Changeset c79e4aea


Ignore:
Timestamp:
Mar 17, 2015 6:49:37 PM (6 years ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
64faeef
Parents:
819b07a5 (diff), 8b6a86e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

propagate from branch 'i2p.i2p' (head 97716ce246bcbee153cf1a28253bac2385ddf7be)

to branch 'i2p.i2p.zzz.upnp' (head e508f71db90f382080b98d11efbdb4d88c1bc406)

Location:
router/java/src/org/cybergarage
Files:
1 added
24 edited

Legend:

Unmodified
Added
Removed
  • router/java/src/org/cybergarage/http/HTTP.java

    r819b07a5 rc79e4aea  
    7070        public static final String CHARSET = "charset";
    7171        public static final String CONTENT_LENGTH = "Content-Length";
     72        public static final String CONTENT_LANGUAGE = "Content-Language";
    7273        public static final String CONTENT_RANGE = "Content-Range";
    7374        public static final String CONTENT_RANGE_BYTES = "bytes";
    74         // Thanks for Brent Hills (10/20/04)
    7575        public static final String RANGE = "Range";
    7676        public static final String TRANSFER_ENCODING = "Transfer-Encoding";
     
    7878        public static final String LOCATION = "Location";
    7979        public static final String SERVER = "Server";
    80 
    81                  
     80       
    8281        public static final String ST = "ST";
    8382        public static final String MX = "MX";
     
    9190        public final static String CALLBACK = "CALLBACK";
    9291        public final static String TIMEOUT = "TIMEOUT";
     92       
     93        public final static String BOOTID_UPNP_ORG = "BOOTID.UPNP.ORG";
     94       
    9395        // Thanks for Brent Hills (10/20/04)
    9496        public final static String MYNAME = "MYNAME";
  • router/java/src/org/cybergarage/http/HTTPPacket.java

    r819b07a5 rc79e4aea  
    612612
    613613        ////////////////////////////////////////////////
     614        //      ContentLanguage
     615        ////////////////////////////////////////////////
     616
     617        public void setContentLanguage(String code)
     618        {
     619                setHeader(HTTP.CONTENT_LANGUAGE, code);
     620        }
     621
     622        public String getContentLanguage()
     623        {
     624                return getHeaderValue(HTTP.CONTENT_LANGUAGE);
     625        }
     626       
     627        ////////////////////////////////////////////////
    614628        //      Charset
    615629        ////////////////////////////////////////////////
  • router/java/src/org/cybergarage/soap/SOAPResponse.java

    r819b07a5 rc79e4aea  
    3535        {
    3636                setRootNode(SOAP.createEnvelopeBodyNode());
    37                 setContentType(XML.CONTENT_TYPE);
     37                setContentType(XML.DEFAULT_CONTENT_TYPE);
    3838        }
    3939
     
    4242                super(httpRes);
    4343                setRootNode(SOAP.createEnvelopeBodyNode());
    44                 setContentType(XML.CONTENT_TYPE);
     44                setContentType(XML.DEFAULT_CONTENT_TYPE);
    4545        }
    4646
     
    4949                super(soapRes);
    5050                setEnvelopeNode(soapRes.getEnvelopeNode());
    51                 setContentType(XML.CONTENT_TYPE);
     51                setContentType(XML.DEFAULT_CONTENT_TYPE);
    5252        }
    5353
  • router/java/src/org/cybergarage/upnp/ActionList.java

    r819b07a5 rc79e4aea  
    1818import java.util.Vector;
    1919
    20 public class ActionList extends Vector<Action> 
     20public class ActionList extends Vector<Action>
    2121{
    2222        ////////////////////////////////////////////////
  • router/java/src/org/cybergarage/upnp/Device.java

    r819b07a5 rc79e4aea  
    11/******************************************************************
    2 *
    3 *       CyberLink for Java
    4 *
    5 *       Copyright (C) Satoshi Konno 2002-2004
    6 *
    7 *       File: Device.java
    8 *
    9 *       Revision:
    10 *
    11 *       11/28/02
    12 *               - first revision.
    13 *       02/26/03
    14 *               - URLBase is updated automatically.
    15 *               - Description of a root device is returned from the XML node tree.
    16 *       05/13/03
    17 *               - URLBase is updated when the request is received.
    18 *               - Changed to create socket threads each local interfaces.
    19 *                 (HTTP, SSDPSearch)
    20 *       06/17/03
    21 *               - Added notify all state variables when a new subscription is received.
    22 *       06/18/03
    23 *               - Fixed a announce bug when the bind address is null on J2SE v 1.4.1_02 and Redhat 9.
    24 *       09/02/03
    25 *               - Giordano Sassaroli <sassarol@cefriel.it>
    26 *               - Problem : bad request response sent even with successful subscriptions
    27 *               - Error : a return statement is missing in the httpRequestRecieved method
    28 *       10/21/03
    29 *               - Updated a udn field by a original uuid.
    30 *       10/22/03
    31 *               - Added setActionListener().
    32 *               - Added setQueryListener().
    33 *       12/12/03
    34 *               - Added a static() to initialize UPnP class.
    35 *       12/25/03
    36 *               - Added advertiser functions.
    37 *       01/05/04
    38 *               - Added isExpired().
    39 *       03/23/04
    40 *               - Oliver Newell <newell@media-rush.com>
    41 *               - Changed to update the UDN only when the field is null.
    42 *       04/21/04
    43 *               - Added isDeviceType().
    44 *       06/18/04
    45 *               - Added setNMPRMode() and isNMPRMode().
    46 *               - Changed getDescriptionData() to update only when the NMPR mode is false.
    47 *       06/21/04
    48 *               - Changed start() to send a bye-bye before the announce.
    49 *               - Changed annouce(), byebye() and deviceSearchReceived() to send the SSDP
    50 *                 messsage four times when the NMPR and the Wireless mode are true.
    51 *       07/02/04
    52 *               - Fixed announce() and byebye() to send the upnp::rootdevice message despite embedded devices.
    53 *               - Fixed getRootNode() to return the root node when the device is embedded.
    54 *       07/24/04
    55 *               - Thanks for Stefano Lenzi <kismet-sl@users.sourceforge.net>
    56 *               - Added getParentDevice().
    57 *       10/20/04
    58 *               - Brent Hills <bhills@openshores.com>
    59 *               - Changed postSearchResponse() to add MYNAME header.
    60 *       11/19/04
    61 *               - Theo Beisch <theo.beisch@gmx.de>
    62 *               - Added getStateVariable(String serviceType, String name).
    63 *       03/22/05
    64 *               - Changed httpPostRequestRecieved() to return the bad request when the post request isn't the soap action.
    65 *       03/23/05
    66 *               - Added loadDescription(String) to load the description from memory.
    67 *       03/30/05
    68 *               - Added getDeviceByDescriptionURI().
    69 *               - Added getServiceBySCPDURL().
    70 *       03/31/05
    71 *               - Changed httpGetRequestRecieved() to return the description stream using
    72 *                 Device::getDescriptionData() and Service::getSCPDData() at first.
    73 *       04/25/05
    74 *               - Thanks for Mikael Hakman <mhakman@dkab.net>
    75 *                 Changed announce() and byebye() to close the socket after the posting.
    76 *       04/25/05
    77 *               - Thanks for Mikael Hakman <mhakman@dkab.net>
    78 *                 Changed deviceSearchResponse() answer with USN:UDN::<device-type> when request ST is device type.
    79 *       04/25/05
    80 *               - Thanks for Mikael Hakman <mhakman@dkab.net>
    81 *               - Changed getDescriptionData() to add a XML declaration at first line.
    82 *       04/25/05
    83 *               - Thanks for Mikael Hakman <mhakman@dkab.net>
    84 *               - Added a new setActionListener() and serQueryListner() to include the sub devices.
    85 *       07/24/05
    86 *               - Thanks for Stefano Lenzi <kismet-sl@users.sourceforge.net>
    87 *               - Fixed a bug of getParentDevice() to return the parent device normally.
    88 *       02/21/06
    89 *               - Changed httpRequestRecieved() not to ignore HEAD requests.
    90 *       04/12/06
    91 *               - Added setUserData() and getUserData() to set a user original data object.
    92 *       03/29/08
    93 *               - Added isRunning() to know whether the device is running.
    94 *
    95 ******************************************************************/
     2 *
     3 *      CyberLink for Java
     4 *
     5 *      Copyright (C) Satoshi Konno 2002-2004
     6 *
     7 *      File: Device.java
     8 *
     9 *      Revision:
     10 *
     11 *      11/28/02
     12 *              - first revision.
     13 *      02/26/03
     14 *              - URLBase is updated automatically.
     15 *              - Description of a root device is returned from the XML node tree.
     16 *      05/13/03
     17 *              - URLBase is updated when the request is received.
     18 *              - Changed to create socket threads each local interfaces.
     19 *                (HTTP, SSDPSearch)
     20 *      06/17/03
     21 *              - Added notify all state variables when a new subscription is received.
     22 *      06/18/03
     23 *              - Fixed a announce bug when the bind address is null on J2SE v 1.4.1_02 and Redhat 9.
     24 *      09/02/03
     25 *              - Giordano Sassaroli <sassarol@cefriel.it>
     26 *              - Problem : bad request response sent even with successful subscriptions
     27 *              - Error : a return statement is missing in the httpRequestRecieved method
     28 *      10/21/03
     29 *              - Updated a udn field by a original uuid.
     30 *      10/22/03
     31 *              - Added setActionListener().
     32 *              - Added setQueryListener().
     33 *      12/12/03
     34 *              - Added a static() to initialize UPnP class.
     35 *      12/25/03
     36 *              - Added advertiser functions.
     37 *      01/05/04
     38 *              - Added isExpired().
     39 *      03/23/04
     40 *              - Oliver Newell <newell@media-rush.com>
     41 *              - Changed to update the UDN only when the field is null.
     42 *      04/21/04
     43 *              - Added isDeviceType().
     44 *      06/18/04
     45 *              - Added setNMPRMode() and isNMPRMode().
     46 *              - Changed getDescriptionData() to update only when the NMPR mode is false.
     47 *      06/21/04
     48 *              - Changed start() to send a bye-bye before the announce.
     49 *              - Changed annouce(), byebye() and deviceSearchReceived() to send the SSDP
     50 *                messsage four times when the NMPR and the Wireless mode are true.
     51 *      07/02/04
     52 *              - Fixed announce() and byebye() to send the upnp::rootdevice message despite embedded devices.
     53 *              - Fixed getRootNode() to return the root node when the device is embedded.
     54 *      07/24/04
     55 *              - Thanks for Stefano Lenzi <kismet-sl@users.sourceforge.net>
     56 *              - Added getParentDevice().
     57 *      10/20/04
     58 *              - Brent Hills <bhills@openshores.com>
     59 *              - Changed postSearchResponse() to add MYNAME header.
     60 *      11/19/04
     61 *              - Theo Beisch <theo.beisch@gmx.de>
     62 *              - Added getStateVariable(String serviceType, String name).
     63 *      03/22/05
     64 *              - Changed httpPostRequestRecieved() to return the bad request when the post request isn't the soap action.
     65 *      03/23/05
     66 *              - Added loadDescription(String) to load the description from memory.
     67 *      03/30/05
     68 *              - Added getDeviceByDescriptionURI().
     69 *              - Added getServiceBySCPDURL().
     70 *      03/31/05
     71 *              - Changed httpGetRequestRecieved() to return the description stream using
     72 *                Device::getDescriptionData() and Service::getSCPDData() at first.
     73 *      04/25/05
     74 *              - Thanks for Mikael Hakman <mhakman@dkab.net>
     75 *                Changed announce() and byebye() to close the socket after the posting.
     76 *      04/25/05
     77 *              - Thanks for Mikael Hakman <mhakman@dkab.net>
     78 *                Changed deviceSearchResponse() answer with USN:UDN::<device-type> when request ST is device type.
     79 *      04/25/05
     80 *              - Thanks for Mikael Hakman <mhakman@dkab.net>
     81 *              - Changed getDescriptionData() to add a XML declaration at first line.
     82 *      04/25/05
     83 *              - Thanks for Mikael Hakman <mhakman@dkab.net>
     84 *              - Added a new setActionListener() and serQueryListner() to include the sub devices.
     85 *      07/24/05
     86 *              - Thanks for Stefano Lenzi <kismet-sl@users.sourceforge.net>
     87 *              - Fixed a bug of getParentDevice() to return the parent device normally.
     88 *      02/21/06
     89 *              - Changed httpRequestRecieved() not to ignore HEAD requests.
     90 *      04/12/06
     91 *              - Added setUserData() and getUserData() to set a user original data object.
     92 *      03/29/08
     93 *              - Added isRunning() to know whether the device is running.
     94 *
     95 ******************************************************************/
    9696
    9797package org.cybergarage.upnp;
     
    102102import java.net.URL;
    103103import java.util.Calendar;
     104import java.util.HashMap;
    104105
    105106import org.cybergarage.http.HTTP;
     
    124125import org.cybergarage.upnp.device.SearchListener;
    125126import org.cybergarage.upnp.device.USN;
     127import org.cybergarage.upnp.device.PresentationListener;
    126128import org.cybergarage.upnp.event.Subscriber;
    127129import org.cybergarage.upnp.event.Subscription;
     
    144146import org.cybergarage.xml.XML;
    145147
    146 public class Device implements org.cybergarage.http.HTTPRequestListener, SearchListener
    147 {
    148         ////////////////////////////////////////////////
    149         //      Constants
    150         ////////////////////////////////////////////////
    151        
     148public class Device implements org.cybergarage.http.HTTPRequestListener,
     149                SearchListener {
     150        // //////////////////////////////////////////////
     151        // Constants
     152        // //////////////////////////////////////////////
     153
    152154        public final static String ELEM_NAME = "device";
    153155        public final static String UPNP_ROOTDEVICE = "upnp:rootdevice";
     
    160162
    161163        public final static String DEFAULT_DESCRIPTION_URI = "/description.xml";
    162        
    163         ////////////////////////////////////////////////
    164         //      Member
    165         ////////////////////////////////////////////////
     164        public final static String DEFAULT_PRESENTATION_URI = "/presentation";
     165
     166        // //////////////////////////////////////////////
     167        // Member
     168        // //////////////////////////////////////////////
    166169
    167170        private Node rootNode;
    168171        private Node deviceNode;
    169172
    170         public Node getRootNode()
    171         {
     173        public Node getRootNode() {
    172174                if (rootNode != null)
    173175                        return rootNode;
     
    177179        }
    178180
    179         public Node getDeviceNode()
    180         {
     181        public Node getDeviceNode() {
    181182                return deviceNode;
    182183        }
    183184
    184         public void setRootNode(Node node)
    185         {
     185        public void setRootNode(Node node) {
    186186                rootNode = node;
    187187        }
    188188
    189         public void setDeviceNode(Node node)
    190         {
     189        public void setDeviceNode(Node node) {
    191190                deviceNode = node;
    192191        }
    193                                
    194         ////////////////////////////////////////////////
    195         //      Initialize
    196         ////////////////////////////////////////////////
    197        
    198         static
    199         {
     192
     193        // //////////////////////////////////////////////
     194        // Initialize
     195        // //////////////////////////////////////////////
     196
     197        static {
    200198                UPnP.initialize();
    201199        }
    202        
    203         ////////////////////////////////////////////////
    204         //      Constructor
    205         ////////////////////////////////////////////////
    206 
    207         public Device(Node root, Node device)
    208         {
     200
     201        // //////////////////////////////////////////////
     202        // Constructor
     203        // //////////////////////////////////////////////
     204
     205        public Device(Node root, Node device) {
    209206                rootNode = root;
    210207                deviceNode = device;
     
    213210        }
    214211
    215         public Device()
    216         {
     212        public Device() {
    217213                this(null, null);
    218214        }
    219        
    220         public Device(Node device)
    221         {
     215
     216        public Device(Node device) {
    222217                this(null, device);
    223218        }
    224219
    225         public Device(File descriptionFile) throws InvalidDescriptionException
    226         {
     220        public Device(File descriptionFile) throws InvalidDescriptionException {
    227221                this(null, null);
    228222                loadDescription(descriptionFile);
     
    232226         * @since 1.8.0
    233227         */
    234         public Device(InputStream input) throws InvalidDescriptionException
    235         {
     228        public Device(InputStream input) throws InvalidDescriptionException {
    236229                this(null, null);
    237230                loadDescription(input);
    238231        }
    239232
    240        
    241         public Device(String descriptionFileName) throws InvalidDescriptionException
    242         {
     233        public Device(String descriptionFileName)
     234                        throws InvalidDescriptionException {
    243235                this(new File(descriptionFileName));
    244236        }
    245237
    246         ////////////////////////////////////////////////
     238        // //////////////////////////////////////////////
    247239        // Mutex
    248         ////////////////////////////////////////////////
    249        
     240        // //////////////////////////////////////////////
     241
    250242        private Mutex mutex = new Mutex();
    251        
    252         public void lock()
    253         {
     243
     244        public void lock() {
    254245                mutex.lock();
    255246        }
    256        
    257         public void unlock()
    258         {
     247
     248        public void unlock() {
    259249                mutex.unlock();
    260250        }
    261        
    262         ////////////////////////////////////////////////
    263         //      getAbsoluteURL
    264         ////////////////////////////////////////////////
    265        
    266         public String getAbsoluteURL(String urlString)
    267         {
     251
     252        // //////////////////////////////////////////////
     253        // getAbsoluteURL
     254        // //////////////////////////////////////////////
     255
     256        public String getAbsoluteURL(String urlString, String baseURLStr,
     257                        String locationURLStr) {
     258                if ((urlString == null) || (urlString.length() <= 0))
     259                        return "";
     260
    268261                try {
    269262                        URL url = new URL(urlString);
    270263                        return url.toString();
    271                 }
    272                 catch (Exception e) {}
    273                
     264                } catch (Exception e) {
     265                }
     266
     267                if ((baseURLStr == null) || (baseURLStr.length() <= 0)) {
     268                        if ((locationURLStr != null) && (0 < locationURLStr.length())) {
     269                                if (!locationURLStr.endsWith("/") || !urlString.startsWith("/")) {
     270                                        String absUrl = locationURLStr + urlString;
     271                                        try {
     272                                                URL url = new URL(absUrl);
     273                                                return url.toString();
     274                                        } catch (Exception e) {
     275                                        }
     276                                } else {
     277                                        String absUrl = locationURLStr + urlString.substring(1);
     278                                        try {
     279                                                URL url = new URL(absUrl);
     280                                                return url.toString();
     281                                        } catch (Exception e) {
     282                                        }
     283                                }
     284
     285                                String absUrl = HTTP.getAbsoluteURL(locationURLStr, urlString);
     286                                try {
     287                                        URL url = new URL(absUrl);
     288                                        return url.toString();
     289                                } catch (Exception e) {
     290                                }
     291
     292                                // Thanks for Steven Yen (2003/09/03)
     293                                Device rootDev = getRootDevice();
     294                                if (rootDev != null) {
     295                                        String location = rootDev.getLocation();
     296                                        String locationHost = HTTP.getHost(location);
     297                                        int locationPort = HTTP.getPort(location);
     298                                        baseURLStr = HTTP.getRequestHostURL(locationHost,
     299                                                        locationPort);
     300                                }
     301                        }
     302                }
     303
     304                if ((baseURLStr != null) && (0 < baseURLStr.length())) {
     305                        if (!baseURLStr.endsWith("/") || !urlString.startsWith("/")) {
     306                                String absUrl = baseURLStr + urlString;
     307                                try {
     308                                        URL url = new URL(absUrl);
     309                                        return url.toString();
     310                                } catch (Exception e) {
     311                                }
     312                        } else {
     313                                String absUrl = baseURLStr + urlString.substring(1);
     314                                try {
     315                                        URL url = new URL(absUrl);
     316                                        return url.toString();
     317                                } catch (Exception e) {
     318                                }
     319                        }
     320
     321                        String absUrl = HTTP.getAbsoluteURL(baseURLStr, urlString);
     322                        try {
     323                                URL url = new URL(absUrl);
     324                                return url.toString();
     325                        } catch (Exception e) {
     326                        }
     327                }
     328
     329                return urlString;
     330        }
     331
     332        public String getAbsoluteURL(String urlString) {
     333                String baseURLStr = null;
     334                String locationURLStr = null;
     335
    274336                Device rootDev = getRootDevice();
    275                 String urlBaseStr = rootDev.getURLBase();
    276                
    277                 // Thanks for Steven Yen (2003/09/03)
    278                 if (urlBaseStr == null || urlBaseStr.length() <= 0) {
    279                         String location = rootDev.getLocation();
    280                         String locationHost = HTTP.getHost(location);
    281                         int locationPort = HTTP.getPort(location);
    282                         urlBaseStr = HTTP.getRequestHostURL(locationHost, locationPort);
    283                 }
    284 
    285                 urlString = HTTP.toRelativeURL(urlString);
    286                 // I2P fix for devices that return a base URL with trailing /
    287                 if (urlBaseStr.endsWith("/") && urlString.startsWith("/"))
    288                         urlString = urlString.substring(1);
    289                 String absUrl = urlBaseStr + urlString;
    290                 try {
    291                         URL url = new URL(absUrl);
    292                         return url.toString();
    293                 }
    294                 catch (Exception e) {}
    295                        
    296                 absUrl = HTTP.getAbsoluteURL(urlBaseStr, urlString);
    297                 try {
    298                         URL url = new URL(absUrl);
    299                         return url.toString();
    300                 }
    301                 catch (Exception e) {}
    302                
    303                 return "";
    304         }
    305 
    306         ////////////////////////////////////////////////
    307         //      NMPR
    308         ////////////////////////////////////////////////
    309        
    310         public void setNMPRMode(boolean flag)
    311         {
     337                if (rootDev != null) {
     338                        baseURLStr = rootDev.getURLBase();
     339                        locationURLStr = rootDev.getLocation();
     340                }
     341
     342                return getAbsoluteURL(urlString, baseURLStr, locationURLStr);
     343        }
     344
     345        // //////////////////////////////////////////////
     346        // NMPR
     347        // //////////////////////////////////////////////
     348
     349        public void setNMPRMode(boolean flag) {
    312350                Node devNode = getDeviceNode();
    313351                if (devNode == null)
     
    316354                        devNode.setNode(UPnP.INMPR03, UPnP.INMPR03_VERSION);
    317355                        devNode.removeNode(Device.URLBASE_NAME);
    318                 }
    319                 else {
     356                } else {
    320357                        devNode.removeNode(UPnP.INMPR03);
    321358                }
    322359        }
    323360
    324         public boolean isNMPRMode()
    325         {
     361        public boolean isNMPRMode() {
    326362                Node devNode = getDeviceNode();
    327363                if (devNode == null)
     
    329365                return (devNode.getNode(UPnP.INMPR03) != null) ? true : false;
    330366        }
    331        
    332         ////////////////////////////////////////////////
    333         //      Wireless
    334         ////////////////////////////////////////////////
    335        
     367
     368        // //////////////////////////////////////////////
     369        // Wireless
     370        // //////////////////////////////////////////////
     371
    336372        private boolean wirelessMode;
    337        
    338         public void setWirelessMode(boolean flag)
    339         {
     373
     374        public void setWirelessMode(boolean flag) {
    340375                wirelessMode = flag;
    341376        }
    342377
    343         public boolean isWirelessMode()
    344         {
     378        public boolean isWirelessMode() {
    345379                return wirelessMode;
    346380        }
    347381
    348         public int getSSDPAnnounceCount()
    349         {
     382        public int getSSDPAnnounceCount() {
    350383                if (isNMPRMode() == true && isWirelessMode() == true)
    351384                        return UPnP.INMPR03_DISCOVERY_OVER_WIRELESS_COUNT;
     
    353386        }
    354387
    355         ////////////////////////////////////////////////
    356         //      Device UUID
    357         ////////////////////////////////////////////////
     388        // //////////////////////////////////////////////
     389        // Device UUID
     390        // //////////////////////////////////////////////
    358391
    359392        private String devUUID;
    360        
    361         private void setUUID(String uuid)
    362         {
    363                 devUUID = uuid;
    364         }
    365        
    366         private String getUUID()
    367         {
    368                 return devUUID;
    369         }
    370        
    371         private void updateUDN()
    372         {
    373                 setUDN("uuid:" + getUUID());   
    374         }
    375        
    376         ////////////////////////////////////////////////
    377         //      Root Device
    378         ////////////////////////////////////////////////
    379        
    380         public Device getRootDevice()
    381         {
     393
     394        private void setUUID(String uuid) {
     395                this.devUUID = uuid;
     396        }
     397
     398        public String getUUID() {
     399                return this.devUUID;
     400        }
     401
     402        private void updateUDN() {
     403                setUDN("uuid:" + getUUID());
     404        }
     405
     406        // //////////////////////////////////////////////
     407        // BootId
     408        // //////////////////////////////////////////////
     409
     410        private int bootId;
     411
     412        private void updateBootId() {
     413                this.bootId = UPnP.createBootId();
     414        }
     415
     416        public int getBootId() {
     417                return this.bootId;
     418        }
     419
     420        // //////////////////////////////////////////////
     421        // configID
     422        // //////////////////////////////////////////////
     423
     424        private final static String CONFIG_ID = "configId";
     425
     426        private void updateConfigId(Device dev) {
     427                int configId = 0;
     428
     429                DeviceList cdevList = dev.getDeviceList();
     430                int cdevCnt = cdevList.size();
     431                for (int n = 0; n < cdevCnt; n++) {
     432                        Device cdev = cdevList.getDevice(n);
     433                        updateConfigId(cdev);
     434                        configId += cdev.getConfigId();
     435                        configId &= UPnP.CONFIGID_UPNP_ORG_MAX;
     436                }
     437
     438                ServiceList serviceList = dev.getServiceList();
     439                int serviceCnt = serviceList.size();
     440                for (int n = 0; n < serviceCnt; n++) {
     441                        Service service = serviceList.getService(n);
     442                        service.updateConfigId();
     443                        configId += service.getConfigId();
     444                        configId &= UPnP.CONFIGID_UPNP_ORG_MAX;
     445                }
     446
     447                Node devNode = getDeviceNode();
     448                if (devNode == null)
     449                        return;
     450
     451                String devDescXml = devNode.toString();
     452                configId += UPnP.caluculateConfigId(devDescXml);
     453                configId &= UPnP.CONFIGID_UPNP_ORG_MAX;
     454                devNode.setAttribute(CONFIG_ID, configId);
     455        }
     456
     457        public void updateConfigId() {
     458                updateConfigId(this);
     459        }
     460
     461        public int getConfigId() {
     462                Node devNode = getDeviceNode();
     463                if (devNode == null)
     464                        return 0;
     465                return devNode.getAttributeIntegerValue(CONFIG_ID);
     466        }
     467
     468        // //////////////////////////////////////////////
     469        // Root Device
     470        // //////////////////////////////////////////////
     471
     472        public Device getRootDevice() {
    382473                Node rootNode = getRootNode();
    383474                if (rootNode == null)
     
    389480        }
    390481
    391         ////////////////////////////////////////////////
    392         //      Parent Device
    393         ////////////////////////////////////////////////
    394        
     482        // //////////////////////////////////////////////
     483        // Parent Device
     484        // //////////////////////////////////////////////
     485
    395486        // Thanks for Stefano Lenzi (07/24/04)
    396487
     
    398489         *
    399490         * @return A Device that contain this object.<br>
    400          *      Return <code>null</code> if this is a root device.
     491         *         Return <code>null</code> if this is a root device.
     492         * @author Stefano "Kismet" Lenzi
    401493         */
    402         public Device getParentDevice() {
    403                 if(isRootDevice())
     494        public Device getParentDevice() {
     495                if (isRootDevice())
    404496                        return null;
    405497                Node devNode = getDeviceNode();
    406498                Node aux = null;
    407                 //<device><deviceList><device>
     499                // <device><deviceList><device>
    408500                aux = devNode.getParentNode().getParentNode();
    409501                return new Device(aux);
    410502        }
     503
    411504        /**
    412505         * Add a Service to device without checking for duplicate or syntax error
    413506         *
    414          * @param s Add Service s to the Device
     507         * @param s
     508         *            Add Service s to the Device
    415509         */
    416510        public void addService(Service s) {
     
    428522         * <br>
    429523         * Note: This method should be used to create a dynamic<br>
    430          * Device withtout writing any XML that describe the device<br>.
     524         * Device withtout writing any XML that describe the device<br>
     525         * .
     526         *
     527         * @param d
     528         *            Add Device d to the Device
     529         *
     530         * @author Stefano "Kismet" Lenzi - kismet-sl@users.sourceforge.net - 2005
    431531         *
    432532         * @param d Add Device d to the Device
     
    435535                Node deviceListNode = getDeviceNode().getNode(DeviceList.ELEM_NAME);
    436536                if (deviceListNode == null) {
    437                         //deviceListNode = new Node(ServiceList.ELEM_NAME); twa wrong ELEM_NAME;
     537                        // deviceListNode = new Node(ServiceList.ELEM_NAME); twa wrong
     538                        // ELEM_NAME;
    438539                        deviceListNode = new Node(DeviceList.ELEM_NAME);
    439540                        getDeviceNode().addNode(deviceListNode);
     
    441542                deviceListNode.addNode(d.getDeviceNode());
    442543                d.setRootNode(null);
    443                 if(getRootNode()==null){
     544                if (getRootNode() == null) {
    444545                        Node root = new Node(RootDescription.ROOT_ELEMENT);
    445                         root.setNameSpace("",RootDescription.ROOT_ELEMENT_NAMESPACE);
     546                        root.setNameSpace("", RootDescription.ROOT_ELEMENT_NAMESPACE);
    446547                        Node spec = new Node(RootDescription.SPECVERSION_ELEMENT);
    447                         Node maj =new Node(RootDescription.MAJOR_ELEMENT);
     548                        Node maj = new Node(RootDescription.MAJOR_ELEMENT);
    448549                        maj.setValue("1");
    449                         Node min =new Node(RootDescription.MINOR_ELEMENT);
     550                        Node min = new Node(RootDescription.MINOR_ELEMENT);
    450551                        min.setValue("0");
    451552                        spec.addNode(maj);
    452553                        spec.addNode(min);
    453                         root.addNode(spec);             
     554                        root.addNode(spec);
    454555                        setRootNode(root);
    455                 }                       
    456         }       
    457        
    458 
    459         ////////////////////////////////////////////////
    460         //      UserData
    461         ////////////////////////////////////////////////
    462 
    463         private DeviceData getDeviceData()
    464         {
     556                }
     557        }
     558
     559        // //////////////////////////////////////////////
     560        // UserData
     561        // //////////////////////////////////////////////
     562
     563        private DeviceData getDeviceData() {
    465564                Node node = getDeviceNode();
    466                 DeviceData userData = (DeviceData)node.getUserData();
     565                DeviceData userData = (DeviceData) node.getUserData();
    467566                if (userData == null) {
    468567                        userData = new DeviceData();
     
    472571                return userData;
    473572        }
    474        
    475         ////////////////////////////////////////////////
    476         //      Description
    477         ////////////////////////////////////////////////
    478 
    479         private void setDescriptionFile(File file)
    480         {
     573
     574        // //////////////////////////////////////////////
     575        // Description
     576        // //////////////////////////////////////////////
     577
     578        private void setDescriptionFile(File file) {
    481579                getDeviceData().setDescriptionFile(file);
    482580        }
    483581
    484         public File getDescriptionFile()
    485         {
     582        public File getDescriptionFile() {
    486583                return getDeviceData().getDescriptionFile();
    487584        }
    488585
    489         private void setDescriptionURI(String uri)
    490         {
     586        private void setDescriptionURI(String uri) {
    491587                getDeviceData().setDescriptionURI(uri);
    492588        }
    493589
    494         private String getDescriptionURI()
    495         {
     590        private String getDescriptionURI() {
    496591                return getDeviceData().getDescriptionURI();
    497592        }
    498593
    499         private boolean isDescriptionURI(String uri)
    500         {
     594        private boolean isDescriptionURI(String uri) {
    501595                String descriptionURI = getDescriptionURI();
    502596                if (uri == null || descriptionURI == null)
     
    505599        }
    506600
    507         public String getDescriptionFilePath()
    508         {
     601        public String getDescriptionFilePath() {
    509602                File descriptionFile = getDescriptionFile();
    510603                if (descriptionFile == null)
     
    512605                return descriptionFile.getAbsoluteFile().getParent();
    513606        }
    514        
     607
    515608        /**
    516609         * @since 1.8.0
    517610         */
    518         public boolean loadDescription(InputStream input) throws InvalidDescriptionException
    519         {
     611        public boolean loadDescription(InputStream input)
     612                        throws InvalidDescriptionException {
    520613                try {
    521614                        Parser parser = UPnP.getXMLParser();
    522615                        rootNode = parser.parse(input);
    523616                        if (rootNode == null)
    524                                 throw new InvalidDescriptionException(Description.NOROOT_EXCEPTION);
     617                                throw new InvalidDescriptionException(
     618                                                Description.NOROOT_EXCEPTION);
    525619                        deviceNode = rootNode.getNode(Device.ELEM_NAME);
    526620                        if (deviceNode == null)
    527                                 throw new InvalidDescriptionException(Description.NOROOTDEVICE_EXCEPTION);
    528                 }
    529                 catch (ParserException e) {
     621                                throw new InvalidDescriptionException(
     622                                                Description.NOROOTDEVICE_EXCEPTION);
     623                } catch (ParserException e) {
    530624                        throw new InvalidDescriptionException(e);
    531625                }
    532                
     626
    533627                if (initializeLoadedDescription() == false)
    534628                        return false;
    535629
    536630                setDescriptionFile(null);
    537                                
     631
    538632                return true;
    539         }       
    540 
    541         public boolean loadDescription(String descString) throws InvalidDescriptionException
    542         {
     633        }
     634
     635        public boolean loadDescription(String descString)
     636                        throws InvalidDescriptionException {
    543637                try {
    544638                        Parser parser = UPnP.getXMLParser();
    545639                        rootNode = parser.parse(descString);
    546640                        if (rootNode == null)
    547                                 throw new InvalidDescriptionException(Description.NOROOT_EXCEPTION);
     641                                throw new InvalidDescriptionException(
     642                                                Description.NOROOT_EXCEPTION);
    548643                        deviceNode = rootNode.getNode(Device.ELEM_NAME);
    549644                        if (deviceNode == null)
    550                                 throw new InvalidDescriptionException(Description.NOROOTDEVICE_EXCEPTION);
    551                 }
    552                 catch (ParserException e) {
     645                                throw new InvalidDescriptionException(
     646                                                Description.NOROOTDEVICE_EXCEPTION);
     647                } catch (ParserException e) {
    553648                        throw new InvalidDescriptionException(e);
    554649                }
    555                
     650
    556651                if (initializeLoadedDescription() == false)
    557652                        return false;
    558653
    559654                setDescriptionFile(null);
    560                                
     655
    561656                return true;
    562657        }
    563        
    564         public boolean loadDescription(File file) throws InvalidDescriptionException
    565         {
     658
     659        public boolean loadDescription(File file)
     660                        throws InvalidDescriptionException {
    566661                try {
    567662                        Parser parser = UPnP.getXMLParser();
    568663                        rootNode = parser.parse(file);
    569664                        if (rootNode == null)
    570                                 throw new InvalidDescriptionException(Description.NOROOT_EXCEPTION, file);
     665                                throw new InvalidDescriptionException(
     666                                                Description.NOROOT_EXCEPTION, file);
    571667                        deviceNode = rootNode.getNode(Device.ELEM_NAME);
    572668                        if (deviceNode == null)
    573                                 throw new InvalidDescriptionException(Description.NOROOTDEVICE_EXCEPTION, file);
    574                 }
    575                 catch (ParserException e) {
     669                                throw new InvalidDescriptionException(
     670                                                Description.NOROOTDEVICE_EXCEPTION, file);
     671                } catch (ParserException e) {
    576672                        throw new InvalidDescriptionException(e);
    577673                }
    578                
     674
    579675                if (initializeLoadedDescription() == false)
    580676                        return false;
    581677
    582678                setDescriptionFile(file);
    583                                
     679
    584680                return true;
    585681        }
    586682
    587         private boolean initializeLoadedDescription()
    588         {
     683        private boolean initializeLoadedDescription() {
    589684                setDescriptionURI(DEFAULT_DESCRIPTION_URI);
    590685                setLeaseTime(DEFAULT_LEASE_TIME);
     
    594689                if (hasUDN() == false)
    595690                        updateUDN();
    596                                
     691
    597692                return true;
    598693        }
    599        
    600         ////////////////////////////////////////////////
    601         //      isDeviceNode
    602         ////////////////////////////////////////////////
    603 
    604         public static boolean isDeviceNode(Node node)
    605         {
     694
     695        // //////////////////////////////////////////////
     696        // isDeviceNode
     697        // //////////////////////////////////////////////
     698
     699        public static boolean isDeviceNode(Node node) {
    606700                return Device.ELEM_NAME.equals(node.getName());
    607701        }
    608        
    609         ////////////////////////////////////////////////
    610         //      Root Device
    611         ////////////////////////////////////////////////
    612 
    613         public boolean isRootDevice(){
    614                 return getRootNode().getNode("device").getNodeValue(UDN).equals(getUDN());
    615         }
    616        
    617         ////////////////////////////////////////////////
    618         //      Root Device
    619         ////////////////////////////////////////////////
    620 
    621         public void setSSDPPacket(SSDPPacket packet)
    622         {
     702
     703        // //////////////////////////////////////////////
     704        // Root Device
     705        // //////////////////////////////////////////////
     706
     707        public boolean isRootDevice() {
     708                return getRootNode().getNode("device").getNodeValue(UDN)
     709                                .equals(getUDN());
     710        }
     711
     712        // //////////////////////////////////////////////
     713        // Root Device
     714        // //////////////////////////////////////////////
     715
     716        public void setSSDPPacket(SSDPPacket packet) {
    623717                getDeviceData().setSSDPPacket(packet);
    624718        }
    625719
    626         public SSDPPacket getSSDPPacket()
    627         {
     720        public SSDPPacket getSSDPPacket() {
    628721                if (isRootDevice() == false)
    629722                        return null;
    630723                return getDeviceData().getSSDPPacket();
    631724        }
    632        
    633         ////////////////////////////////////////////////
    634         //      Location
    635         ////////////////////////////////////////////////
    636 
    637         public void setLocation(String value)
    638         {
     725
     726        // //////////////////////////////////////////////
     727        // Location
     728        // //////////////////////////////////////////////
     729
     730        public void setLocation(String value) {
    639731                getDeviceData().setLocation(value);
    640732        }
    641733
    642         public String getLocation()
    643         {
     734        public String getLocation() {
    644735                SSDPPacket packet = getSSDPPacket();
    645736                if (packet != null)
     
    648739        }
    649740
    650         ////////////////////////////////////////////////
    651         //      LeaseTime
    652         ////////////////////////////////////////////////
    653 
    654         public void setLeaseTime(int value)
    655         {
     741        // //////////////////////////////////////////////
     742        // LeaseTime
     743        // //////////////////////////////////////////////
     744
     745        public void setLeaseTime(int value) {
    656746                getDeviceData().setLeaseTime(value);
    657747                Advertiser adv = getAdvertiser();
     
    662752        }
    663753
    664         public int getLeaseTime()
    665         {
     754        public int getLeaseTime() {
    666755                SSDPPacket packet = getSSDPPacket();
    667756                if (packet != null)
    668                         return packet.getLeaseTime();   
     757                        return packet.getLeaseTime();
    669758                return getDeviceData().getLeaseTime();
    670759        }
    671760
    672         ////////////////////////////////////////////////
    673         //      TimeStamp
    674         ////////////////////////////////////////////////
    675 
    676         public long getTimeStamp()
    677         {
     761        // //////////////////////////////////////////////
     762        // TimeStamp
     763        // //////////////////////////////////////////////
     764
     765        public long getTimeStamp() {
    678766                SSDPPacket packet = getSSDPPacket();
    679767                if (packet != null)
    680                         return packet.getTimeStamp();           
     768                        return packet.getTimeStamp();
    681769                return 0;
    682770        }
    683771
    684         public long getElapsedTime()
    685         {
     772        public long getElapsedTime() {
    686773                return (System.currentTimeMillis() - getTimeStamp()) / 1000;
    687774        }
    688775
    689         public boolean isExpired()
    690         {
     776        public boolean isExpired() {
    691777                long elipsedTime = getElapsedTime();
    692                 long leaseTime = getLeaseTime() + UPnP.DEFAULT_EXPIRED_DEVICE_EXTRA_TIME;
     778                long leaseTime = getLeaseTime()
     779                                + UPnP.DEFAULT_EXPIRED_DEVICE_EXTRA_TIME;
    693780                if (leaseTime < elipsedTime)
    694781                        return true;
    695782                return false;
    696783        }
    697        
    698         ////////////////////////////////////////////////
    699         //      URL Base
    700         ////////////////////////////////////////////////
     784
     785        // //////////////////////////////////////////////
     786        // URL Base
     787        // //////////////////////////////////////////////
    701788
    702789        private final static String URLBASE_NAME = "URLBase";
    703        
    704         private void setURLBase(String value)
    705         {
     790
     791        private void setURLBase(String value) {
    706792                if (isRootDevice() == true) {
    707793                        Node node = getRootNode().getNode(URLBASE_NAME);
     
    719805        }
    720806
    721         private void updateURLBase(String host)
    722         {
     807        private void updateURLBase(String host) {
    723808                String urlBase = HostInterface.getHostURL(host, getHTTPPort(), "");
    724809                setURLBase(urlBase);
    725810        }
    726  
    727         public String getURLBase()
    728         {
     811
     812        public String getURLBase() {
    729813                if (isRootDevice() == true)
    730814                        return getRootNode().getNodeValue(URLBASE_NAME);
     
    732816        }
    733817
    734         ////////////////////////////////////////////////
    735         //      deviceType
    736         ////////////////////////////////////////////////
     818        // //////////////////////////////////////////////
     819        // deviceType
     820        // //////////////////////////////////////////////
    737821
    738822        private final static String DEVICE_TYPE = "deviceType";
    739        
    740         public void setDeviceType(String value)
    741         {
     823
     824        public void setDeviceType(String value) {
    742825                getDeviceNode().setNode(DEVICE_TYPE, value);
    743826        }
    744827
    745         public String getDeviceType()
    746         {
     828        public String getDeviceType() {
    747829                return getDeviceNode().getNodeValue(DEVICE_TYPE);
    748830        }
    749831
    750         public boolean isDeviceType(String value)
    751         {
     832        public boolean isDeviceType(String value) {
    752833                if (value == null)
    753834                        return false;
     
    755836        }
    756837
    757         ////////////////////////////////////////////////
    758         //      friendlyName
    759         ////////////////////////////////////////////////
     838        // //////////////////////////////////////////////
     839        // friendlyName
     840        // //////////////////////////////////////////////
    760841
    761842        private final static String FRIENDLY_NAME = "friendlyName";
    762        
    763         public void setFriendlyName(String value)
    764         {
     843
     844        public void setFriendlyName(String value) {
    765845                getDeviceNode().setNode(FRIENDLY_NAME, value);
    766846        }
    767847
    768         public String getFriendlyName()
    769         {
     848        public String getFriendlyName() {
    770849                return getDeviceNode().getNodeValue(FRIENDLY_NAME);
    771850        }
    772851
    773         ////////////////////////////////////////////////
    774         //      manufacture
    775         ////////////////////////////////////////////////
     852        // //////////////////////////////////////////////
     853        // manufacture
     854        // //////////////////////////////////////////////
    776855
    777856        private final static String MANUFACTURE = "manufacturer";
    778        
    779         public void setManufacture(String value)
    780         {
     857
     858        public void setManufacture(String value) {
    781859                getDeviceNode().setNode(MANUFACTURE, value);
    782860        }
    783861
    784         public String getManufacture()
    785         {
     862        public String getManufacture() {
    786863                return getDeviceNode().getNodeValue(MANUFACTURE);
    787864        }
    788865
    789         ////////////////////////////////////////////////
    790         //      manufactureURL
    791         ////////////////////////////////////////////////
     866        // //////////////////////////////////////////////
     867        // manufactureURL
     868        // //////////////////////////////////////////////
    792869
    793870        private final static String MANUFACTURE_URL = "manufacturerURL";
    794        
    795         public void setManufactureURL(String value)
    796         {
     871
     872        public void setManufactureURL(String value) {
    797873                getDeviceNode().setNode(MANUFACTURE_URL, value);
    798874        }
    799875
    800         public String getManufactureURL()
    801         {
     876        public String getManufactureURL() {
    802877                return getDeviceNode().getNodeValue(MANUFACTURE_URL);
    803878        }
    804879
    805         ////////////////////////////////////////////////
    806         //      modelDescription
    807         ////////////////////////////////////////////////
     880        // //////////////////////////////////////////////
     881        // modelDescription
     882        // //////////////////////////////////////////////
    808883
    809884        private final static String MODEL_DESCRIPTION = "modelDescription";
    810        
    811         public void setModelDescription(String value)
    812         {
     885
     886        public void setModelDescription(String value) {
    813887                getDeviceNode().setNode(MODEL_DESCRIPTION, value);
    814888        }
    815889
    816         public String getModelDescription()
    817         {
     890        public String getModelDescription() {
    818891                return getDeviceNode().getNodeValue(MODEL_DESCRIPTION);
    819892        }
    820893
    821         ////////////////////////////////////////////////
    822         //      modelName
    823         ////////////////////////////////////////////////
     894        // //////////////////////////////////////////////
     895        // modelName
     896        // //////////////////////////////////////////////
    824897
    825898        private final static String MODEL_NAME = "modelName";
    826        
    827         public void setModelName(String value)
    828         {
     899
     900        public void setModelName(String value) {
    829901                getDeviceNode().setNode(MODEL_NAME, value);
    830902        }
    831903
    832         public String getModelName()
    833         {
     904        public String getModelName() {
    834905                return getDeviceNode().getNodeValue(MODEL_NAME);
    835906        }
    836907
    837         ////////////////////////////////////////////////
    838         //      modelNumber
    839         ////////////////////////////////////////////////
     908        // //////////////////////////////////////////////
     909        // modelNumber
     910        // //////////////////////////////////////////////
    840911
    841912        private final static String MODEL_NUMBER = "modelNumber";
    842        
    843         public void setModelNumber(String value)
    844         {
     913
     914        public void setModelNumber(String value) {
    845915                getDeviceNode().setNode(MODEL_NUMBER, value);
    846916        }
    847917
    848         public String getModelNumber()
    849         {
     918        public String getModelNumber() {
    850919                return getDeviceNode().getNodeValue(MODEL_NUMBER);
    851920        }
    852921
    853         ////////////////////////////////////////////////
    854         //      modelURL
    855         ////////////////////////////////////////////////
     922        // //////////////////////////////////////////////
     923        // modelURL
     924        // //////////////////////////////////////////////
    856925
    857926        private final static String MODEL_URL = "modelURL";
    858        
    859         public void setModelURL(String value)
    860         {
     927
     928        public void setModelURL(String value) {
    861929                getDeviceNode().setNode(MODEL_URL, value);
    862930        }
    863931
    864         public String getModelURL()
    865         {
     932        public String getModelURL() {
    866933                return getDeviceNode().getNodeValue(MODEL_URL);
    867934        }
    868935
    869         ////////////////////////////////////////////////
    870         //      serialNumber
    871         ////////////////////////////////////////////////
     936        // //////////////////////////////////////////////
     937        // serialNumber
     938        // //////////////////////////////////////////////
    872939
    873940        private final static String SERIAL_NUMBER = "serialNumber";
    874        
    875         public void setSerialNumber(String value)
    876         {
     941
     942        public void setSerialNumber(String value) {
    877943                getDeviceNode().setNode(SERIAL_NUMBER, value);
    878944        }
    879945
    880         public String getSerialNumber()
    881         {
     946        public String getSerialNumber() {
    882947                return getDeviceNode().getNodeValue(SERIAL_NUMBER);
    883948        }
    884949
    885         ////////////////////////////////////////////////
    886         //      UDN
    887         ////////////////////////////////////////////////
     950        // //////////////////////////////////////////////
     951        // UDN
     952        // //////////////////////////////////////////////
    888953
    889954        private final static String UDN = "UDN";
    890        
    891         public void setUDN(String value)
    892         {
     955
     956        public void setUDN(String value) {
    893957                getDeviceNode().setNode(UDN, value);
    894958        }
    895959
    896         public String getUDN()
    897         {
     960        public String getUDN() {
    898961                return getDeviceNode().getNodeValue(UDN);
    899962        }
    900963
    901         public boolean hasUDN()
    902         {
     964        public boolean hasUDN() {
    903965                String udn = getUDN();
    904966                if (udn == null || udn.length() <= 0)
     
    906968                return true;
    907969        }
    908        
    909         ////////////////////////////////////////////////
    910         //      UPC
    911         ////////////////////////////////////////////////
     970
     971        // //////////////////////////////////////////////
     972        // UPC
     973        // //////////////////////////////////////////////
    912974
    913975        private final static String UPC = "UPC";
    914        
    915         public void setUPC(String value)
    916         {
     976
     977        public void setUPC(String value) {
    917978                getDeviceNode().setNode(UPC, value);
    918979        }
    919980
    920         public String getUPC()
    921         {
     981        public String getUPC() {
    922982                return getDeviceNode().getNodeValue(UPC);
    923983        }
    924984
    925         ////////////////////////////////////////////////
    926         //      presentationURL
    927         ////////////////////////////////////////////////
     985        // //////////////////////////////////////////////
     986        // presentationURL
     987        // //////////////////////////////////////////////
    928988
    929989        private final static String presentationURL = "presentationURL";
    930        
    931         public void setPresentationURL(String value)
    932         {
     990        private PresentationListener presentationListener;
     991
     992        public void setPresentationURL(String value) {
    933993                getDeviceNode().setNode(presentationURL, value);
    934994        }
    935995
    936         public String getPresentationURL()
    937         {
     996        public String getPresentationURL() {
    938997                return getDeviceNode().getNodeValue(presentationURL);
    939998        }
    940999
    941         ////////////////////////////////////////////////
    942         //      deviceList
    943         ////////////////////////////////////////////////
    944 
    945         public DeviceList getDeviceList()
    946         {
     1000        public boolean removePresentationURL() {
     1001                return getDeviceNode().removeNode(presentationURL);
     1002        }
     1003
     1004        private boolean isPresentationRequest(HTTPRequest httpReq) {
     1005                if (!httpReq.isGetRequest())
     1006                        return false;
     1007                String urlPath = httpReq.getURI();
     1008                if (urlPath == null)
     1009                        return false;
     1010                String presentationURL = getPresentationURL();
     1011                if (presentationURL == null)
     1012                        return false;
     1013                return urlPath.startsWith(presentationURL);
     1014        }
     1015
     1016        public void setPresentationListener(PresentationListener listener) {
     1017                this.presentationListener = listener;
     1018
     1019                if (listener != null) {
     1020                        setPresentationURL(DEFAULT_PRESENTATION_URI);
     1021                } else {
     1022                        removePresentationURL();
     1023                }
     1024        }
     1025
     1026        public boolean hasPresentationListener() {
     1027                return (this.presentationListener != null) ? true : false;
     1028        }
     1029
     1030        public PresentationListener getPresentationListener() {
     1031                return this.presentationListener;
     1032        }
     1033
     1034        // //////////////////////////////////////////////
     1035        // deviceList
     1036        // //////////////////////////////////////////////
     1037
     1038        public DeviceList getDeviceList() {
    9471039                DeviceList devList = new DeviceList();
    9481040                Node devListNode = getDeviceNode().getNode(DeviceList.ELEM_NAME);
     
    9501042                        return devList;
    9511043                int nNode = devListNode.getNNodes();
    952                 for (int n=0; n<nNode; n++) {
     1044                for (int n = 0; n < nNode; n++) {
    9531045                        Node node = devListNode.getNode(n);
    9541046                        if (Device.isDeviceNode(node) == false)
     
    9561048                        Device dev = new Device(node);
    9571049                        devList.add(dev);
    958                 } 
     1050                }
    9591051                return devList;
    9601052        }
    9611053
    962         public boolean isDevice(String name)
    963         {
     1054        public boolean isDevice(String name) {
    9641055                if (name == null)
    9651056                        return false;
     
    9721063                return false;
    9731064        }
    974        
    975         public Device getDevice(String name)
    976         {
     1065
     1066        public Device getDevice(String name) {
    9771067                DeviceList devList = getDeviceList();
    9781068                int devCnt = devList.size();
    979                 for (int n=0; n<devCnt; n++) {
     1069                for (int n = 0; n < devCnt; n++) {
    9801070                        Device dev = devList.getDevice(n);
    9811071                        if (dev.isDevice(name) == true)
     
    9871077                return null;
    9881078        }
    989        
    990         public Device getDeviceByDescriptionURI(String uri)
    991         {
     1079
     1080        public Device getDeviceByDescriptionURI(String uri) {
    9921081                DeviceList devList = getDeviceList();
    9931082                int devCnt = devList.size();
    994                 for (int n=0; n<devCnt; n++) {
     1083                for (int n = 0; n < devCnt; n++) {
    9951084                        Device dev = devList.getDevice(n);
    9961085                        if (dev.isDescriptionURI(uri) == true)
     
    10021091                return null;
    10031092        }
    1004        
    1005         ////////////////////////////////////////////////
    1006         //      serviceList
    1007         ////////////////////////////////////////////////
    1008 
    1009         public ServiceList getServiceList()
    1010         {
     1093
     1094        // //////////////////////////////////////////////
     1095        // serviceList
     1096        // //////////////////////////////////////////////
     1097
     1098        public ServiceList getServiceList() {
    10111099                ServiceList serviceList = new ServiceList();
    10121100                Node serviceListNode = getDeviceNode().getNode(ServiceList.ELEM_NAME);
     
    10141102                        return serviceList;
    10151103                int nNode = serviceListNode.getNNodes();
    1016                 for (int n=0; n<nNode; n++) {
     1104                for (int n = 0; n < nNode; n++) {
    10171105                        Node node = serviceListNode.getNode(n);
    10181106                        if (Service.isServiceNode(node) == false)
     
    10201108                        Service service = new Service(node);
    10211109                        serviceList.add(service);
    1022                 } 
     1110                }
    10231111                return serviceList;
    10241112        }
    10251113
    1026         public Service getService(String name)
    1027         {
     1114        public Service getService(String name) {
    10281115                ServiceList serviceList = getServiceList();
    10291116                int serviceCnt = serviceList.size();
    1030                 for (int n=0; n<serviceCnt; n++) {
     1117                for (int n = 0; n < serviceCnt; n++) {
    10311118                        Service service = serviceList.getService(n);
    10321119                        if (service.isService(name) == true)
    10331120                                return service;
    10341121                }
    1035                
     1122
    10361123                DeviceList devList = getDeviceList();
    10371124                int devCnt = devList.size();
    1038                 for (int n=0; n<devCnt; n++) {
     1125                for (int n = 0; n < devCnt; n++) {
    10391126                        Device dev = devList.getDevice(n);
    10401127                        Service service = dev.getService(name);
     
    10421129                                return service;
    10431130                }
    1044                
     1131
    10451132                return null;
    10461133        }
    10471134
    1048         public Service getServiceBySCPDURL(String searchUrl)
    1049         {
     1135        public Service getServiceBySCPDURL(String searchUrl) {
    10501136                ServiceList serviceList = getServiceList();
    10511137                int serviceCnt = serviceList.size();
    1052                 for (int n=0; n<serviceCnt; n++) {
     1138                for (int n = 0; n < serviceCnt; n++) {
    10531139                        Service service = serviceList.getService(n);
    10541140                        if (service.isSCPDURL(searchUrl) == true)
    10551141                                return service;
    10561142                }
    1057                
     1143
    10581144                DeviceList devList = getDeviceList();
    10591145                int devCnt = devList.size();
    1060                 for (int n=0; n<devCnt; n++) {
     1146                for (int n = 0; n < devCnt; n++) {
    10611147                        Device dev = devList.getDevice(n);
    10621148                        Service service = dev.getServiceBySCPDURL(searchUrl);
     
    10641150                                return service;
    10651151                }
    1066                
     1152
    10671153                return null;
    10681154        }
    10691155
    1070         public Service getServiceByControlURL(String searchUrl)
    1071         {
     1156        public Service getServiceByControlURL(String searchUrl) {
    10721157                ServiceList serviceList = getServiceList();
    10731158                int serviceCnt = serviceList.size();
    1074                 for (int n=0; n<serviceCnt; n++) {
     1159                for (int n = 0; n < serviceCnt; n++) {
    10751160                        Service service = serviceList.getService(n);
    10761161                        if (service.isControlURL(searchUrl) == true)
    10771162                                return service;
    10781163                }
    1079                
     1164
    10801165                DeviceList devList = getDeviceList();
    10811166                int devCnt = devList.size();
    1082                 for (int n=0; n<devCnt; n++) {
     1167                for (int n = 0; n < devCnt; n++) {
    10831168                        Device dev = devList.getDevice(n);
    10841169                        Service service = dev.getServiceByControlURL(searchUrl);
     
    10861171                                return service;
    10871172                }
    1088                
     1173
    10891174                return null;
    10901175        }
    10911176
    1092         public Service getServiceByEventSubURL(String searchUrl)
    1093         {
     1177        public Service getServiceByEventSubURL(String searchUrl) {
    10941178                ServiceList serviceList = getServiceList();
    10951179                int serviceCnt = serviceList.size();
    1096                 for (int n=0; n<serviceCnt; n++) {
     1180                for (int n = 0; n < serviceCnt; n++) {
    10971181                        Service service = serviceList.getService(n);
    10981182                        if (service.isEventSubURL(searchUrl) == true)
    10991183                                return service;
    11001184                }
    1101                
     1185
    11021186                DeviceList devList = getDeviceList();
    11031187                int devCnt = devList.size();
    1104                 for (int n=0; n<devCnt; n++) {
     1188                for (int n = 0; n < devCnt; n++) {
    11051189                        Device dev = devList.getDevice(n);
    11061190                        Service service = dev.getServiceByEventSubURL(searchUrl);
     
    11081192                                return service;
    11091193                }
    1110                
     1194
    11111195                return null;
    11121196        }
    11131197
    1114         public Service getSubscriberService(String uuid)
    1115         {
     1198        public Service getSubscriberService(String uuid) {
    11161199                ServiceList serviceList = getServiceList();
    11171200                int serviceCnt = serviceList.size();
    1118                 for (int n=0; n<serviceCnt; n++) {
     1201                for (int n = 0; n < serviceCnt; n++) {
    11191202                        Service service = serviceList.getService(n);
    11201203                        String sid = service.getSID();
     
    11221205                                return service;
    11231206                }
    1124                
     1207
    11251208                DeviceList devList = getDeviceList();
    11261209                int devCnt = devList.size();
    1127                 for (int n=0; n<devCnt; n++) {
     1210                for (int n = 0; n < devCnt; n++) {
    11281211                        Device dev = devList.getDevice(n);
    11291212                        Service service = dev.getSubscriberService(uuid);
     
    11311214                                return service;
    11321215                }
    1133                
     1216
    11341217                return null;
    11351218        }
    11361219
    1137         ////////////////////////////////////////////////
    1138         //      StateVariable
    1139         ////////////////////////////////////////////////
    1140 
    1141         public StateVariable getStateVariable(String serviceType, String name)
    1142         {
     1220        // //////////////////////////////////////////////
     1221        // StateVariable
     1222        // //////////////////////////////////////////////
     1223
     1224        public StateVariable getStateVariable(String serviceType, String name) {
    11431225                if (serviceType == null && name == null)
    11441226                        return null;
    1145                
     1227
    11461228                ServiceList serviceList = getServiceList();
    11471229                int serviceCnt = serviceList.size();
    1148                 for (int n=0; n<serviceCnt; n++) {
     1230                for (int n = 0; n < serviceCnt; n++) {
    11491231                        Service service = serviceList.getService(n);
    11501232                        // Thanks for Theo Beisch (11/09/04)
     
    11571239                                return stateVar;
    11581240                }
    1159                
     1241
    11601242                DeviceList devList = getDeviceList();
    11611243                int devCnt = devList.size();
    1162                 for (int n=0; n<devCnt; n++) {
     1244                for (int n = 0; n < devCnt; n++) {
    11631245                        Device dev = devList.getDevice(n);
    11641246                        StateVariable stateVar = dev.getStateVariable(serviceType, name);
     
    11661248                                return stateVar;
    11671249                }
    1168                
     1250
    11691251                return null;
    11701252        }
    11711253
    1172         public StateVariable getStateVariable(String name)
    1173         {
     1254        public StateVariable getStateVariable(String name) {
    11741255                return getStateVariable(null, name);
    11751256        }
    1176        
    1177         ////////////////////////////////////////////////
    1178         //      Action
    1179         ////////////////////////////////////////////////
    1180 
    1181         public Action getAction(String name)
    1182         {
     1257
     1258        // //////////////////////////////////////////////
     1259        // Action
     1260        // //////////////////////////////////////////////
     1261
     1262        public Action getAction(String name) {
    11831263                ServiceList serviceList = getServiceList();
    11841264                int serviceCnt = serviceList.size();
    1185                 for (int n=0; n<serviceCnt; n++) {
     1265                for (int n = 0; n < serviceCnt; n++) {
    11861266                        Service service = serviceList.getService(n);
    11871267                        ActionList actionList = service.getActionList();
    11881268                        int actionCnt = actionList.size();
    1189                         for (int i=0; i<actionCnt; i++) {
    1190                                 Action action = (Action)actionList.getAction(i);
     1269                        for (int i = 0; i < actionCnt; i++) {
     1270                                Action action = (Action) actionList.getAction(i);
    11911271                                String actionName = action.getName();
    11921272                                if (actionName == null)
     
    11961276                        }
    11971277                }
    1198                
     1278
    11991279                DeviceList devList = getDeviceList();
    12001280                int devCnt = devList.size();
    1201                 for (int n=0; n<devCnt; n++) {
     1281                for (int n = 0; n < devCnt; n++) {
    12021282                        Device dev = devList.getDevice(n);
    12031283                        Action action = dev.getAction(name);
     
    12051285                                return action;
    12061286                }
     1287
     1288                return null;
     1289        }
     1290
     1291        // //////////////////////////////////////////////
     1292        // iconList
     1293        // //////////////////////////////////////////////
     1294
     1295        private HashMap<String, byte[]> iconBytesMap = new HashMap<String, byte[]>();
     1296
     1297        public boolean isIconBytesURI(String uri) {
     1298                byte iconBytes[] = iconBytesMap.get(uri);
     1299                if (iconBytes == null)
     1300                        return false;
     1301                return true;
     1302        }
     1303
     1304        public Icon getIconByURI(String uri) {
     1305                IconList iconList = getIconList();
     1306                if (iconList.size() <= 0)
     1307                        return null;
     1308
     1309                int nIcon = iconList.size();
     1310                for (int n = 0; n < nIcon; n++) {
     1311                        Icon icon = iconList.getIcon(n);
     1312                        if (icon.isURL(uri))
     1313                                return icon;
     1314                }
    12071315               
    12081316                return null;
    12091317        }
    12101318
    1211         ////////////////////////////////////////////////
    1212         //      iconList
    1213         ////////////////////////////////////////////////
    1214 
    1215         public IconList getIconList()
    1216         {
     1319        public boolean addIcon(Icon icon) {
     1320                Node deviceNode = getDeviceNode();
     1321                if (deviceNode == null)
     1322                        return false;
     1323
     1324                Node iconListNode = deviceNode.getNode(IconList.ELEM_NAME);
     1325                if (iconListNode == null) {
     1326                        iconListNode = new Node(IconList.ELEM_NAME);
     1327                        deviceNode.addNode(iconListNode);
     1328                }
     1329
     1330                Node iconNode = new Node(Icon.ELEM_NAME);
     1331                if (icon.getIconNode() != null) {
     1332                        iconNode.set(icon.getIconNode());
     1333                }
     1334                iconListNode.addNode(iconNode);
     1335
     1336                if (icon.hasURL() && icon.hasBytes()) {
     1337                        iconBytesMap.put(icon.getURL(), icon.getBytes());
     1338                }
     1339
     1340                return true;
     1341        }
     1342
     1343        public IconList getIconList() {
    12171344                IconList iconList = new IconList();
    12181345                Node iconListNode = getDeviceNode().getNode(IconList.ELEM_NAME);
     
    12201347                        return iconList;
    12211348                int nNode = iconListNode.getNNodes();
    1222                 for (int n=0; n<nNode; n++) {
     1349                for (int n = 0; n < nNode; n++) {
    12231350                        Node node = iconListNode.getNode(n);
    12241351                        if (Icon.isIconNode(node) == false)
    12251352                                continue;
    12261353                        Icon icon = new Icon(node);
     1354                        if (icon.hasURL()) {
     1355                                String iconURL = icon.getURL();
     1356                                byte iconBytes[] = iconBytesMap.get(iconURL);
     1357                                if (iconBytes != null) {
     1358                                        icon.setBytes(iconBytes);
     1359                                }
     1360                        }
    12271361                        iconList.add(icon);
    1228                 } 
     1362                }
    12291363                return iconList;
    12301364        }
    1231        
    1232         public Icon getIcon(int n)
    1233         {
     1365
     1366        public Icon getIcon(int n) {
    12341367                IconList iconList = getIconList();
    1235                 if (n < 0 && (iconList.size()-1) < n)
     1368                if (n < 0 && (iconList.size() - 1) < n)
    12361369                        return null;
    12371370                return iconList.getIcon(n);
    12381371        }
    12391372
    1240         public Icon getSmallestIcon()
    1241         {
    1242                 Icon smallestIcon = null;               
     1373        public Icon getSmallestIcon() {
     1374                Icon smallestIcon = null;
    12431375                IconList iconList = getIconList();
    12441376                int iconCount = iconList.size();
    1245                 for (int n=0; n < iconCount; n++) {
     1377                for (int n = 0; n < iconCount; n++) {
    12461378                        Icon icon = iconList.getIcon(n);
    12471379                        if (null == smallestIcon) {
     
    12501382                        }
    12511383                        if (icon.getWidth() < smallestIcon.getWidth())
    1252                                 smallestIcon = icon;                   
    1253                 }
    1254                
     1384                                smallestIcon = icon;
     1385                }
     1386
    12551387                return smallestIcon;
    12561388        }
    1257        
    1258         ////////////////////////////////////////////////
    1259         //      Notify
    1260         ////////////////////////////////////////////////
    1261 
    1262         public String getLocationURL(String host)
    1263         {
    1264                 return HostInterface.getHostURL(host, getHTTPPort(), getDescriptionURI());
    1265         }
    1266 
    1267         private String getNotifyDeviceNT()
    1268         {
     1389
     1390        // //////////////////////////////////////////////
     1391        // Notify
     1392        // //////////////////////////////////////////////
     1393
     1394        public String getLocationURL(String host) {
     1395                return HostInterface.getHostURL(host, getHTTPPort(),
     1396                                getDescriptionURI());
     1397        }
     1398
     1399        private String getNotifyDeviceNT() {
    12691400                if (isRootDevice() == false)
    1270                         return getUDN();                       
     1401                        return getUDN();
    12711402                return UPNP_ROOTDEVICE;
    12721403        }
    12731404
    1274         private String getNotifyDeviceUSN()
    1275         {
     1405        private String getNotifyDeviceUSN() {
    12761406                if (isRootDevice() == false)
    1277                         return getUDN();                       
     1407                        return getUDN();
    12781408                return getUDN() + "::" + UPNP_ROOTDEVICE;
    12791409        }
    12801410
    1281         private String getNotifyDeviceTypeNT()
    1282         {
     1411        private String getNotifyDeviceTypeNT() {
    12831412                return getDeviceType();
    12841413        }
    12851414
    1286         private String getNotifyDeviceTypeUSN()
    1287         {
     1415        private String getNotifyDeviceTypeUSN() {
    12881416                return getUDN() + "::" + getDeviceType();
    12891417        }
    1290        
    1291         public final static void notifyWait()
    1292         {
     1418
     1419        public final static void notifyWait() {
    12931420                TimerUtil.waitRandom(DEFAULT_DISCOVERY_WAIT_TIME);
    12941421        }
    1295         public void announce(String bindAddr)
    1296         {
     1422
     1423        public void announce(String bindAddr) {
    12971424                String devLocation = getLocationURL(bindAddr);
    1298                
     1425
    12991426                SSDPNotifySocket ssdpSock = new SSDPNotifySocket(bindAddr);
    13001427
     
    13041431                ssdpReq.setLocation(devLocation);
    13051432                ssdpReq.setNTS(NTS.ALIVE);
    1306                
    1307                 // uuid:device-UUID(::upnp:rootdevice)*
     1433                ssdpReq.setBootId(getBootId());
     1434
     1435                // uuid:device-UUID(::upnp:rootdevice)*
    13081436                if (isRootDevice() == true) {
    1309                         String devNT = getNotifyDeviceNT();                     
     1437                        String devNT = getNotifyDeviceNT();
    13101438                        String devUSN = getNotifyDeviceUSN();
    13111439                        ssdpReq.setNT(devNT);
    13121440                        ssdpReq.setUSN(devUSN);
    13131441                        ssdpSock.post(ssdpReq);
    1314                          
    1315                         String devUDN = getUDN(); 
    1316                         ssdpReq.setNT(devUDN); 
    1317                         ssdpReq.setUSN(devUDN); 
    1318                         ssdpSock.post(ssdpReq);                         
    1319                 }
    1320                
    1321                 // uuid:device-UUID::urn:schemas-upnp-org:device:deviceType:v 
    1322                 String devNT = getNotifyDeviceTypeNT();                 
     1442
     1443                        String devUDN = getUDN();
     1444                        ssdpReq.setNT(devUDN);
     1445                        ssdpReq.setUSN(devUDN);
     1446                        ssdpSock.post(ssdpReq);
     1447                }
     1448
     1449                // uuid:device-UUID::urn:schemas-upnp-org:device:deviceType:v
     1450                String devNT = getNotifyDeviceTypeNT();
    13231451                String devUSN = getNotifyDeviceTypeUSN();
    13241452                ssdpReq.setNT(devNT);
    13251453                ssdpReq.setUSN(devUSN);
    13261454                ssdpSock.post(ssdpReq);
    1327                
     1455
    13281456                // Thanks for Mikael Hakman (04/25/05)
    13291457                ssdpSock.close();
    1330                
     1458
    13311459                ServiceList serviceList = getServiceList();
    13321460                int serviceCnt = serviceList.size();
    1333                 for (int n=0; n<serviceCnt; n++) {
     1461                for (int n = 0; n < serviceCnt; n++) {
    13341462                        Service service = serviceList.getService(n);
    13351463                        service.announce(bindAddr);
     
    13381466                DeviceList childDeviceList = getDeviceList();
    13391467                int childDeviceCnt = childDeviceList.size();
    1340                 for (int n=0; n<childDeviceCnt; n++) {
     1468                for (int n = 0; n < childDeviceCnt; n++) {
    13411469                        Device childDevice = childDeviceList.getDevice(n);
    13421470                        childDevice.announce(bindAddr);
     
    13441472        }
    13451473
    1346         public void announce(){
     1474        public void announce() {
    13471475                notifyWait();
    13481476                InetAddress[] binds = getDeviceData().getHTTPBindAddress();
    13491477                String[] bindAddresses;
    1350                 if(binds!=null){                       
     1478                if (binds != null) {
    13511479                        bindAddresses = new String[binds.length];
    13521480                        for (int i = 0; i < binds.length; i++) {
    13531481                                bindAddresses[i] = binds[i].getHostAddress();
    13541482                        }
    1355                 }else{
     1483                } else {
    13561484                        int nHostAddrs = HostInterface.getNHostAddresses();
    1357                         bindAddresses = new String[nHostAddrs]; 
    1358                         for (int n=0; n<nHostAddrs; n++) {
     1485                        bindAddresses = new String[nHostAddrs];
     1486                        for (int n = 0; n < nHostAddrs; n++) {
    13591487                                bindAddresses[n] = HostInterface.getHostAddress(n);
    13601488                        }
    1361                 }               
     1489                }
    13621490                for (int j = 0; j < bindAddresses.length; j++) {
    1363                         if(bindAddresses[j] == null || bindAddresses[j].length() == 0)
     1491                        if (bindAddresses[j] == null || bindAddresses[j].length() == 0)
    13641492                                continue;
    13651493                        int ssdpCount = getSSDPAnnounceCount();
    1366                         for (int i=0; i<ssdpCount; i++)
     1494                        for (int i = 0; i < ssdpCount; i++)
    13671495                                announce(bindAddresses[j]);
    1368                        
    1369                 }
    1370         }
    1371        
    1372         public void byebye(String bindAddr)
    1373         {
     1496
     1497                }
     1498        }
     1499
     1500        public void byebye(String bindAddr) {
    13741501                SSDPNotifySocket ssdpSock = new SSDPNotifySocket(bindAddr);
    1375                
     1502
    13761503                SSDPNotifyRequest ssdpReq = new SSDPNotifyRequest();
    13771504                ssdpReq.setNTS(NTS.BYEBYE);
    1378                
    1379                 // uuid:device-UUID(::upnp:rootdevice)* 
     1505
     1506                // uuid:device-UUID(::upnp:rootdevice)*
    13801507                if (isRootDevice() == true) {
    1381                         String devNT = getNotifyDeviceNT();                     
     1508                        String devNT = getNotifyDeviceNT();
    13821509                        String devUSN = getNotifyDeviceUSN();
    13831510                        ssdpReq.setNT(devNT);
     
    13851512                        ssdpSock.post(ssdpReq);
    13861513                }
    1387                
    1388                 // uuid:device-UUID::urn:schemas-upnp-org:device:deviceType:v 
    1389                 String devNT = getNotifyDeviceTypeNT();                 
     1514
     1515                // uuid:device-UUID::urn:schemas-upnp-org:device:deviceType:v
     1516                String devNT = getNotifyDeviceTypeNT();
    13901517                String devUSN = getNotifyDeviceTypeUSN();
    13911518                ssdpReq.setNT(devNT);
     
    13951522                // Thanks for Mikael Hakman (04/25/05)
    13961523                ssdpSock.close();
    1397                
     1524
    13981525                ServiceList serviceList = getServiceList();
    13991526                int serviceCnt = serviceList.size();
    1400                 for (int n=0; n<serviceCnt; n++) {
     1527                for (int n = 0; n < serviceCnt; n++) {
    14011528                        Service service = serviceList.getService(n);
    14021529                        service.byebye(bindAddr);
     
    14051532                DeviceList childDeviceList = getDeviceList();
    14061533                int childDeviceCnt = childDeviceList.size();
    1407                 for (int n=0; n<childDeviceCnt; n++) {
     1534                for (int n = 0; n < childDeviceCnt; n++) {
    14081535                        Device childDevice = childDeviceList.getDevice(n);
    14091536                        childDevice.byebye(bindAddr);
     
    14111538        }
    14121539
    1413         public void byebye(){
     1540        public void byebye() {
    14141541
    14151542                InetAddress[] binds = getDeviceData().getHTTPBindAddress();
    14161543                String[] bindAddresses;
    1417                 if(binds!=null){                       
     1544                if (binds != null) {
    14181545                        bindAddresses = new String[binds.length];
    14191546                        for (int i = 0; i < binds.length; i++) {
    14201547                                bindAddresses[i] = binds[i].getHostAddress();
    14211548                        }
    1422                 }else{
     1549                } else {
    14231550                        int nHostAddrs = HostInterface.getNHostAddresses();
    1424                         bindAddresses = new String[nHostAddrs]; 
    1425                         for (int n=0; n<nHostAddrs; n++) {
     1551                        bindAddresses = new String[nHostAddrs];
     1552                        for (int n = 0; n < nHostAddrs; n++) {
    14261553                                bindAddresses[n] = HostInterface.getHostAddress(n);
    14271554                        }
    1428                 }               
    1429                
    1430                 for (int j = 0; j < bindAddresses.length; j++) {                       
     1555                }
     1556
     1557                for (int j = 0; j < bindAddresses.length; j++) {
    14311558                        if (bindAddresses[j] == null || bindAddresses[j].length() <= 0)
    14321559                                continue;
    14331560                        int ssdpCount = getSSDPAnnounceCount();
    1434                         for (int i=0; i<ssdpCount; i++)
     1561                        for (int i = 0; i < ssdpCount; i++)
    14351562                                byebye(bindAddresses[j]);
    1436                 }               
    1437         }
    1438 
    1439         ////////////////////////////////////////////////
    1440         //      Search
    1441         ////////////////////////////////////////////////
    1442 
    1443     private static Calendar cal = Calendar.getInstance();
    1444     public boolean postSearchResponse(SSDPPacket ssdpPacket, String st, String usn)
    1445         {
     1563                }
     1564        }
     1565
     1566        // //////////////////////////////////////////////
     1567        // Search
     1568        // //////////////////////////////////////////////
     1569
     1570        private static Calendar cal = Calendar.getInstance();
     1571
     1572        public boolean postSearchResponse(SSDPPacket ssdpPacket, String st,
     1573                        String usn) {
    14461574                String localAddr = ssdpPacket.getLocalAddress();
    14471575                Device rootDev = getRootDevice();
    14481576                String rootDevLocation = rootDev.getLocationURL(localAddr);
    1449                
     1577
    14501578                SSDPSearchResponse ssdpRes = new SSDPSearchResponse();
    14511579                ssdpRes.setLeaseTime(getLeaseTime());
     
    14541582                ssdpRes.setUSN(usn);
    14551583                ssdpRes.setLocation(rootDevLocation);
     1584                ssdpRes.setBootId(getBootId());
    14561585                // Thanks for Brent Hills (10/20/04)
    14571586                ssdpRes.setMYNAME(getFriendlyName());
     
    14591588                int mx = ssdpPacket.getMX();
    14601589                TimerUtil.waitRandom(mx * 1000);
    1461                
     1590
    14621591                String remoteAddr = ssdpPacket.getRemoteAddress();
    14631592                int remotePort = ssdpPacket.getRemotePort();
     
    14661595                        ssdpRes.print();
    14671596                int ssdpCount = getSSDPAnnounceCount();
    1468                 for (int i=0; i<ssdpCount; i++)
     1597                for (int i = 0; i < ssdpCount; i++)
    14691598                        ssdpResSock.post(remoteAddr, remotePort, ssdpRes);
    1470                        
     1599
    14711600                return true;
    14721601        }
    1473        
    1474         public void deviceSearchResponse(SSDPPacket ssdpPacket)
    1475         {
     1602
     1603        public void deviceSearchResponse(SSDPPacket ssdpPacket) {
    14761604                String ssdpST = ssdpPacket.getST();
    14771605
     
    14801608
    14811609                boolean isRootDevice = isRootDevice();
    1482                
     1610
    14831611                String devUSN = getUDN();
    14841612                if (isRootDevice == true)
    14851613                        devUSN += "::" + USN.ROOTDEVICE;
    1486                        
     1614
    14871615                if (ST.isAllDevice(ssdpST) == true) {
    1488                         String devNT = getNotifyDeviceNT();                     
     1616                        String devNT = getNotifyDeviceNT();
    14891617                        int repeatCnt = (isRootDevice == true) ? 3 : 2;
    1490                         for (int n=0; n<repeatCnt; n++)
     1618                        for (int n = 0; n < repeatCnt; n++)
    14911619                                postSearchResponse(ssdpPacket, devNT, devUSN);
    1492                 }
    1493                 else if (ST.isRootDevice(ssdpST) == true) {
     1620                } else if (ST.isRootDevice(ssdpST) == true) {
    14941621                        if (isRootDevice == true)
    14951622                                postSearchResponse(ssdpPacket, ST.ROOT_DEVICE, devUSN);
    1496                 }
    1497                 else if (ST.isUUIDDevice(ssdpST) == true) {
     1623                } else if (ST.isUUIDDevice(ssdpST) == true) {
    14981624                        String devUDN = getUDN();
    14991625                        if (ssdpST.equals(devUDN) == true)
    15001626                                postSearchResponse(ssdpPacket, devUDN, devUSN);
    1501                 }
    1502                 else if (ST.isURNDevice(ssdpST) == true) {
    1503                         String devType= getDeviceType();
     1627                } else if (ST.isURNDevice(ssdpST) == true) {
     1628                        String devType = getDeviceType();
    15041629                        if (ssdpST.equals(devType) == true) {
    15051630                                // Thanks for Mikael Hakman (04/25/05)
     
    15081633                        }
    15091634                }
    1510                
     1635
    15111636                ServiceList serviceList = getServiceList();
    15121637                int serviceCnt = serviceList.size();
    1513                 for (int n=0; n<serviceCnt; n++) {
     1638                for (int n = 0; n < serviceCnt; n++) {
    15141639                        Service service = serviceList.getService(n);
    15151640                        service.serviceSearchResponse(ssdpPacket);
    15161641                }
    1517                
     1642
    15181643                DeviceList childDeviceList = getDeviceList();
    15191644                int childDeviceCnt = childDeviceList.size();
    1520                 for (int n=0; n<childDeviceCnt; n++) {
     1645                for (int n = 0; n < childDeviceCnt; n++) {
    15211646                        Device childDevice = childDeviceList.getDevice(n);
    15221647                        childDevice.deviceSearchResponse(ssdpPacket);
    15231648                }
    15241649        }
    1525        
    1526         public void deviceSearchReceived(SSDPPacket ssdpPacket)
    1527         {
     1650
     1651        public void deviceSearchReceived(SSDPPacket ssdpPacket) {
    15281652                deviceSearchResponse(ssdpPacket);
    15291653        }
    1530        
    1531         ////////////////////////////////////////////////
    1532         //      HTTP Server     
    1533         ////////////////////////////////////////////////
    1534 
    1535         public void setHTTPPort(int port)
    1536         {
     1654
     1655        // //////////////////////////////////////////////
     1656        // HTTP Server
     1657        // //////////////////////////////////////////////
     1658
     1659        public void setHTTPPort(int port) {
    15371660                getDeviceData().setHTTPPort(port);
    15381661        }
    1539        
    1540         public int getHTTPPort()
    1541         {
     1662
     1663        public int getHTTPPort() {
    15421664                return getDeviceData().getHTTPPort();
    15431665        }
    15441666
    1545         public void setHTTPBindAddress(InetAddress[] inets){
     1667        public void setHTTPBindAddress(InetAddress[] inets) {
    15461668                this.getDeviceData().setHTTPBindAddress(inets);
    15471669        }
    1548        
    1549         public InetAddress[] getHTTPBindAddress(){
     1670
     1671        public InetAddress[] getHTTPBindAddress() {
    15501672                return this.getDeviceData().getHTTPBindAddress();
    1551         }       
    1552        
     1673        }
     1674
    15531675        /**
    15541676         *
     
    15561678         * @since 1.8
    15571679         */
    1558         public String getSSDPIPv4MulticastAddress(){
     1680        public String getSSDPIPv4MulticastAddress() {
    15591681                return this.getDeviceData().getMulticastIPv4Address();
    1560         }       
    1561        
     1682        }
     1683
    15621684        /**
    15631685         *
     
    15651687         * @since 1.8
    15661688         */
    1567         public void getSSDPIPv4MulticastAddress(String ip){
     1689        public void getSSDPIPv4MulticastAddress(String ip) {
    15681690                this.getDeviceData().setMulticastIPv4Address(ip);
    1569         }       
    1570        
     1691        }
     1692
    15711693        /**
    15721694         *
     
    15741696         * @since 1.8
    15751697         */
    1576         public String getSSDPIPv6MulticastAddress(){
     1698        public String getSSDPIPv6MulticastAddress() {
    15771699                return this.getDeviceData().getMulticastIPv6Address();
    1578         }       
    1579        
     1700        }
     1701
    15801702        /**
    15811703         *
     
    15831705         * @since 1.8
    15841706         */
    1585         public void getSSDPIPv6MulticastAddress(String ip){
     1707        public void getSSDPIPv6MulticastAddress(String ip) {
    15861708                this.getDeviceData().setMulticastIPv6Address(ip);
    1587         }       
    1588        
    1589         public void httpRequestRecieved(HTTPRequest httpReq)
    1590         {
     1709        }
     1710
     1711        public void httpRequestRecieved(HTTPRequest httpReq) {
    15911712                if (Debug.isOn() == true)
    15921713                        httpReq.print();
    1593        
     1714
     1715                if (hasPresentationListener() && isPresentationRequest(httpReq)) {
     1716                        PresentationListener listener = getPresentationListener();
     1717                        listener.httpRequestRecieved(httpReq);
     1718                        return;
     1719                }
     1720
    15941721                if (httpReq.isGetRequest() == true || httpReq.isHeadRequest() == true) {
    15951722                        httpGetRequestRecieved(httpReq);
     
    16011728                }
    16021729
    1603                 if (httpReq.isSubscribeRequest() == true || httpReq.isUnsubscribeRequest() == true) {
     1730                if (httpReq.isSubscribeRequest() == true
     1731                                || httpReq.isUnsubscribeRequest() == true) {
    16041732                        SubscriptionRequest subReq = new SubscriptionRequest(httpReq);
    16051733                        deviceEventSubscriptionRecieved(subReq);
     
    16101738        }
    16111739
    1612         private synchronized byte[] getDescriptionData(String host)
    1613         {
     1740        private synchronized byte[] getDescriptionData(String host) {
    16141741                if (isNMPRMode() == false)
    16151742                        updateURLBase(host);
     
    16241751                return desc.getBytes();
    16251752        }
    1626        
    1627         private void httpGetRequestRecieved(HTTPRequest httpReq)
    1628         {
     1753
     1754        private void httpGetRequestRecieved(HTTPRequest httpReq) {
    16291755                String uri = httpReq.getURI();
    16301756                Debug.message("httpGetRequestRecieved = " + uri);
     
    16331759                        return;
    16341760                }
    1635                                        
     1761
    16361762                Device embDev;
    16371763                Service embService;
    1638                
     1764
    16391765                byte fileByte[] = new byte[0];
     1766                String contentType = null;
     1767                String contentLanguage = null;
     1768
    16401769                if (isDescriptionURI(uri) == true) {
    16411770                        String localAddr = httpReq.getLocalAddress();
    16421771                        if ((localAddr == null) || (localAddr.length() <= 0))
    16431772                                localAddr = HostInterface.getInterface();
     1773                        contentType = XML.DEFAULT_CONTENT_TYPE;
     1774                        contentLanguage = XML.DEFAULT_CONTENT_LANGUAGE;
    16441775                        fileByte = getDescriptionData(localAddr);
    1645                 }
    1646                 else if ((embDev = getDeviceByDescriptionURI(uri)) != null) {
     1776                } else if ((embDev = getDeviceByDescriptionURI(uri)) != null) {
    16471777                        String localAddr = httpReq.getLocalAddress();
     1778                        contentType = XML.DEFAULT_CONTENT_TYPE;
     1779                        contentLanguage = XML.DEFAULT_CONTENT_LANGUAGE;
    16481780                        fileByte = embDev.getDescriptionData(localAddr);
    1649                 }
    1650                 else if ((embService = getServiceBySCPDURL(uri)) != null) {
     1781                } else if ((embService = getServiceBySCPDURL(uri)) != null) {
     1782                        contentType = XML.DEFAULT_CONTENT_TYPE;
     1783                        contentLanguage = XML.DEFAULT_CONTENT_LANGUAGE;
    16511784                        fileByte = embService.getSCPDData();
    1652                 }
    1653                 else {
     1785                } else if (isIconBytesURI(uri) == true) {
     1786                        Icon devIcon = getIconByURI(uri);
     1787                        if (devIcon != null) {
     1788                                contentType = devIcon.getMimeType();
     1789                                fileByte = devIcon.getBytes();
     1790                        }
     1791                } else {
    16541792                        httpReq.returnBadRequest();
    16551793                        return;
    16561794                }
    1657                
     1795
    16581796                HTTPResponse httpRes = new HTTPResponse();
    1659                 if (FileUtil.isXMLFileName(uri) == true)
    1660                         httpRes.setContentType(XML.CONTENT_TYPE);
    16611797                httpRes.setStatusCode(HTTPStatus.OK);
     1798                if (contentType != null) {
     1799                        httpRes.setContentType(contentType);
     1800                }
     1801                if (contentLanguage != null) {
     1802                        // FIXME Check ACCEPT-LANGUAGE header in client request, and set a
     1803                        // suitable code.
     1804                        httpRes.setContentLanguage(contentLanguage);
     1805                }
    16621806                httpRes.setContent(fileByte);
    16631807
     
    16651809        }
    16661810
    1667         private void httpPostRequestRecieved(HTTPRequest httpReq)
    1668         {
     1811        private void httpPostRequestRecieved(HTTPRequest httpReq) {
    16691812                if (httpReq.isSOAPAction() == true) {
    1670                         //SOAPRequest soapReq = new SOAPRequest(httpReq);
     1813                        // SOAPRequest soapReq = new SOAPRequest(httpReq);
    16711814                        soapActionRecieved(httpReq);
    16721815                        return;
     
    16751818        }
    16761819
    1677         ////////////////////////////////////////////////
    1678         //      SOAP
    1679         ////////////////////////////////////////////////
    1680 
    1681         private void soapBadActionRecieved(HTTPRequest soapReq)
    1682         {
     1820        // //////////////////////////////////////////////
     1821        // SOAP
     1822        // //////////////////////////////////////////////
     1823
     1824        private void soapBadActionRecieved(HTTPRequest soapReq) {
    16831825                SOAPResponse soapRes = new SOAPResponse();
    16841826                soapRes.setStatusCode(HTTPStatus.BAD_REQUEST);
     
    16861828        }
    16871829
    1688         private void soapActionRecieved(HTTPRequest soapReq)
    1689         {
     1830        private void soapActionRecieved(HTTPRequest soapReq) {
    16901831                String uri = soapReq.getURI();
    16911832                Service ctlService = getServiceByControlURL(uri);
    1692                 if (ctlService != null)  {
     1833                if (ctlService != null) {
    16931834                        ActionRequest crlReq = new ActionRequest(soapReq);
    16941835                        deviceControlRequestRecieved(crlReq, ctlService);
     
    16981839        }
    16991840
    1700         ////////////////////////////////////////////////
    1701         //      controlAction
    1702         ////////////////////////////////////////////////
    1703 
    1704         private void deviceControlRequestRecieved(ControlRequest ctlReq, Service service)
    1705         {
     1841        // //////////////////////////////////////////////
     1842        // controlAction
     1843        // //////////////////////////////////////////////
     1844
     1845        private void deviceControlRequestRecieved(ControlRequest ctlReq,
     1846                        Service service) {
    17061847                if (ctlReq.isQueryControl() == true)
    17071848                        deviceQueryControlRecieved(new QueryRequest(ctlReq), service);
     
    17101851        }
    17111852
    1712         private void invalidActionControlRecieved(ControlRequest ctlReq)
    1713         {
     1853        private void invalidActionControlRecieved(ControlRequest ctlReq) {
    17141854                ControlResponse actRes = new ActionResponse();
    17151855                actRes.setFaultResponse(UPnPStatus.INVALID_ACTION);
     
    17171857        }
    17181858
    1719    private void invalidArgumentsControlRecieved(ControlRequest ctlReq)
    1720     {
    1721         ControlResponse actRes = new ActionResponse();
    1722         actRes.setFaultResponse(UPnPStatus.INVALID_ARGS);
    1723         ctlReq.post(actRes);
    1724     }
    1725 
    1726         private void deviceActionControlRecieved(ActionRequest ctlReq, Service service)
    1727         {
     1859        private void invalidArgumentsControlRecieved(ControlRequest ctlReq) {
     1860                ControlResponse actRes = new ActionResponse();
     1861                actRes.setFaultResponse(UPnPStatus.INVALID_ARGS);
     1862                ctlReq.post(actRes);
     1863        }
     1864
     1865        private void deviceActionControlRecieved(ActionRequest ctlReq,
     1866                        Service service) {
    17281867                if (Debug.isOn() == true)
    17291868                        ctlReq.print();
    1730                        
     1869
    17311870                String actionName = ctlReq.getActionName();
    17321871                Action action = service.getAction(actionName);
     
    17371876                ArgumentList actionArgList = action.getArgumentList();
    17381877                ArgumentList reqArgList = ctlReq.getArgumentList();
    1739         try {
    1740             actionArgList.setReqArgs(reqArgList);
    1741         } catch (IllegalArgumentException ex){
    1742             invalidArgumentsControlRecieved(ctlReq);
    1743             return;
    1744        }
     1878                try {
     1879                        actionArgList.setReqArgs(reqArgList);
     1880                } catch (IllegalArgumentException ex) {
     1881                        invalidArgumentsControlRecieved(ctlReq);
     1882                        return;
     1883                }
    17451884                if (action.performActionListener(ctlReq) == false)
    17461885                        invalidActionControlRecieved(ctlReq);
    17471886        }
    17481887
    1749         private void deviceQueryControlRecieved(QueryRequest ctlReq, Service service)
    1750         {
     1888        private void deviceQueryControlRecieved(QueryRequest ctlReq, Service service) {
    17511889                if (Debug.isOn() == true)
    17521890                        ctlReq.print();
     
    17611899        }
    17621900
    1763         ////////////////////////////////////////////////
    1764         //      eventSubscribe
    1765         ////////////////////////////////////////////////
    1766 
    1767         private void upnpBadSubscriptionRecieved(SubscriptionRequest subReq, int code)
    1768         {
     1901        // //////////////////////////////////////////////
     1902        // eventSubscribe
     1903        // //////////////////////////////////////////////
     1904
     1905        private void upnpBadSubscriptionRecieved(SubscriptionRequest subReq,
     1906                        int code) {
    17691907                SubscriptionResponse subRes = new SubscriptionResponse();
    17701908                subRes.setErrorResponse(code);
     
    17721910        }
    17731911
    1774         private void deviceEventSubscriptionRecieved(SubscriptionRequest subReq)
    1775         {
     1912        private void deviceEventSubscriptionRecieved(SubscriptionRequest subReq) {
    17761913                String uri = subReq.getURI();
    17771914                Service service = getServiceByEventSubURL(uri);
     
    17961933                        return;
    17971934                }
    1798                
     1935
    17991936                // SUBSCRIBE (RENEW)
    18001937                if (subReq.hasSID() == true) {
     
    18021939                        return;
    18031940                }
    1804                
     1941
    18051942                upnpBadSubscriptionRecieved(subReq, HTTPStatus.PRECONDITION_FAILED);
    18061943        }
    18071944
    1808         private void deviceEventNewSubscriptionRecieved(Service service, SubscriptionRequest subReq)
    1809         {
     1945        private void deviceEventNewSubscriptionRecieved(Service service,
     1946                        SubscriptionRequest subReq) {
    18101947                String callback = subReq.getCallback();
    18111948                try {
    18121949                        new URL(callback);
    1813                 }
    1814                 catch (Exception e) {
     1950                } catch (Exception e) {
    18151951                        upnpBadSubscriptionRecieved(subReq, HTTPStatus.PRECONDITION_FAILED);
    18161952                        return;
     
    18191955                long timeOut = subReq.getTimeout();
    18201956                String sid = Subscription.createSID();
    1821                        
     1957
    18221958                Subscriber sub = new Subscriber();
    18231959                sub.setDeliveryURL(callback);
     
    18251961                sub.setSID(sid);
    18261962                service.addSubscriber(sub);
    1827                        
     1963
    18281964                SubscriptionResponse subRes = new SubscriptionResponse();
    18291965                subRes.setStatusCode(HTTPStatus.OK);
     
    18361972                if (Debug.isOn() == true)
    18371973                        subRes.print();
    1838                
     1974
    18391975                service.notifyAllStateVariables();
    18401976        }
    18411977
    1842         private void deviceEventRenewSubscriptionRecieved(Service service, SubscriptionRequest subReq)
    1843         {
     1978        private void deviceEventRenewSubscriptionRecieved(Service service,
     1979                        SubscriptionRequest subReq) {
    18441980                String sid = subReq.getSID();
    18451981                Subscriber sub = service.getSubscriber(sid);
     
    18531989                sub.setTimeOut(timeOut);
    18541990                sub.renew();
    1855                                
     1991
    18561992                SubscriptionResponse subRes = new SubscriptionResponse();
    18571993                subRes.setStatusCode(HTTPStatus.OK);
     
    18591995                subRes.setTimeout(timeOut);
    18601996                subReq.post(subRes);
    1861                
     1997
    18621998                if (Debug.isOn() == true)
    18631999                        subRes.print();
    1864         }               
    1865 
    1866         private void deviceEventUnsubscriptionRecieved(Service service, SubscriptionRequest subReq)
    1867         {
     2000        }
     2001
     2002        private void deviceEventUnsubscriptionRecieved(Service service,
     2003                        SubscriptionRequest subReq) {
    18682004                String sid = subReq.getSID();
    18692005                Subscriber sub = service.getSubscriber(sid);
     
    18752011
    18762012                service.removeSubscriber(sub);
    1877                                                
     2013
    18782014                SubscriptionResponse subRes = new SubscriptionResponse();
    18792015                subRes.setStatusCode(HTTPStatus.OK);
    18802016                subReq.post(subRes);
    1881                
     2017
    18822018                if (Debug.isOn() == true)
    18832019                        subRes.print();
    1884         }               
    1885        
    1886         ////////////////////////////////////////////////
    1887         //      Thread 
    1888         ////////////////////////////////////////////////
    1889 
    1890         private HTTPServerList getHTTPServerList()
    1891         {
     2020        }
     2021
     2022        // //////////////////////////////////////////////
     2023        // Thread
     2024        // //////////////////////////////////////////////
     2025
     2026        private HTTPServerList getHTTPServerList() {
    18922027                return getDeviceData().getHTTPServerList();
    18932028        }
     2029
    18942030        /**
    18952031         *
    1896          * @param port The port to use for binding the SSDP service
     2032         * @param port
     2033         *            The port to use for binding the SSDP service
    18972034         */
    1898         public void setSSDPPort(int port){
     2035        public void setSSDPPort(int port) {
    18992036                this.getDeviceData().setSSDPPort(port);
    19002037        }
     
    19042041         * @return The port to use for binding the SSDP service
    19052042         */
    1906         public int getSSDPPort(){
     2043        public int getSSDPPort() {
    19072044                return this.getDeviceData().getSSDPPort();
    19082045        }
    1909        
    1910        
    19112046
    19122047        /**
    19132048         *
    1914          * @param inets The IP that will be used for binding the SSDP service.
    1915          *              Use <code>null</code> to get the default beahvior
     2049         * @param inets
     2050         *            The IP that will be used for binding the SSDP service. Use
     2051         *            <code>null</code> to get the default beahvior
    19162052         */
    1917         public void setSSDPBindAddress(InetAddress[] inets){
     2053        public void setSSDPBindAddress(InetAddress[] inets) {
    19182054                this.getDeviceData().setSSDPBindAddress(inets);
    19192055        }
    1920                
    1921        
     2056
    19222057        /**
    19232058         *
    1924          * @return inets The IP that will be used for binding the SSDP service.
    1925          *              null means the default setted by the class UPnP
     2059         * @return inets The IP that will be used for binding the SSDP service. null
     2060         *         means the default setted by the class UPnP
    19262061         */
    1927         public InetAddress[] getSSDPBindAddress(){
     2062        public InetAddress[] getSSDPBindAddress() {
    19282063                return this.getDeviceData().getSSDPBindAddress();
    1929         }       
    1930        
     2064        }
     2065
    19312066        /**
    19322067         *
    1933          * @param ip The IPv4 address used for Multicast comunication
     2068         * @param ip
     2069         *            The IPv4 address used for Multicast comunication
    19342070         */
    1935         public void setMulticastIPv4Address(String ip){
     2071        public void setMulticastIPv4Address(String ip) {
    19362072                this.getDeviceData().setMulticastIPv4Address(ip);
    19372073        }
     
    19412077         * @return The IPv4 address used for Multicast comunication
    19422078         */
    1943         public String getMulticastIPv4Address(){
     2079        public String getMulticastIPv4Address() {
    19442080                return this.getDeviceData().getMulticastIPv4Address();
    19452081        }
    1946        
     2082
    19472083        /**
    19482084         *
    1949          * @param ip The IPv address used for Multicast comunication
     2085         * @param ip
     2086         *            The IPv address used for Multicast comunication
    19502087         */
    1951         public void setMulticastIPv6Address(String ip){
     2088        public void setMulticastIPv6Address(String ip) {
    19522089                this.getDeviceData().setMulticastIPv6Address(ip);
    19532090        }
     
    19572094         * @return The IPv address used for Multicast comunication
    19582095         */
    1959         public String getMulticastIPv6Address(){
     2096        public String getMulticastIPv6Address() {
    19602097                return this.getDeviceData().getMulticastIPv6Address();
    19612098        }
    1962        
    1963 
    1964         private SSDPSearchSocketList getSSDPSearchSocketList()
    1965         {
     2099
     2100        private SSDPSearchSocketList getSSDPSearchSocketList() {
    19662101                return getDeviceData().getSSDPSearchSocketList();
    19672102        }
    19682103
    1969         private void setAdvertiser(Advertiser adv)
    1970         {
     2104        private void setAdvertiser(Advertiser adv) {
    19712105                getDeviceData().setAdvertiser(adv);
    19722106        }
    1973        
    1974         private Advertiser getAdvertiser()
    1975         {
     2107
     2108        private Advertiser getAdvertiser() {
    19762109                return getDeviceData().getAdvertiser();
    19772110        }
    19782111
    1979         public boolean start()
    1980         {
     2112        public boolean start() {
    19812113                stop(true);
    1982                
    1983                 ////////////////////////////////////////
     2114
     2115                // //////////////////////////////////////
    19842116                // HTTP Server
    1985                 ////////////////////////////////////////
    1986                
     2117                // //////////////////////////////////////
     2118
    19872119                int retryCnt = 0;
    19882120                int bindPort = getHTTPPort();
     
    19982130                httpServerList.start();
    19992131
    2000                 ////////////////////////////////////////
     2132                // //////////////////////////////////////
    20012133                // SSDP Seach Socket
    2002                 ////////////////////////////////////////
    2003                
     2134                // //////////////////////////////////////
     2135
    20042136                SSDPSearchSocketList ssdpSearchSockList = getSSDPSearchSocketList();
    20052137                if (ssdpSearchSockList.open() == false)
     
    20082140                ssdpSearchSockList.start();
    20092141
    2010                 ////////////////////////////////////////
     2142                // //////////////////////////////////////
     2143                // BOOTID/CONFIGID.UPNP.ORG
     2144                // //////////////////////////////////////
     2145
     2146                updateBootId();
     2147                updateConfigId();
     2148
     2149                // //////////////////////////////////////
    20112150                // Announce
    2012                 ////////////////////////////////////////
    2013                
     2151                // //////////////////////////////////////
     2152
    20142153                announce();
    2015                
    2016                 ////////////////////////////////////////
     2154
     2155                // //////////////////////////////////////
    20172156                // Advertiser
    2018                 ////////////////////////////////////////
     2157                // //////////////////////////////////////
    20192158
    20202159                Advertiser adv = new Advertiser(this);
    20212160                setAdvertiser(adv);
    20222161                adv.start();
    2023                
     2162
    20242163                return true;
    20252164        }
    20262165
    2027         private boolean stop(boolean doByeBye)
    2028         {
     2166        private boolean stop(boolean doByeBye) {
    20292167                if (doByeBye == true)
    20302168                        byebye();
    2031                
     2169
    20322170                HTTPServerList httpServerList = getHTTPServerList();
    20332171                httpServerList.stop();
    20342172                httpServerList.close();
    20352173                httpServerList.clear();
    2036                
     2174
    20372175                SSDPSearchSocketList ssdpSearchSockList = getSSDPSearchSocketList();
    20382176                ssdpSearchSockList.stop();
    20392177                ssdpSearchSockList.close();
    20402178                ssdpSearchSockList.clear();
    2041                
     2179
    20422180                Advertiser adv = getAdvertiser();
    20432181                if (adv != null) {
     
    20482186                return true;
    20492187        }
    2050        
    2051         public boolean stop()
    2052         {
     2188
     2189        public boolean stop() {
    20532190                return stop(true);
    20542191        }
    20552192
    2056         public boolean isRunning()
    2057         {
     2193        public boolean isRunning() {
    20582194                return (getAdvertiser() != null) ? true : false;
    20592195        }
    20602196
    2061         ////////////////////////////////////////////////
     2197        // //////////////////////////////////////////////
    20622198        // Interface Address
    2063         ////////////////////////////////////////////////
    2064        
    2065         public String getInterfaceAddress()
    2066         {
     2199        // //////////////////////////////////////////////
     2200
     2201        public String getInterfaceAddress() {
    20672202                SSDPPacket ssdpPacket = getSSDPPacket();
    20682203                if (ssdpPacket == null)
     
    20712206        }
    20722207
    2073         ////////////////////////////////////////////////
     2208        // //////////////////////////////////////////////
    20742209        // Acion/QueryListener
    2075         ////////////////////////////////////////////////
    2076        
    2077         public void setActionListener(ActionListener listener)
    2078         {
     2210        // //////////////////////////////////////////////
     2211
     2212        public void setActionListener(ActionListener listener) {
    20792213                ServiceList serviceList = getServiceList();
    20802214                int nServices = serviceList.size();
    2081                 for (int n=0; n<nServices; n++) {
     2215                for (int n = 0; n < nServices; n++) {
    20822216                        Service service = serviceList.getService(n);
    20832217                        service.setActionListener(listener);
     
    20852219        }
    20862220
    2087         public void setQueryListener(QueryListener listener)
    2088         {
     2221        public void setQueryListener(QueryListener listener) {
    20892222                ServiceList serviceList = getServiceList();
    20902223                int nServices = serviceList.size();
    2091                 for (int n=0; n<nServices; n++) {
     2224                for (int n = 0; n < nServices; n++) {
    20922225                        Service service = serviceList.getService(n);
    20932226                        service.setQueryListener(listener);
     
    20952228        }
    20962229
    2097         ////////////////////////////////////////////////
     2230        // //////////////////////////////////////////////
    20982231        // Acion/QueryListener (includeSubDevices)
    2099         ////////////////////////////////////////////////
     2232        // //////////////////////////////////////////////
    21002233
    21012234        // Thanks for Mikael Hakman (04/25/05)
    2102         public void setActionListener(ActionListener listener, boolean includeSubDevices)
    2103         {
     2235        public void setActionListener(ActionListener listener,
     2236                        boolean includeSubDevices) {
    21042237                setActionListener(listener);
    21052238                if (includeSubDevices == true) {
     
    21122245                }
    21132246        }
    2114                
     2247
    21152248        // Thanks for Mikael Hakman (04/25/05)
    2116         public void setQueryListener(QueryListener listener, boolean includeSubDevices)
    2117         {
     2249        public void setQueryListener(QueryListener listener,
     2250                        boolean includeSubDevices) {
    21182251                setQueryListener(listener);
    21192252                if (includeSubDevices == true) {
     
    21272260        }
    21282261
    2129         ////////////////////////////////////////////////
    2130         //      userData
    2131         ////////////////////////////////////////////////
    2132 
    2133         private Object userData = null;
    2134        
    2135         public void setUserData(Object data)
    2136         {
     2262        // //////////////////////////////////////////////
     2263        // userData
     2264        // //////////////////////////////////////////////
     2265
     2266        private Object userData = null;
     2267
     2268        public void setUserData(Object data) {
    21372269                userData = data;
    21382270        }
    21392271
    2140         public Object getUserData()
    2141         {
     2272        public Object getUserData() {
    21422273                return userData;
    21432274        }
    2144        
    2145         ////////////////////////////////////////////////
    2146         //      output
    2147         ////////////////////////////////////////////////
    2148 
    2149 /*
    2150         public void output(PrintWriter ps)
    2151         {
    2152                 ps.println("deviceType = " + getDeviceType());
    2153                 ps.println("freindlyName = " + getFriendlyName());
    2154                 ps.println("presentationURL = " + getPresentationURL());
    2155 
    2156                 DeviceList devList = getDeviceList();
    2157                 ps.println("devList = " + devList.size());
    2158                
    2159                 ServiceList serviceList = getServiceList();
    2160                 ps.println("serviceList = " + serviceList.size());
    2161 
    2162                 IconList iconList = getIconList();
    2163                 ps.println("iconList = " + iconList.size());
    2164         }
    2165 
    2166         public void print()
    2167         {
    2168                 PrintWriter pr = new PrintWriter(System.out);
    2169                 output(pr);
    2170                 pr.flush();
    2171         }
    2172 */
     2275
     2276        // //////////////////////////////////////////////
     2277        // output
     2278        // //////////////////////////////////////////////
     2279
     2280        /*
     2281         * public void output(PrintWriter ps) { ps.println("deviceType = " +
     2282         * getDeviceType()); ps.println("freindlyName = " + getFriendlyName());
     2283         * ps.println("presentationURL = " + getPresentationURL());
     2284         *
     2285         * DeviceList devList = getDeviceList(); ps.println("devList = " +
     2286         * devList.size());
     2287         *
     2288         * ServiceList serviceList = getServiceList(); ps.println("serviceList = " +
     2289         * serviceList.size());
     2290         *
     2291         * IconList iconList = getIconList(); ps.println("iconList = " +
     2292         * iconList.size()); }
     2293         *
     2294         * public void print() { PrintWriter pr = new PrintWriter(System.out);
     2295         * output(pr); pr.flush(); }
     2296         */
    21732297
    21742298}
    2175 
  • router/java/src/org/cybergarage/upnp/Icon.java

    r819b07a5 rc79e4aea  
    4848        }
    4949
     50        public Icon() {
     51                this(new Node(ELEM_NAME));
     52        }
     53       
    5054        ////////////////////////////////////////////////
    5155        //      isIconNode
     
    7377        }
    7478
     79        public boolean hasMimeType()
     80        {
     81                String iconMimeType = getMimeType();
     82                if (iconMimeType == null)
     83                        return false;
     84                return (0 < iconMimeType.length()) ? true : false;
     85        }
     86       
    7587        ////////////////////////////////////////////////
    7688        //      width
     
    140152        }
    141153
    142         public String getDepth()
    143         {
    144                 return getIconNode().getNodeValue(DEPTH);
     154        public void setDepth(int value)
     155        {
     156                try {
     157                        setDepth(Integer.toString(value));
     158                }
     159                catch (Exception e) {};
     160        }
     161       
     162        public int getDepth()
     163        {
     164                try {
     165                        return Integer.parseInt(getIconNode().getNodeValue(DEPTH));
     166                }
     167                catch (Exception e) {};
     168                return 0;
    145169        }
    146170
     
    160184                return getIconNode().getNodeValue(URL);
    161185        }
     186
     187        public boolean hasURL()
     188        {
     189                String iconURL = getURL();
     190                if (iconURL == null)
     191                        return false;
     192                return (0 < iconURL.length()) ? true : false;
     193        }
     194       
     195        public boolean isURL(String url)
     196        {
     197                if (url == null)
     198                        return false;
     199                String iconURL = getURL();
     200                if (iconURL == null)
     201                        return false;
     202                return iconURL.equals(url);
     203        }
    162204       
    163205        ////////////////////////////////////////////////
     
    176218                return userData;
    177219        }
     220
     221        ////////////////////////////////////////////////
     222        //      Bytes
     223        ////////////////////////////////////////////////
     224
     225        private byte bytes[] = null;
     226       
     227        public void setBytes(byte data[])
     228        {
     229                bytes = data;
     230        }
     231
     232        public boolean hasBytes()
     233        {
     234                return (bytes != null) ? true : false;
     235        }
     236       
     237        public byte[]getBytes()
     238        {
     239                return bytes;
     240        }
    178241}
  • router/java/src/org/cybergarage/upnp/IconList.java

    r819b07a5 rc79e4aea  
    1818import java.util.Vector;
    1919
    20 public class IconList extends Vector<Icon> 
     20public class IconList extends Vector<Icon>
    2121{
    2222        ////////////////////////////////////////////////
  • router/java/src/org/cybergarage/upnp/Service.java

    r819b07a5 rc79e4aea  
    122122        public static final String SCPD_ROOTNODE="scpd";
    123123        public static final String SCPD_ROOTNODE_NS="urn:schemas-upnp-org:service-1-0";
    124        
     124
    125125        public static final String SPEC_VERSION="specVersion";
    126126        public static final String MAJOR="major";
     
    143143               
    144144                //Node scpd = new Node(SCPD_ROOTNODE,SCPD_ROOTNODE_NS); wrong!
    145                 Node scpd = new Node(SCPD_ROOTNODE);                                    // better (twa)
    146                 scpd.addAttribute("xmlns",SCPD_ROOTNODE_NS);                    // better (twa)
     145                Node scpd = new Node(SCPD_ROOTNODE);
     146                scpd.addAttribute("xmlns",SCPD_ROOTNODE_NS);
    147147                scpd.addNode(sp);
    148148                getServiceData().setSCPDNode(scpd);
     
    242242        }
    243243
     244        ////////////////////////////////////////////////
     245        //      configID
     246        ////////////////////////////////////////////////
     247
     248        private final static String CONFIG_ID = "configId";
     249       
     250        public void updateConfigId()
     251        {
     252                Node scpdNode = getSCPDNode();
     253                if (scpdNode == null)
     254                        return;
     255               
     256                String scpdXml = scpdNode.toString();
     257                int configId = UPnP.caluculateConfigId(scpdXml);
     258                scpdNode.setAttribute(CONFIG_ID, configId);
     259        }
     260
     261        public int getConfigId()
     262        {
     263                Node scpdNode = getSCPDNode();
     264                if (scpdNode == null)
     265                        return 0;
     266                return scpdNode.getAttributeIntegerValue(CONFIG_ID);
     267        }
     268       
    244269        ////////////////////////////////////////////////
    245270        //      isURL
     
    341366                        throw new InvalidDescriptionException(e);
    342367                }
     368               
    343369                return true;
    344370        }
     
    350376                if (scpdNode == null)
    351377                        return false;
     378               
    352379                ServiceData data = getServiceData();
    353380                data.setSCPDNode(scpdNode);
     381
    354382                return true;
    355383        }
     
    364392                if (scpdNode == null)
    365393                        return false;
     394               
    366395                ServiceData data = getServiceData();
    367396                data.setSCPDNode(scpdNode);
     397               
    368398                return true;
    369399        }
     
    372402    public void setDescriptionURL(String value)
    373403    {
    374             getServiceData().setDescriptionURL(value);
     404        getServiceData().setDescriptionURL(value);
    375405    }
    376406
    377407    public String getDescriptionURL()
    378408    {
    379             return getServiceData().getDescriptionURL();
     409        return getServiceData().getDescriptionURL();
    380410    }
    381411       
  • router/java/src/org/cybergarage/upnp/ServiceList.java

    r819b07a5 rc79e4aea  
    2020import java.util.Vector;
    2121
    22 public class ServiceList extends Vector<Service> 
     22public class ServiceList extends Vector<Service>
    2323{
    2424        ////////////////////////////////////////////////
  • router/java/src/org/cybergarage/upnp/ServiceStateTable.java

    r819b07a5 rc79e4aea  
    1818import java.util.Vector;
    1919
    20 public class ServiceStateTable extends Vector<StateVariable> 
     20public class ServiceStateTable extends Vector<StateVariable>
    2121{
    2222        ////////////////////////////////////////////////
  • router/java/src/org/cybergarage/upnp/UPnP.java

    r819b07a5 rc79e4aea  
    4646       
    4747        public final static String NAME = "CyberLinkJava";
    48         public final static String VERSION = "1.8";
     48        public final static String VERSION = "3.0";
    4949
    5050        // I2P was 100
     
    6464
    6565        public final static String XML_DECLARATION = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
     66       
     67        public final static int CONFIGID_UPNP_ORG_MAX = 16777215;
    6668       
    6769        ////////////////////////////////////////////////
     
    191193        }
    192194
     195        ////////////////////////////////////////////////
     196        //      BootId
     197        ////////////////////////////////////////////////
     198
     199        public static final int createBootId()
     200        {
     201                return (int)(System.currentTimeMillis() / 1000L);
     202        }
     203       
     204        ////////////////////////////////////////////////
     205        //      ConfigId
     206        ////////////////////////////////////////////////
     207
     208        public static final int caluculateConfigId(String configXml)
     209        {
     210                if (configXml == null)
     211                        return 0;
     212                int configId = 0;
     213                int configLen = configXml.length();
     214                for (int n=0; n<configLen; n++) {
     215                        configId += configXml.codePointAt(n);
     216                        if (configId < CONFIGID_UPNP_ORG_MAX)
     217                                continue;
     218                        configId = configId % CONFIGID_UPNP_ORG_MAX;
     219                }
     220                return configId;
     221        }
     222       
    193223        ////////////////////////////////////////////////
    194224        // XML Parser
  • router/java/src/org/cybergarage/upnp/event/NotifyRequest.java

    r819b07a5 rc79e4aea  
    131131                setSEQ(notifyCnt);
    132132
    133                 setContentType(XML.CONTENT_TYPE);
     133                setContentType(XML.DEFAULT_CONTENT_TYPE);
    134134                Node propSetNode = createPropertySetNode(varName, value);
    135135                setContent(propSetNode);               
  • router/java/src/org/cybergarage/upnp/event/PropertyList.java

    r819b07a5 rc79e4aea  
    1818import java.util.*;
    1919
    20 public class PropertyList extends Vector<Property> 
     20public class PropertyList extends Vector<Property>
    2121{
    2222        ////////////////////////////////////////////////
  • router/java/src/org/cybergarage/upnp/event/SubscriberList.java

    r819b07a5 rc79e4aea  
    2020import java.util.*;
    2121
    22 public class SubscriberList extends Vector<Subscriber> 
     22public class SubscriberList extends Vector<Subscriber>
    2323{
    2424        ////////////////////////////////////////////////
  • router/java/src/org/cybergarage/upnp/ssdp/SSDPRequest.java

    r819b07a5 rc79e4aea  
    109109                return SSDP.getLeaseTime(cacheCtrl);
    110110        }
     111
     112        ////////////////////////////////////////////////
     113        //      BootId
     114        ////////////////////////////////////////////////
     115
     116        public void setBootId(int bootId)
     117        {
     118                setHeader(HTTP.BOOTID_UPNP_ORG, bootId);
     119        }
     120
     121        public int getBootId()
     122        {
     123                return getIntegerHeaderValue(HTTP.BOOTID_UPNP_ORG);
     124        }
    111125}
  • router/java/src/org/cybergarage/upnp/ssdp/SSDPResponse.java

    r819b07a5 rc79e4aea  
    117117
    118118        ////////////////////////////////////////////////
     119        //      BootId
     120        ////////////////////////////////////////////////
     121
     122        public void setBootId(int bootId)
     123        {
     124                setHeader(HTTP.BOOTID_UPNP_ORG, bootId);
     125        }
     126
     127        public int getBootId()
     128        {
     129                return getIntegerHeaderValue(HTTP.BOOTID_UPNP_ORG);
     130        }
     131       
     132        ////////////////////////////////////////////////
    119133        //      getHeader (Override)
    120134        ////////////////////////////////////////////////
  • router/java/src/org/cybergarage/upnp/ssdp/SSDPSearchSocketList.java

    r819b07a5 rc79e4aea  
    6161                this.multicastIPv6 = multicastIPv6;
    6262        }
    63 
    64        
    65        
    6663
    6764        ////////////////////////////////////////////////
  • router/java/src/org/cybergarage/upnp/xml/DeviceData.java

    r819b07a5 rc79e4aea  
    181181         * @param inets The <tt>InetAddress</tt> that will be binded for listing this service.
    182182         *              Use <code>null</code> for the default behaviur.
    183          * @see org.cybergarage.upnp.ssdp
    184          * @see org.cybergarage.upnp
    185          * @see org.cybergarage.net.HostInterface
     183         * @see {@link UPnP}
     184         * @see {@link USSDP}
     185         * @see {@link HostInterface}
    186186         * @since 1.8
    187187         */
  • router/java/src/org/cybergarage/util/FileUtil.java

    r819b07a5 rc79e4aea  
    1919import java.io.File;
    2020import java.io.FileInputStream;
    21 import java.util.Locale;
    2221
    2322public final class FileUtil
     
    7473                if (StringUtil.hasData(name) == false)
    7574                        return false;
    76                 String lowerName = name.toLowerCase(Locale.US);
     75                String lowerName = name.toLowerCase();
    7776                return lowerName.endsWith("xml");
    7877        }
  • router/java/src/org/cybergarage/xml/Attribute.java

    r819b07a5 rc79e4aea  
    2727        public Attribute(String name, String value)
    2828        {
     29                this();
    2930                setName(name);
    3031                setValue(value);
    3132        }
    3233
     34        public Attribute(Attribute otherAttr)
     35        {
     36                this();
     37                set(otherAttr);
     38        }
     39       
    3340        ////////////////////////////////////////////////
    3441        //      name
     
    5865                return value;
    5966        }
     67
     68        ////////////////////////////////////////////////
     69        //      set
     70        ////////////////////////////////////////////////
     71
     72        public void set(Attribute otherAttr)
     73        {
     74                setName(otherAttr.getName());
     75                setValue(otherAttr.getValue());
     76        }
    6077}
    6178
  • router/java/src/org/cybergarage/xml/AttributeList.java

    r819b07a5 rc79e4aea  
    1818import java.util.Vector;
    1919
    20 public class AttributeList extends Vector<Attribute> 
     20public class AttributeList extends Vector<Attribute>
    2121{
    2222        public AttributeList()
  • router/java/src/org/cybergarage/xml/Node.java

    r819b07a5 rc79e4aea  
    6262        }
    6363
     64        public Node(Node otherNode)
     65        {
     66                this();
     67                set(otherNode);
     68        }
     69       
    6470        ////////////////////////////////////////////////
    6571        //      parent node
     
    190196        }
    191197
     198        public void removeAllAttributes()
     199        {
     200                attrList.clear();
     201        }
     202       
    192203        public boolean hasAttributes()
    193204        {
     
    240251        }
    241252               
     253        ////////////////////////////////////////////////
     254        //      set
     255        ////////////////////////////////////////////////
     256       
     257        public boolean set(Node otherNode) {
     258                if (otherNode == null)
     259                        return false;
     260               
     261                setName(otherNode.getName());           
     262                setValue(otherNode.getValue());
     263
     264                removeAllAttributes();
     265                int nOtherAttributes = otherNode.getNAttributes();
     266                for (int n=0; n<nOtherAttributes; n++) {
     267                        Attribute otherAttr = otherNode.getAttribute(n);
     268                        Attribute thisAttr = new Attribute(otherAttr);
     269                        addAttribute(thisAttr);
     270                }
     271               
     272                removeAllNodes();
     273                int nOtherChildNodes = otherNode.getNNodes();
     274                for (int n=0; n<nOtherChildNodes; n++) {
     275                        Node otherChildNode = otherNode.getNode(n);
     276                        Node thisChildNode = new Node();
     277                        thisChildNode.set(otherChildNode);
     278                        addNode(thisChildNode);
     279                }
     280               
     281                return true;
     282        }
     283       
     284        ////////////////////////////////////////////////
     285        //      equals
     286        ////////////////////////////////////////////////
     287       
     288        public boolean equals(Node otherNode) {
     289                if (otherNode == null)
     290                        return false;
     291
     292                String thisNodeString = toString();
     293                String otherNodeString = otherNode.toString();
     294               
     295                return thisNodeString.equals(otherNodeString);
     296        }
     297       
    242298        ////////////////////////////////////////////////
    243299        //      Child node
     
    310366        ////////////////////////////////////////////////
    311367
     368        public boolean hasNode(String name) {
     369                Node node = getNode(name);
     370                if (node != null) {
     371                        return true;
     372                }
     373                return false;
     374        }
     375       
     376        public void setNode(String name) {
     377                if (hasNode(name)) {
     378                        return;
     379                }
     380                Node node = new Node(name);
     381                addNode(node);
     382        }
     383       
    312384        public void setNode(String name, String value) {
    313385                Node node = getNode(name);
    314                 if (node != null) {
    315                         node.setValue(value);
    316                         return;
    317                 }
    318                 node = new Node(name);
     386                if (node == null) {
     387                        node = new Node(name);
     388                        addNode(node);
     389                }
    319390                node.setValue(value);
    320                 addNode(node);
    321391        }
    322392
  • router/java/src/org/cybergarage/xml/NodeList.java

    r819b07a5 rc79e4aea  
    1818import java.util.Vector;
    1919
    20 public class NodeList extends Vector<Node> 
     20public class NodeList extends Vector<Node>
    2121{
    2222        public NodeList()
  • router/java/src/org/cybergarage/xml/XML.java

    r819b07a5 rc79e4aea  
    2121public class XML
    2222{
    23         public final static String CONTENT_TYPE = "text/xml; charset=\"utf-8\"";
     23        public final static String DEFAULT_CONTENT_TYPE = "text/xml; charset=\"utf-8\"";
     24        public final static String DEFAULT_CONTENT_LANGUAGE = "en";
    2425        public final static String CHARSET_UTF8 = "utf-8";
    2526
Note: See TracChangeset for help on using the changeset viewer.