Changeset 21466e0


Ignore:
Timestamp:
May 25, 2012 7:55:02 PM (8 years ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
26846d5
Parents:
b033db96 (diff), d18e4d4 (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:

explicit merge of 'dd3f93f7ec59e6a7f967945a75c5d4d7b53539ed'

and 'e99d32aef6da4112890ebe09c3f7d8fcb8b647e5'

Files:
1 added
66 edited

Legend:

Unmodified
Added
Removed
  • licenses/LICENSE-UPnP.txt

    rb033db96 r21466e0  
    1 Copyright (C) 2003-2006 Satoshi Konno
     1Copyright (c) 2003-2010, Satoshi Konno
     2
    23All rights reserved.
    34
    45Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
    56
    6 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
     7    * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
     8    * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
     9    * Neither the name of the Cyber Garage nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
    710
    8 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
    9 
    10 3. The name of the author may not be used to endorse or promote products derived from this software without specific prior written permission.
    11 
    12 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     11THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     12"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     13LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     14A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
     15CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
     16EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
     17PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
     18PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
     19LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
     20NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
     21SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  • router/java/src/org/cybergarage/http/HTTP.java

    rb033db96 r21466e0  
    3131package org.cybergarage.http;
    3232
    33 import java.net.*;
     33import java.net.URL;
    3434
    3535public class HTTP
     
    4646               
    4747        public static final String CRLF = "\r\n";
     48        public static final byte CR = '\r';
     49        public static final byte LF = '\n';
    4850        public static final String TAB = "\t";
    4951       
     
    6062        public static final String DATE = "Date";
    6163        public static final String CACHE_CONTROL = "Cache-Control";
    62                 public static final String NO_CACHE = "no-cache";
    63                 public static final String MAX_AGE = "max-age";
     64        public static final String NO_CACHE = "no-cache";
     65        public static final String MAX_AGE = "max-age";
    6466        public static final String CONNECTION = "Connection";
    65                 public static final String CLOSE = "close";
     67        public static final String CLOSE = "close";
    6668        public static final String KEEP_ALIVE = "Keep-Alive";
    6769        public static final String CONTENT_TYPE = "Content-Type";
     70        public static final String CHARSET = "charset";
    6871        public static final String CONTENT_LENGTH = "Content-Length";
    6972        public static final String CONTENT_RANGE = "Content-Range";
    70                 public static final String CONTENT_RANGE_BYTES = "bytes";
     73        public static final String CONTENT_RANGE_BYTES = "bytes";
    7174        // Thanks for Brent Hills (10/20/04)
    7275        public static final String RANGE = "Range";
    7376        public static final String TRANSFER_ENCODING = "Transfer-Encoding";
    74                 public static final String CHUNKED = "Chunked";
     77        public static final String CHUNKED = "Chunked";
    7578        public static final String LOCATION = "Location";
    7679        public static final String SERVER = "Server";
  • router/java/src/org/cybergarage/http/HTTPHeader.java

    rb033db96 r21466e0  
    1919package org.cybergarage.http;
    2020
    21 import java.io.*;
     21import java.io.IOException;
     22import java.io.LineNumberReader;
     23import java.io.StringReader;
    2224
    23 import org.cybergarage.util.*;
     25import org.cybergarage.util.Debug;
    2426
    2527public class HTTPHeader
    2628{
     29        private static int MAX_LENGTH = 1024;
    2730        private String name;
    2831        private String value;
     
    113116        public final static String getValue(String data, String name)
    114117        {
     118                /* Thanks for Stephan Mehlhase (2010-10-26) */
    115119                StringReader strReader = new StringReader(data);
    116                 LineNumberReader lineReader = new LineNumberReader(strReader);
     120                LineNumberReader lineReader = new LineNumberReader(strReader, Math.min(data.length(), MAX_LENGTH));
    117121                return getValue(lineReader, name);
    118122        }
  • router/java/src/org/cybergarage/http/HTTPPacket.java

    rb033db96 r21466e0  
    6060*       03/02/05
    6161*               - Changed post() to suppot chunked stream.
     62*       06/11/05
     63*               - Added setHost().
     64*       07/07/05
     65*               - Lee Peik Feng <pflee@users.sourceforge.net>
     66*               - Andrey Ovchar <AOvchar@consultitnow.com>
     67*               - Fixed set() to parse the chunk size as a hex string.
     68*       11/02/05
     69*               - Changed set() to use BufferedInputStream instead of BufferedReader to
     70*                 get the content as a byte stream.
     71*       11/06/05
     72*               - Added getCharSet().
     73*               - Changed getContentString() to return the content string using the charset.
    6274*
    6375*******************************************************************/
     
    6577package org.cybergarage.http;
    6678
    67 import java.io.*;
    68 import java.util.*;
    69 
    70 import org.cybergarage.net.*;
    71 import org.cybergarage.util.*;
     79import java.io.BufferedInputStream;
     80import java.io.ByteArrayOutputStream;
     81import java.io.IOException;
     82import java.io.InputStream;
     83import java.io.InterruptedIOException;
    7284import java.util.Calendar;
     85import java.util.StringTokenizer;
     86import java.util.Vector;
     87
     88import org.cybergarage.net.HostInterface;
     89import org.cybergarage.util.Debug;
     90import org.cybergarage.util.StringUtil;
    7391
    7492public class HTTPPacket
     
    130148        ////////////////////////////////////////////////
    131149       
     150        private String readLine(BufferedInputStream in)
     151        {
     152                ByteArrayOutputStream lineBuf = new ByteArrayOutputStream();
     153                byte readBuf[] = new byte[1];
     154               
     155                try {
     156                        int     readLen = in.read(readBuf);
     157                        while (0 < readLen) {
     158                                if (readBuf[0] == HTTP.LF)
     159                                        break;
     160                                if (readBuf[0] != HTTP.CR)
     161                                        lineBuf.write(readBuf[0]);
     162                                readLen = in.read(readBuf);
     163                        }
     164                }
     165                catch (InterruptedIOException e) {
     166                        //Ignoring warning because it's a way to break the HTTP connecttion
     167                        //TODO Create a new level of Logging and log the event
     168                }
     169                catch (IOException e) {
     170                        Debug.warning(e);
     171                }
     172
     173                return lineBuf.toString();
     174        }
     175       
    132176        protected boolean set(InputStream in, boolean onlyHeaders)
    133177        {
    134178                try {
    135                         BufferedReader reader = new BufferedReader(new InputStreamReader(in));
     179                        BufferedInputStream reader = new BufferedInputStream(in);
    136180                       
    137                         String firstLine = reader.readLine();
     181                        String firstLine = readLine(reader);
    138182                        if (firstLine == null || firstLine.length() <= 0)
    139183                                return false;
     
    149193                                //response in the stream.
    150194                                //skip all header lines
    151                                 String headerLine = reader.readLine();
     195                                String headerLine = readLine(reader);
    152196                                while ((headerLine != null) && (0 < headerLine.length()) ) {
    153197                                        HTTPHeader header = new HTTPHeader(headerLine);
    154198                                        if (header.hasName() == true)
    155199                                                setHeader(header);
    156                                         headerLine = reader.readLine();
     200                                        headerLine = readLine(reader);
    157201                                }
    158202                                //look forward another first line
    159                                 String actualFirstLine = reader.readLine();
     203                                String actualFirstLine = readLine(reader);
    160204                                if ((actualFirstLine != null) && (0 < actualFirstLine.length()) ) {
    161205                                        //this is the actual first line
     
    166210                        }
    167211                               
    168                         String headerLine = reader.readLine();
     212                        String headerLine = readLine(reader);
    169213                        while ((headerLine != null) && (0 < headerLine.length()) ) {
    170214                                HTTPHeader header = new HTTPHeader(headerLine);
    171215                                if (header.hasName() == true)
    172216                                        setHeader(header);
    173                                 headerLine = reader.readLine();
     217                                headerLine = readLine(reader);
    174218                        }
    175219                               
     
    184228                        if (isChunkedRequest == true) {
    185229                                try {
    186                                         String chunkSizeLine = reader.readLine();
    187                                         contentLen = Long.parseLong(new String(chunkSizeLine.getBytes(), 0, chunkSizeLine.length()-2));
     230                                        String chunkSizeLine = readLine(reader);
     231                                        // Thanks for Lee Peik Feng <pflee@users.sourceforge.net> (07/07/05)
     232                                        //contentLen = Long.parseLong(new String(chunkSizeLine.getBytes(), 0, chunkSizeLine.length()-2), 16);
     233                                        contentLen = (chunkSizeLine != null) ? Long.parseLong(chunkSizeLine.trim(), 16) : 0;
    188234                                }
    189235                                catch (Exception e) {};
     
    192238                                contentLen = getContentLength();
    193239                                               
    194                         StringBuilder contentBuf = new StringBuilder();
     240                        ByteArrayOutputStream contentBuf = new ByteArrayOutputStream();
    195241                       
    196242                        while (0 < contentLen) {
    197243                                int chunkSize = HTTP.getChunkSize();
    198                                 char readBuf[] = new char[chunkSize];
     244                               
     245                                /* Thanks for Stephan Mehlhase (2010-10-26) */
     246                                byte readBuf[] = new byte[(int) (contentLen > chunkSize ? chunkSize : contentLen)];
     247                               
    199248                                long readCnt = 0;
    200249                                while (readCnt < contentLen) {
     
    207256                                                if (readLen < 0)
    208257                                                        break;
    209                                                 contentBuf.append(new String(readBuf, 0, readLen));
     258                                                contentBuf.write(readBuf, 0, readLen);
    210259                                                readCnt += readLen;
    211260                                        }
     
    227276                                        // read next chunk size
    228277                                        try {
    229                                                 String chunkSizeLine = reader.readLine();
    230                                                 contentLen = Long.parseLong(new String(chunkSizeLine.getBytes(), 0, chunkSizeLine.length()-2));
     278                                                String chunkSizeLine = readLine(reader);
     279                                                // Thanks for Lee Peik Feng <pflee@users.sourceforge.net> (07/07/05)
     280                                                contentLen = Long.parseLong(new String(chunkSizeLine.getBytes(), 0, chunkSizeLine.length()-2), 16);
    231281                                        }
    232282                                        catch (Exception e) {
     
    238288                        }
    239289
    240                         // Thanks for Ralf G. R. Bergs (02/09/04)
    241                         String contentStr = contentBuf.toString();
    242                         setContent(contentStr.getBytes(), false);
     290                        setContent(contentBuf.toByteArray(), false);
    243291                }
    244292                catch (Exception e) {
     
    465513        public String getHeaderString()
    466514        {
    467                 StringBuilder str = new StringBuilder();
     515                StringBuffer str = new StringBuffer();
    468516       
    469517                int nHeaders = getNHeaders();
     
    511559        public  String getContentString()
    512560        {
     561                String charSet = getCharSet();
     562                if (charSet == null || charSet.length() <= 0)
     563                        return new String(content);
     564                try {
     565                        return new String(content, charSet);
     566                }
     567                catch (Exception e) {
     568                        Debug.warning(e);
     569                }
    513570                return new String(content);
    514571        }
     
    552609        {
    553610                return getHeaderValue(HTTP.CONTENT_TYPE);
     611        }
     612
     613        ////////////////////////////////////////////////
     614        //      Charset
     615        ////////////////////////////////////////////////
     616
     617        public String getCharSet()
     618        {
     619                String contentType = getContentType();
     620                if (contentType == null)
     621                        return "";
     622                contentType = contentType.toLowerCase();
     623                int charSetIdx = contentType.indexOf(HTTP.CHARSET);
     624                if (charSetIdx < 0)
     625                        return "";
     626                int charSetEndIdx = charSetIdx + HTTP.CHARSET.length() + 1;
     627                String charSet = new String(contentType.getBytes(), charSetEndIdx, (contentType.length() - charSetEndIdx));
     628                if (charSet.length() < 0)
     629                        return "";
     630                if (charSet.charAt(0) == '\"')
     631                        charSet = charSet.substring(1, (charSet.length() - 1));
     632                if (charSet.length() < 0)
     633                        return "";
     634                if (charSet.charAt((charSet.length()-1)) == '\"')
     635                        charSet = charSet.substring(0, (charSet.length() - 1));
     636                return charSet;
    554637        }
    555638
     
    643726                if (strToken.hasMoreTokens() == false)
    644727                        return range;
    645                 strToken.nextToken(" ");
     728                String bytesStr = strToken.nextToken(" ");
    646729                // Get first-byte-pos
    647730                if (strToken.hasMoreTokens() == false)
     
    738821        }
    739822
     823        public void setHost(String host)
     824        {
     825                String hostAddr = host;
     826                if (HostInterface.isIPv6Address(host) == true)
     827                        hostAddr = "[" + host + "]";
     828                setHeader(HTTP.HOST, hostAddr);
     829        }
     830       
    740831        public String getHost()
    741832        {
  • router/java/src/org/cybergarage/http/HTTPRequest.java

    rb033db96 r21466e0  
    4545*       03/02/05
    4646*               - Changed post() to suppot chunked stream.
     47*       06/10/05
     48*               - Changed post() to add a HOST headedr before the posting.
     49*       07/07/05
     50*               - Lee Peik Feng <pflee@users.sourceforge.net>
     51*               - Fixed post() to output the chunk size as a hex string.
    4752*
    4853******************************************************************/
     
    5055package org.cybergarage.http;
    5156
    52 import java.io.*;
    53 import java.net.*;
    54 import java.util.*;
     57import java.io.IOException;
     58import java.io.InputStream;
     59import java.io.OutputStream;
     60import java.io.PrintStream;
     61import java.net.Socket;
     62import java.net.SocketException;
     63import java.net.InetSocketAddress;
     64import java.util.StringTokenizer;
    5565
    5666import org.cybergarage.util.Debug;
    57 
     67/**
     68 *
     69 * This class rappresnet an HTTP <b>request</b>, and act as HTTP client when it sends the request<br>
     70 *
     71 * @author Satoshi "skonno" Konno
     72 * @author Stefano "Kismet" Lenzi
     73 * @version 1.8
     74 *
     75 */
    5876public class HTTPRequest extends HTTPPacket
    5977{
     
    6482        public HTTPRequest()
    6583        {
     84                setVersion(HTTP.VERSION_10);
    6685        }
    6786
     
    299318        public String getHeader()
    300319        {
    301                 StringBuilder str = new StringBuilder();
     320                StringBuffer str = new StringBuffer();
    302321               
    303322                str.append(getFirstLineString());
     
    373392                HTTPResponse httpRes = new HTTPResponse();
    374393
     394                setHost(host);
     395               
    375396                setConnection((isKeepAlive == true) ? HTTP.KEEP_ALIVE : HTTP.CLOSE);
    376397               
     
    411432                        if (0 < contentLength) {
    412433                                if (isChunkedRequest == true) {
    413                                         String chunSizeBuf = Long.toString(contentLength);
     434                                        // Thanks for Lee Peik Feng <pflee@users.sourceforge.net> (07/07/05)
     435                                        String chunSizeBuf = Long.toHexString(contentLength);
    414436                                        pout.print(chunSizeBuf);
    415437                                        pout.print(HTTP.CRLF);
     
    429451                        in = postSocket.getInputStream();
    430452                        httpRes.set(in, isHeaderRequest);               
    431                 }
    432                 catch (Exception e) {
     453                } catch (SocketException e) {
    433454                        httpRes.setStatusCode(HTTPStatus.INTERNAL_SERVER_ERROR);
    434                         // I2P addition
     455                        Debug.warning(e);
     456                } catch (IOException e) {
     457                        //Socket create but without connection
     458                        //TODO Blacklistening the device
     459                        httpRes.setStatusCode(HTTPStatus.INTERNAL_SERVER_ERROR);
    435460                        Debug.warning(e);
    436461                } finally {
     
    497522        public String toString()
    498523        {
    499                 StringBuilder str = new StringBuilder();
     524                StringBuffer str = new StringBuffer();
    500525
    501526                str.append(getHeader());
  • router/java/src/org/cybergarage/http/HTTPResponse.java

    rb033db96 r21466e0  
    2020package org.cybergarage.http;
    2121
    22 import java.io.*;
     22import java.io.InputStream;
    2323import org.cybergarage.util.Debug;
    2424
     
    3131        public HTTPResponse()
    3232        {
     33                setVersion(HTTP.VERSION_11);
    3334                setContentType(HTML.CONTENT_TYPE);
    3435                setServer(HTTPServer.getName());
     
    8687        public String getHeader()
    8788        {
    88                 StringBuilder str = new StringBuilder();
     89                StringBuffer str = new StringBuffer();
    8990       
    9091                str.append(getStatusLineString());
     
    100101        public String toString()
    101102        {
    102                 StringBuilder str = new StringBuilder();
     103                StringBuffer str = new StringBuffer();
    103104
    104105                str.append(getStatusLineString());
  • router/java/src/org/cybergarage/http/HTTPServer.java

    rb033db96 r21466e0  
    2020package org.cybergarage.http;
    2121
    22 import java.io.*;
    23 import java.net.*;
    24 
    25 import org.cybergarage.util.*;
    26 
     22import java.io.IOException;
     23import java.net.InetAddress;
     24import java.net.ServerSocket;
     25import java.net.Socket;
     26
     27import org.cybergarage.util.Debug;
     28import org.cybergarage.util.ListenerList;
     29
     30/**
     31 *
     32 * This class identifies an HTTP over TCP server<br>
     33 * The server must be initialized iether by the {@link HTTPServer#open(InetAddress, int)} or the {@link HTTPServer#open(String, int)} method.<br>
     34 * Optionally a set of {@link HTTPRequestListener} may be set<br>
     35 * The server then can be started or stopped by the method {@link HTTPServer#start()} and {@link HTTPServer#stop()}
     36 *
     37 * @author Satoshi "skonno" Konno
     38 * @author Stefano "Kismet" Lenzi
     39 * @version 1.8
     40 *
     41 */
    2742public class HTTPServer implements Runnable
    2843{
     
    3550
    3651        public final static int DEFAULT_PORT = 80;
    37 
     52       
     53        /**
     54         * Default timeout connection for HTTP comunication
     55         * @since 1.8
     56         */
     57        public final static int DEFAULT_TIMEOUT = DEFAULT_PORT * 1000;
     58       
    3859        public static String getName()
    3960        {
     
    5071        {
    5172                serverSock = null;
     73               
    5274        }
    5375
     
    5981        private InetAddress bindAddr = null;
    6082        private int bindPort = 0;
     83        /**
     84         * Store the current TCP timeout value
     85         * The variable should be accessed by getter and setter metho
     86         */
     87        protected int timeout = DEFAULT_TIMEOUT;
    6188       
    6289        public ServerSocket getServerSock()
     
    77104        }
    78105       
     106       
     107       
    79108        ////////////////////////////////////////////////
    80109        //      open/close
    81110        ////////////////////////////////////////////////
     111       
     112        /**
     113         * Get the current socket timeout
     114         * @since 1.8
     115         */
     116        public synchronized int getTimeout() {
     117                return timeout;
     118        }
     119
     120        /**
     121         * Set the current socket timeout
     122         * @param longout new timeout
     123         * @since 1.8
     124         */
     125        public synchronized void setTimeout(int timeout) {
     126                this.timeout = timeout;
     127        }
     128
     129        public boolean open(InetAddress addr,int port){
     130                if (serverSock != null)
     131                        return true;
     132                try {
     133                        serverSock = new ServerSocket(bindPort, 0, bindAddr);
     134                }catch (IOException e) {
     135                        return false;
     136                }
     137                return true;
     138        }
    82139       
    83140        public boolean open(String addr, int port)
     
    89146                        bindPort = port;
    90147                        serverSock = new ServerSocket(bindPort, 0, bindAddr);
    91                         serverSock.setSoTimeout(10*1000);
    92148                }
    93149                catch (IOException e) {
     
    121177                try {
    122178                        Socket sock = serverSock.accept();
    123                         sock.setSoTimeout(HTTP.DEFAULT_TIMEOUT * 1000);
     179                        sock.setSoTimeout(getTimeout());
    124180                        return sock;
    125181                }
     
    176232                        Socket sock;
    177233                        try {
    178                                 //Debug.message("accept ...");
     234                                Debug.message("accept ...");
    179235                                sock = accept();
    180236                                if (sock != null)
     
    187243                        HTTPServerThread httpServThread = new HTTPServerThread(this, sock);
    188244                        httpServThread.start();
    189                         //Debug.message("httpServThread ...");
    190                 }
    191         }
    192        
    193         public boolean start()
    194         {
    195                 httpServerThread = new Thread(this, "UPnP-HTTPServer");
     245                        Debug.message("httpServThread ...");
     246                }
     247        }
     248       
     249        public boolean start(){
     250                StringBuffer name = new StringBuffer("Cyber.HTTPServer/");
     251                name.append(serverSock.getLocalSocketAddress());
     252                httpServerThread = new Thread(this,name.toString());
    196253                httpServerThread.start();
    197254                return true;
  • router/java/src/org/cybergarage/http/HTTPServerList.java

    rb033db96 r21466e0  
    1111*       05/08/03
    1212*               - first revision.
     13*       24/03/06
     14*               - Stefano Lenzi:added debug information as request by Stephen More
    1315*
    1416******************************************************************/
     
    1618package org.cybergarage.http;
    1719
    18 import java.util.*;
     20import java.net.InetAddress;
     21import java.util.Vector;
    1922
    20 import org.cybergarage.net.*;
     23import org.cybergarage.net.HostInterface;
     24import org.cybergarage.upnp.Device;
    2125
    2226public class HTTPServerList extends Vector
     
    2630        ////////////////////////////////////////////////
    2731       
    28         private static final long serialVersionUID = 2379889735659369065L;
    29 
    30         public HTTPServerList()
    31         {
     32        private InetAddress[] binds = null;
     33        private int port = Device.HTTP_DEFAULT_PORT;
     34       
     35        public HTTPServerList() {
     36        }
     37       
     38        public HTTPServerList(InetAddress[] list, int port) {
     39                this.binds = list;
     40                this.port = port;
    3241        }
    3342
     
    6372        }
    6473
     74        public int open(){
     75                InetAddress[] binds=this.binds;
     76                String[] bindAddresses;
     77                if(binds!=null){                       
     78                        bindAddresses = new String[binds.length];
     79                        for (int i = 0; i < binds.length; i++) {
     80                                bindAddresses[i] = binds[i].getHostAddress();
     81                        }
     82                }else{
     83                        int nHostAddrs = HostInterface.getNHostAddresses();
     84                        bindAddresses = new String[nHostAddrs];
     85                        for (int n=0; n<nHostAddrs; n++) {
     86                                bindAddresses[n] = HostInterface.getHostAddress(n);
     87                        }
     88                }               
     89                int j=0;
     90                for (int i = 0; i < bindAddresses.length; i++) {
     91                        HTTPServer httpServer = new HTTPServer();
     92                        if((bindAddresses[i]==null) || (httpServer.open(bindAddresses[i], port) == false)) {
     93                                close();
     94                                clear();
     95                        }else{
     96                                add(httpServer);
     97                                j++;
     98                        }
     99                }
     100                return j;
     101        }
     102       
     103       
    65104        public boolean open(int port)
    66105        {
    67                 int nHostAddrs = HostInterface.getNHostAddresses();
    68                 for (int n=0; n<nHostAddrs; n++) {
    69                         String bindAddr = HostInterface.getHostAddress(n);
    70                         HTTPServer httpServer = new HTTPServer();
    71                         if (httpServer.open(bindAddr, port) == false) {
    72                                 close();
    73                                 clear();
    74                                 return false;
    75                         }
    76                         add(httpServer);
    77                 }
    78                 return true;
     106                this.port=port;
     107                return open()!=0;
    79108        }
    80109       
  • router/java/src/org/cybergarage/http/HTTPServerThread.java

    rb033db96 r21466e0  
    1616package org.cybergarage.http;
    1717
    18 import java.net.*;
     18import java.net.Socket;
    1919
    2020public class HTTPServerThread extends Thread
     
    2929        public HTTPServerThread(HTTPServer httpServer, Socket sock)
    3030        {
     31        super("Cyber.HTTPServerThread");
    3132                this.httpServer = httpServer;
    3233                this.sock = sock;
    33                 this.setDaemon(true);
    3434        }
    3535
  • router/java/src/org/cybergarage/http/HTTPSocket.java

    rb033db96 r21466e0  
    1818*       03/02/05
    1919*               - Changed post() to suppot chunked stream.
     20*       06/10/05
     21*               - Changed post() to add a Date headedr to the HTTPResponse before the posting.
     22*       07/07/05
     23*               - Lee Peik Feng <pflee@users.sourceforge.net>
     24*               - Fixed post() to output the chunk size as a hex string.
    2025*       
    2126******************************************************************/
     
    2328package org.cybergarage.http;
    2429
    25 import java.io.*;
    26 import java.net.*;
    27 import java.util.*;
     30import java.io.InputStream;
     31import java.io.OutputStream;
     32import java.net.Socket;
     33import java.util.Calendar;
    2834
    2935public class HTTPSocket
     
    120126                }
    121127                catch (Exception e) {
     128                        //TODO Add blacklistening of the UPnP Device
    122129                        return false;
    123130                }
     
    147154        private boolean post(HTTPResponse httpRes, byte content[], long contentOffset, long contentLength, boolean isOnlyHeader)
    148155        {
     156                //TODO Check for bad HTTP agents, this method may be list for IOInteruptedException and for blacklistening
    149157                httpRes.setDate(Calendar.getInstance());
     158               
    150159                OutputStream out = getOutputStream();
    151160
     
    163172                       
    164173                        if (isChunkedResponse == true) {
    165                                 String chunSizeBuf = Long.toString(contentLength);
     174                                // Thanks for Lee Peik Feng <pflee@users.sourceforge.net> (07/07/05)
     175                                String chunSizeBuf = Long.toHexString(contentLength);
    166176                                out.write(chunSizeBuf.getBytes());
    167177                                out.write(HTTP.CRLF.getBytes());
     
    188198        private boolean post(HTTPResponse httpRes, InputStream in, long contentOffset, long contentLength, boolean isOnlyHeader)
    189199        {
     200                //TODO Check for bad HTTP agents, this method may be list for IOInteruptedException and for blacklistening
    190201                httpRes.setDate(Calendar.getInstance());
     202               
    191203                OutputStream out = getOutputStream();
    192204
     
    214226                        while (0 < readLen && readCnt < contentLength) {
    215227                                if (isChunkedResponse == true) {
    216                                         String chunSizeBuf = Long.toString(readLen);
     228                                        // Thanks for Lee Peik Feng <pflee@users.sourceforge.net> (07/07/05)
     229                                        String chunSizeBuf = Long.toHexString(readLen);
    217230                                        out.write(chunSizeBuf.getBytes());
    218231                                        out.write(HTTP.CRLF.getBytes());
     
    243256        public boolean post(HTTPResponse httpRes, long contentOffset, long contentLength, boolean isOnlyHeader)
    244257        {
     258                //TODO Close if Connection != keep-alive
    245259                if (httpRes.hasContentInputStream() == true)
    246260                        return post(httpRes,httpRes.getContentInputStream(), contentOffset, contentLength, isOnlyHeader);
  • router/java/src/org/cybergarage/http/HTTPStatus.java

    rb033db96 r21466e0  
    2626package org.cybergarage.http;
    2727
    28 import java.util.*;
     28import java.util.StringTokenizer;
    2929
    30 import org.cybergarage.util.*;
     30import org.cybergarage.util.Debug;
    3131
    3232public class HTTPStatus
  • router/java/src/org/cybergarage/http/ParameterList.java

    rb033db96 r21466e0  
    1616package org.cybergarage.http;
    1717
    18 import java.util.*;
     18import java.util.Vector;
    1919
    2020public class ParameterList extends Vector
    2121{
    22         private static final long serialVersionUID = -6026765325018137641L;
    23 
    2422        public ParameterList()
    2523        {
  • router/java/src/org/cybergarage/net/HostInterface.java

    rb033db96 r21466e0  
    2626package org.cybergarage.net;
    2727
    28 import java.net.*;
    29 import java.util.*;
     28import java.net.Inet4Address;
     29import java.net.Inet6Address;
     30import java.net.InetAddress;
     31import java.net.NetworkInterface;
     32import java.net.SocketException;
     33import java.util.ArrayList;
     34import java.util.Enumeration;
     35import java.util.Vector;
     36
     37import org.cybergarage.util.Debug;
    3038
    3139public class HostInterface
     
    4452       
    4553        private static String ifAddress = "";
     54        public final static int IPV4_BITMASK =  0x0001;
     55        public final static int IPV6_BITMASK =  0x0010;
     56        public final static int LOCAL_BITMASK = 0x0100;
    4657
    4758        public final static void setInterface(String ifaddr)
     
    102113                        }
    103114                }
    104                 catch(Exception e){};
     115                catch(Exception e){
     116                        Debug.warning(e);
     117                };
    105118                return nHostAddrs;
    106119        }
    107120
     121        /**
     122         *
     123         * @param ipfilter
     124         * @param interfaces
     125         * @return
     126         * @since 1.8.0
     127         * @author Stefano "Kismet" Lenzi &lt;kismet.sl@gmail.com&gt;
     128         */
     129        public final static InetAddress[] getInetAddress(int ipfilter,String[] interfaces){
     130                Enumeration nis;
     131                if(interfaces!=null){
     132                        Vector iflist = new Vector();
     133                        for (int i = 0; i < interfaces.length; i++) {
     134                                NetworkInterface ni;
     135                                try {
     136                                        ni = NetworkInterface.getByName(interfaces[i]);
     137                                } catch (SocketException e) {
     138                                        continue;
     139                                }
     140                                if(ni != null) iflist.add(ni);
     141
     142                        }
     143                        nis = iflist.elements();
     144                }else{
     145                        try {
     146                                nis = NetworkInterface.getNetworkInterfaces();
     147                        } catch (SocketException e) {
     148                                return null;
     149                        }
     150                }               
     151                ArrayList addresses = new ArrayList();
     152                while (nis.hasMoreElements()){
     153                        NetworkInterface ni = (NetworkInterface)nis.nextElement();                     
     154                        Enumeration addrs = ni.getInetAddresses();
     155                        while (addrs.hasMoreElements()) {
     156                                InetAddress addr = (InetAddress)addrs.nextElement();
     157                                if(((ipfilter & LOCAL_BITMASK)==0) && addr.isLoopbackAddress())
     158                                        continue;
     159                               
     160                                if (((ipfilter & IPV4_BITMASK)!=0) && addr instanceof Inet4Address ) {                                         
     161                                        addresses.add(addr);
     162                                }else if (((ipfilter & IPV6_BITMASK)!=0)&& addr instanceof InetAddress) {
     163                                        addresses.add(addr);
     164                                }
     165                        }
     166                }
     167                return (InetAddress[]) addresses.toArray(new InetAddress[]{});
     168        }
     169       
     170       
    108171        public final static String getHostAddress(int n)
    109172        {
     
    144207                try {
    145208                        InetAddress addr = InetAddress.getByName(host);
    146                         return (addr instanceof Inet6Address);
     209                        if (addr instanceof Inet6Address)
     210                                return true;
     211                        return false;
    147212                }
    148213                catch (Exception e) {}
     
    154219                try {
    155220                        InetAddress addr = InetAddress.getByName(host);
    156                         return (addr instanceof Inet4Address);
     221                        if (addr instanceof Inet4Address)
     222                                return true;
     223                        return false;
    157224                }
    158225                catch (Exception e) {}
  • router/java/src/org/cybergarage/soap/SOAP.java

    rb033db96 r21466e0  
    1616package org.cybergarage.soap;
    1717
    18 import org.cybergarage.xml.*;
     18import org.cybergarage.xml.Node;
     19import org.cybergarage.xml.Parser;
    1920
    2021public class SOAP
  • router/java/src/org/cybergarage/soap/SOAPRequest.java

    rb033db96 r21466e0  
    2121package org.cybergarage.soap;
    2222
    23 import java.io.*;
     23import java.io.ByteArrayInputStream;
    2424
    25 import org.cybergarage.http.*;
    26 import org.cybergarage.xml.*;
    27 import org.cybergarage.util.*;
     25import org.cybergarage.http.HTTP;
     26import org.cybergarage.http.HTTPRequest;
     27import org.cybergarage.http.HTTPResponse;
     28import org.cybergarage.util.Debug;
     29import org.cybergarage.xml.Node;
     30import org.cybergarage.xml.Parser;
     31import org.cybergarage.xml.ParserException;
    2832
    2933public class SOAPRequest extends HTTPRequest
  • router/java/src/org/cybergarage/soap/SOAPResponse.java

    rb033db96 r21466e0  
    2121package org.cybergarage.soap;
    2222
    23 import org.cybergarage.http.*;
     23import org.cybergarage.http.HTTPResponse;
    2424import org.cybergarage.util.Debug;
    25 import org.cybergarage.xml.*;
     25import org.cybergarage.xml.Node;
     26import org.cybergarage.xml.XML;
    2627
    2728public class SOAPResponse extends HTTPResponse
  • router/java/src/org/cybergarage/upnp/Action.java

    rb033db96 r21466e0  
    2323*               - Thanks for Dimas <cyberrate@users.sourceforge.net> and Stefano Lenzi <kismet-sl@users.sourceforge.net>
    2424*               - Changed postControlAction() to set the status code to the UPnPStatus.
     25*       04/12/06
     26*               - Added setUserData() and getUserData() to set a user original data object.
    2527*
    2628******************************************************************/
    2729
    2830package org.cybergarage.upnp;
    29 
    30 import org.cybergarage.xml.*;
    31 import org.cybergarage.util.*;
    32 
    33 import org.cybergarage.upnp.xml.*;
    34 import org.cybergarage.upnp.control.*;
     31import java.util.Iterator;
     32
     33import org.cybergarage.upnp.control.ActionListener;
     34import org.cybergarage.upnp.control.ActionRequest;
     35import org.cybergarage.upnp.control.ActionResponse;
     36import org.cybergarage.upnp.control.ControlResponse;
     37import org.cybergarage.upnp.xml.ActionData;
     38import org.cybergarage.util.Debug;
     39import org.cybergarage.util.Mutex;
     40import org.cybergarage.xml.Node;
    3541
    3642public class Action
     
    5965        }
    6066       
     67        void setService(Service s){
     68                serviceNode=s.getServiceNode();
     69                /*To ensure integrity of the XML structure*/
     70                Iterator i = getArgumentList().iterator();
     71                while (i.hasNext()) {
     72                        Argument arg = (Argument) i.next();
     73                        arg.setService(s);
     74                }               
     75        }
     76       
    6177        public Node getActionNode()
    6278        {
     
    6783        //      Constructor
    6884        ////////////////////////////////////////////////
     85        public Action(Node serviceNode){
     86                //TODO Test
     87                this.serviceNode = serviceNode;
     88                this.actionNode = new Node(Action.ELEM_NAME);           
     89        }
    6990
    7091        public Action(Node serviceNode, Node actionNode)
     
    140161                }
    141162                return argumentList;
     163        }       
     164       
     165        public void setArgumentList(ArgumentList al){
     166                Node argumentListNode = getActionNode().getNode(ArgumentList.ELEM_NAME);
     167                if (argumentListNode == null){
     168                        argumentListNode = new Node(ArgumentList.ELEM_NAME);
     169                        getActionNode().addNode(argumentListNode);
     170                }else{
     171                        argumentListNode.removeAllNodes();
     172                }
     173                Iterator i = al.iterator();
     174                while (i.hasNext()) {
     175                        Argument a = (Argument) i.next();
     176                        a.setService(getService());
     177                        argumentListNode.addNode(a.getArgumentNode());
     178                }
     179               
    142180        }
    143181
     
    185223        }
    186224
     225        /**
     226         * @deprecated You should use one of the following methods instead:<br />
     227         *  - {@link #setInArgumentValues(ArgumentList)} <br/>
     228         *  - {@link #setOutArgumentValues(ArgumentList)}
     229         */
    187230        public void setArgumentValues(ArgumentList argList)
    188231        {
    189232                getArgumentList().set(argList);
     233        }
     234
     235        /**
     236         *
     237         * @param argList
     238         * @since 1.8.0
     239         */
     240        public void setInArgumentValues(ArgumentList argList)
     241        {
     242                getArgumentList().setReqArgs(argList);
     243        }
     244       
     245        /**
     246         *
     247         * @param argList
     248         * @since 1.8.0
     249         */
     250        public void setOutArgumentValues(ArgumentList argList)
     251        {
     252                getArgumentList().setResArgs(argList);
    190253        }
    191254       
     
    324387                        return false;
    325388                ArgumentList outArgList = ctrlRes.getResponse();
    326                 actionArgList.set(outArgList);
     389        try {
     390            actionArgList.setResArgs(outArgList);
     391        } catch (IllegalArgumentException ex){
     392            setStatus(UPnPStatus.INVALID_ARGS,"Action succesfully delivered but invalid arguments returned.");
     393            return false;
     394        }
    327395                return true;
    328396        }
     
    368436        }
    369437       
     438        ////////////////////////////////////////////////
     439        //      userData
     440        ////////////////////////////////////////////////
     441
     442        private Object userData = null;
     443       
     444        public void setUserData(Object data)
     445        {
     446                userData = data;
     447        }
     448
     449        public Object getUserData()
     450        {
     451                return userData;
     452        }
    370453}
  • router/java/src/org/cybergarage/upnp/ActionList.java

    rb033db96 r21466e0  
    1616package org.cybergarage.upnp;
    1717
    18 import java.util.*;
     18import java.util.Vector;
    1919
    2020public class ActionList extends Vector
     
    2323        //      Constants
    2424        ////////////////////////////////////////////////
    25 
    26         private static final long serialVersionUID = 1965922721316119846L;
     25       
    2726        public final static String ELEM_NAME = "actionList";
    2827
  • router/java/src/org/cybergarage/upnp/AllowedValue.java

    rb033db96 r21466e0  
    1616package org.cybergarage.upnp;
    1717
    18 import org.cybergarage.xml.*;
     18import org.cybergarage.xml.Node;
    1919
    2020public class AllowedValue
     
    4646        }
    4747
     48        /**
     49         * Create an AllowedValue by the value String,
     50         * and will create the Node structure by itself
     51         *
     52         * @param value The value that will be associate to thi object
     53         *
     54         * @author Stefano "Kismet" Lenzi - kismet-sl@users.sourceforge.net  - 2005
     55         */
     56        public AllowedValue(String value) {
     57
     58                //TODO Some test are done not stable
     59                allowedValueNode = new Node(ELEM_NAME); //better (twa)
     60                setValue(value);                                                //better (twa)
     61        }
     62
    4863        ////////////////////////////////////////////////
    4964        //      isAllowedValueNode
  • router/java/src/org/cybergarage/upnp/AllowedValueList.java

    rb033db96 r21466e0  
    1818package org.cybergarage.upnp;
    1919
    20 import java.util.*;
     20import java.util.Iterator;
     21import java.util.Vector;
    2122
    2223public class AllowedValueList extends Vector
     
    2627        ////////////////////////////////////////////////
    2728       
    28         private static final long serialVersionUID = 5740394642751180992L;
    2929        public final static String ELEM_NAME = "allowedValueList";
    3030
     
    3737        {
    3838        }
     39
     40        public AllowedValueList(String[] values) {
     41                for (int i = 0; i < values.length; i++) {
     42                        add(new AllowedValue(values[i]));
     43                };
     44               
     45        }
     46
    3947       
    4048        ////////////////////////////////////////////////
     
    4755        }
    4856
     57        public boolean isAllowed(String v){
     58                for (Iterator i = this.iterator(); i.hasNext();) {
     59                        AllowedValue av = (AllowedValue) i.next();
     60                        if(av.getValue().equals(v))
     61                                return true;
     62                }
     63                return false;
     64        }
    4965}
  • router/java/src/org/cybergarage/upnp/AllowedValueRange.java

    rb033db96 r21466e0  
    1616package org.cybergarage.upnp;
    1717
    18 import org.cybergarage.xml.*;
     18import org.cybergarage.xml.Node;
    1919
    2020public class AllowedValueRange
     
    4646        }
    4747
     48        public AllowedValueRange(){
     49                //TODO Test
     50                allowedValueRangeNode = new Node(ELEM_NAME);
     51        }
    4852        ////////////////////////////////////////////////
    4953        //      isAllowedValueRangeNode
    5054        ////////////////////////////////////////////////
     55       
     56        public AllowedValueRange(Number max, Number min, Number step) {
     57                //TODO Test
     58                allowedValueRangeNode = new Node(ELEM_NAME);
     59                if(max!=null)
     60                        setMaximum(max.toString());
     61                if(min!=null)
     62                        setMinimum(min.toString());
     63                if(step!=null)
     64                        setStep(step.toString());
     65        }
    5166
    5267        public static boolean isAllowedValueRangeNode(Node node)
  • router/java/src/org/cybergarage/upnp/Argument.java

    rb033db96 r21466e0  
    1818*               - Added getServiceNode() and getService().
    1919*               - Added the parent service node to the constructor.
     20*       04/12/06
     21*               - Added setUserData() and getUserData() to set a user original data object.
    2022*
    2123******************************************************************/
     
    2325package org.cybergarage.upnp;
    2426
    25 import org.cybergarage.xml.*;
    26 
    27 import org.cybergarage.upnp.xml.*;
     27import org.cybergarage.upnp.xml.ArgumentData;
     28import org.cybergarage.xml.Node;
    2829
    2930public class Argument
     
    6061        }
    6162       
     63        void setService(Service s){
     64                s.getServiceNode();
     65        }
     66       
    6267        public Node getActionNode()
    6368        {
     
    8489        public Argument()
    8590        {
    86                 argumentNode = new Node();
     91                argumentNode = new Node(ELEM_NAME);
    8792                serviceNode = null;
     93        }
     94       
     95        public Argument(Node servNode){
     96                argumentNode = new Node(ELEM_NAME);
     97                serviceNode = servNode;         
    8898        }
    8999       
     
    227237
    228238        ////////////////////////////////////////////////
    229         //      Related
    230         ////////////////////////////////////////////////
     239        //      userData
     240        ////////////////////////////////////////////////
     241
     242        private Object userData = null;
     243       
     244        public void setUserData(Object data)
     245        {
     246                userData = data;
     247        }
     248
     249        public Object getUserData()
     250        {
     251                return userData;
     252        }
    231253}
  • router/java/src/org/cybergarage/upnp/ArgumentList.java

    rb033db96 r21466e0  
    1616package org.cybergarage.upnp;
    1717
    18 import java.util.*;
     18import java.util.Vector;
    1919
    2020public class ArgumentList extends Vector
     
    2424        ////////////////////////////////////////////////
    2525       
    26         private static final long serialVersionUID = -5412792105767389170L;
    2726        public final static String ELEM_NAME = "argumentList";
    2827
     
    6160        //      Methods
    6261        ////////////////////////////////////////////////
    63        
     62        /**
     63         * @deprecated
     64         */
    6465        public void set(ArgumentList inArgList)
    6566        {
     
    7475                }
    7576        }
     77
     78        /**
     79         * Set all the Argument which are Input Argoument to the given value in
     80         * the argument list
     81         *
     82         * @param inArgList
     83         */
     84        public void setReqArgs(ArgumentList inArgList)
     85        {
     86        int nArgs = size();
     87        for (int n=0; n<nArgs; n++) {
     88            Argument arg = getArgument(n);
     89            if (arg.isInDirection()){
     90                    String argName = arg.getName();
     91                    Argument inArg = inArgList.getArgument(argName);
     92                    if (inArg == null)
     93                        throw new IllegalArgumentException("Argument \"" + argName + "\" missing.");
     94                    arg.setValue(inArg.getValue());
     95            }
     96        }
     97        }
     98        /**
     99         * Set all the Argument which are Output Argoument to the given value in
     100         * the argument list
     101         *
     102         * @param outArgList
     103         */
     104        public void setResArgs(ArgumentList outArgList)
     105        {
     106        int nArgs = size();
     107        for (int n=0; n<nArgs; n++) {
     108            Argument arg = getArgument(n);
     109            if (arg.isOutDirection()){
     110                    String argName = arg.getName();
     111                    Argument outArg = outArgList.getArgument(argName);
     112                    if (outArg == null)
     113                        throw new IllegalArgumentException("Argument \"" + argName + "\" missing.");
     114                    arg.setValue(outArg.getValue());
     115            }
     116        }
     117        }
     118
     119
    76120}
    77121
  • router/java/src/org/cybergarage/upnp/ControlPoint.java

    rb033db96 r21466e0  
    5555*       03/30/05
    5656*               - Changed addDevice() to use Parser::parse(URL).
     57*       04/12/06
     58*               - Added setUserData() and getUserData() to set a user original data object.
    5759*
    5860*******************************************************************/
     
    6062package org.cybergarage.upnp;
    6163
    62 import org.cybergarage.net.*;
    63 import org.cybergarage.util.*;
    64 import org.cybergarage.xml.*;
    65 import org.cybergarage.http.*;
    66 
    67 import org.cybergarage.upnp.control.*;
    68 import org.cybergarage.upnp.ssdp.*;
    69 import org.cybergarage.upnp.device.*;
    70 import org.cybergarage.upnp.event.*;
    71 
    72 import java.net.*;
     64import java.net.InetAddress;
     65import java.net.MalformedURLException;
     66import java.net.URL;
     67
     68import org.cybergarage.http.HTTPRequest;
     69import org.cybergarage.http.HTTPRequestListener;
     70import org.cybergarage.http.HTTPServerList;
     71import org.cybergarage.net.HostInterface;
     72import org.cybergarage.upnp.control.RenewSubscriber;
     73import org.cybergarage.upnp.device.DeviceChangeListener;
     74import org.cybergarage.upnp.device.Disposer;
     75import org.cybergarage.upnp.device.NotifyListener;
     76import org.cybergarage.upnp.device.ST;
     77import org.cybergarage.upnp.device.SearchResponseListener;
     78import org.cybergarage.upnp.device.USN;
     79import org.cybergarage.upnp.event.EventListener;
     80import org.cybergarage.upnp.event.NotifyRequest;
     81import org.cybergarage.upnp.event.Property;
     82import org.cybergarage.upnp.event.PropertyList;
     83import org.cybergarage.upnp.event.Subscription;
     84import org.cybergarage.upnp.event.SubscriptionRequest;
     85import org.cybergarage.upnp.event.SubscriptionResponse;
     86import org.cybergarage.upnp.ssdp.SSDP;
     87import org.cybergarage.upnp.ssdp.SSDPNotifySocketList;
     88import org.cybergarage.upnp.ssdp.SSDPPacket;
     89import org.cybergarage.upnp.ssdp.SSDPSearchRequest;
     90import org.cybergarage.upnp.ssdp.SSDPSearchResponseSocketList;
     91import org.cybergarage.util.Debug;
     92import org.cybergarage.util.ListenerList;
     93import org.cybergarage.util.Mutex;
     94import org.cybergarage.xml.Node;
     95import org.cybergarage.xml.NodeList;
     96import org.cybergarage.xml.Parser;
     97import org.cybergarage.xml.ParserException;
    7398
    7499public class ControlPoint implements HTTPRequestListener
     
    110135        ////////////////////////////////////////////////
    111136
    112         public ControlPoint(int ssdpPort, int httpPort)
    113         {
    114                 ssdpNotifySocketList = new SSDPNotifySocketList();
    115                 ssdpSearchResponseSocketList = new SSDPSearchResponseSocketList();
     137        public ControlPoint(int ssdpPort, int httpPort,InetAddress[] binds){
     138                ssdpNotifySocketList = new SSDPNotifySocketList(binds);
     139                ssdpSearchResponseSocketList = new SSDPSearchResponseSocketList(binds);
    116140               
    117141                setSSDPPort(ssdpPort);
     
    125149                setNMPRMode(false);
    126150                setRenewSubscriber(null);
     151        }
     152       
     153        public ControlPoint(int ssdpPort, int httpPort){
     154                this(ssdpPort,httpPort,null);
    127155        }
    128156
     
    315343        }
    316344
    317         private void removeDevice(Device dev)
     345        protected void removeDevice(Device dev)
    318346        {
    319347                if (dev == null)
     
    322350        }
    323351       
    324         private void removeDevice(String name)
     352        protected void removeDevice(String name)
    325353        {
    326354                Device dev = getDevice(name);
     
    400428                for (int n=0; n<listenerSize; n++) {
    401429                        NotifyListener listener = (NotifyListener)deviceNotifyListenerList.get(n);
    402                         listener.deviceNotifyReceived(ssdpPacket);
     430                        try{
     431                                listener.deviceNotifyReceived(ssdpPacket);
     432                        }catch(Exception e){
     433                                Debug.warning("NotifyListener returned an error:", e);
     434                        }
    403435                }
    404436        }
     
    425457                for (int n=0; n<listenerSize; n++) {
    426458                        SearchResponseListener listener = (SearchResponseListener)deviceSearchResponseListenerList.get(n);
    427                         listener.deviceSearchResponseReceived(ssdpPacket);
     459                        try{
     460                                listener.deviceSearchResponseReceived(ssdpPacket);
     461                        }catch(Exception e){
     462                                Debug.warning("SearchResponseListener returned an error:", e);
     463                        }
     464
     465
    428466                }
    429467        }
     
    473511        {
    474512                if (packet.isRootDevice() == true) {
    475                         if (packet.isAlive() == true)
     513                        if (packet.isAlive() == true){
    476514                                addDevice(packet);
    477                         if (packet.isByeBye() == true)
     515                        }else if (packet.isByeBye() == true){
    478516                                removeDevice(packet);
     517                        }
    479518                }
    480519                performNotifyListener(packet);
     
    918957
    919958        ////////////////////////////////////////////////
     959        //      userData
     960        ////////////////////////////////////////////////
     961
     962        private Object userData = null;
     963       
     964        public void setUserData(Object data)
     965        {
     966                userData = data;
     967        }
     968
     969        public Object getUserData()
     970        {
     971                return userData;
     972        }
     973       
     974        ////////////////////////////////////////////////
    920975        //      print   
    921976        ////////////////////////////////////////////////
  • router/java/src/org/cybergarage/upnp/Device.java

    rb033db96 r21466e0  
    8383*               - Thanks for Mikael Hakman <mhakman@dkab.net>
    8484*               - 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.
    8594*
    8695******************************************************************/
     
    8897package org.cybergarage.upnp;
    8998
    90 import java.net.*;
    91 import java.io.*;
    92 import java.util.*;
    93 
    94 import org.cybergarage.net.*;
    95 import org.cybergarage.http.*;
    96 import org.cybergarage.util.*;
    97 import org.cybergarage.xml.*;
    98 import org.cybergarage.soap.*;
    99 
    100 import org.cybergarage.upnp.ssdp.*;
    101 import org.cybergarage.upnp.device.*;
    102 import org.cybergarage.upnp.control.*;
    103 import org.cybergarage.upnp.event.*;
    104 import org.cybergarage.upnp.xml.*;
     99import java.io.File;
     100import java.io.InputStream;
     101import java.net.InetAddress;
     102import java.net.URL;
     103import java.util.Calendar;
     104
     105import org.cybergarage.http.HTTP;
     106import org.cybergarage.http.HTTPRequest;
     107import org.cybergarage.http.HTTPResponse;
     108import org.cybergarage.http.HTTPServerList;
     109import org.cybergarage.http.HTTPStatus;
     110import org.cybergarage.net.HostInterface;
     111import org.cybergarage.soap.SOAPResponse;
     112import org.cybergarage.upnp.control.ActionListener;
     113import org.cybergarage.upnp.control.ActionRequest;
     114import org.cybergarage.upnp.control.ActionResponse;
     115import org.cybergarage.upnp.control.ControlRequest;
     116import org.cybergarage.upnp.control.ControlResponse;
     117import org.cybergarage.upnp.control.QueryListener;
     118import org.cybergarage.upnp.control.QueryRequest;
     119import org.cybergarage.upnp.device.Advertiser;
     120import org.cybergarage.upnp.device.Description;
     121import org.cybergarage.upnp.device.InvalidDescriptionException;
     122import org.cybergarage.upnp.device.NTS;
     123import org.cybergarage.upnp.device.ST;
     124import org.cybergarage.upnp.device.SearchListener;
     125import org.cybergarage.upnp.device.USN;
     126import org.cybergarage.upnp.event.Subscriber;
     127import org.cybergarage.upnp.event.Subscription;
     128import org.cybergarage.upnp.event.SubscriptionRequest;
     129import org.cybergarage.upnp.event.SubscriptionResponse;
     130import org.cybergarage.upnp.ssdp.SSDPNotifyRequest;
     131import org.cybergarage.upnp.ssdp.SSDPNotifySocket;
     132import org.cybergarage.upnp.ssdp.SSDPPacket;
     133import org.cybergarage.upnp.ssdp.SSDPSearchResponse;
     134import org.cybergarage.upnp.ssdp.SSDPSearchResponseSocket;
     135import org.cybergarage.upnp.ssdp.SSDPSearchSocketList;
     136import org.cybergarage.upnp.xml.DeviceData;
     137import org.cybergarage.util.Debug;
     138import org.cybergarage.util.FileUtil;
     139import org.cybergarage.util.Mutex;
     140import org.cybergarage.util.TimerUtil;
     141import org.cybergarage.xml.Node;
     142import org.cybergarage.xml.Parser;
     143import org.cybergarage.xml.ParserException;
     144import org.cybergarage.xml.XML;
    105145
    106146public class Device implements org.cybergarage.http.HTTPRequestListener, SearchListener
     
    189229        }
    190230
     231        /**
     232         * @since 1.8.0
     233         */
     234        public Device(InputStream input) throws InvalidDescriptionException
     235        {
     236                this(null, null);
     237                loadDescription(input);
     238        }
     239
     240       
    191241        public Device(String descriptionFileName) throws InvalidDescriptionException
    192242        {
     
    210260        }
    211261       
     262        ////////////////////////////////////////////////
     263        //      getAbsoluteURL
     264        ////////////////////////////////////////////////
     265       
     266        public String getAbsoluteURL(String urlString)
     267        {
     268                try {
     269                        URL url = new URL(urlString);
     270                        return url.toString();
     271                }
     272                catch (Exception e) {}
     273               
     274                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                String absUrl = urlBaseStr + urlString;
     287                try {
     288                        URL url = new URL(absUrl);
     289                        return url.toString();
     290                }
     291                catch (Exception e) {}
     292                       
     293                absUrl = HTTP.getAbsoluteURL(urlBaseStr, urlString);
     294                try {
     295                        URL url = new URL(absUrl);
     296                        return url.toString();
     297                }
     298                catch (Exception e) {}
     299               
     300                return "";
     301        }
     302
    212303        ////////////////////////////////////////////////
    213304        //      NMPR
     
    301392        // Thanks for Stefano Lenzi (07/24/04)
    302393
    303         public Device getParentDevice()
    304         {
     394        /**
     395         *
     396         * @return A Device that contain this object.<br>
     397         *      Return <code>null</code> if this is a root device.
     398         * @author Stefano "Kismet" Lenzi
     399         */
     400        public Device getParentDevice() {
    305401                if(isRootDevice())
    306402                        return null;
    307403                Node devNode = getDeviceNode();
     404                Node aux = null;
    308405                //<device><deviceList><device>
    309                 devNode = devNode.getParentNode().getParentNode().getNode(Device.ELEM_NAME);
    310                 return new Device(devNode);
    311         }
     406                aux = devNode.getParentNode().getParentNode();
     407                return new Device(aux);
     408        }
     409        /**
     410         * Add a Service to device without checking for duplicate or syntax error
     411         *
     412         * @param s Add Service s to the Device
     413         */
     414        public void addService(Service s) {
     415                Node serviceListNode = getDeviceNode().getNode(ServiceList.ELEM_NAME);
     416                if (serviceListNode == null) {
     417                        serviceListNode = new Node(ServiceList.ELEM_NAME);
     418                        getDeviceNode().addNode(serviceListNode);
     419                }
     420                serviceListNode.addNode(s.getServiceNode());
     421        }
     422
     423        /**
     424         * Add a Device to device without checking for duplicate or syntax error.
     425         * This method set or reset the root node of the Device and itself<br>
     426         * <br>
     427         * Note: This method should be used to create a dynamic<br>
     428         * Device withtout writing any XML that describe the device<br>.
     429         *
     430         * @param d Add Device d to the Device
     431         *
     432         * @author Stefano "Kismet" Lenzi - kismet-sl@users.sourceforge.net  - 2005
     433         *
     434         */
     435        public void addDevice(Device d) {
     436                Node deviceListNode = getDeviceNode().getNode(DeviceList.ELEM_NAME);
     437                if (deviceListNode == null) {
     438                        //deviceListNode = new Node(ServiceList.ELEM_NAME); twa wrong ELEM_NAME;
     439                        deviceListNode = new Node(DeviceList.ELEM_NAME);
     440                        getDeviceNode().addNode(deviceListNode);
     441                }
     442                deviceListNode.addNode(d.getDeviceNode());
     443                d.setRootNode(null);
     444                if(getRootNode()==null){
     445                        Node root = new Node(RootDescription.ROOT_ELEMENT);
     446                        root.setNameSpace("",RootDescription.ROOT_ELEMENT_NAMESPACE);
     447                        Node spec = new Node(RootDescription.SPECVERSION_ELEMENT);
     448                        Node maj =new Node(RootDescription.MAJOR_ELEMENT);
     449                        maj.setValue("1");
     450                        Node min =new Node(RootDescription.MINOR_ELEMENT);
     451                        min.setValue("0");
     452                        spec.addNode(maj);
     453                        spec.addNode(min);
     454                        root.addNode(spec);             
     455                        setRootNode(root);
     456                }                       
     457        }       
     458       
    312459
    313460        ////////////////////////////////////////////////
     
    366513                return descriptionFile.getAbsoluteFile().getParent();
    367514        }
     515       
     516        /**
     517         * @since 1.8.0
     518         */
     519        public boolean loadDescription(InputStream input) throws InvalidDescriptionException
     520        {
     521                try {
     522                        Parser parser = UPnP.getXMLParser();
     523                        rootNode = parser.parse(input);
     524                        if (rootNode == null)
     525                                throw new InvalidDescriptionException(Description.NOROOT_EXCEPTION);
     526                        deviceNode = rootNode.getNode(Device.ELEM_NAME);
     527                        if (deviceNode == null)
     528                                throw new InvalidDescriptionException(Description.NOROOTDEVICE_EXCEPTION);
     529                }
     530                catch (ParserException e) {
     531                        throw new InvalidDescriptionException(e);
     532                }
     533               
     534                if (initializeLoadedDescription() == false)
     535                        return false;
     536
     537                setDescriptionFile(null);
     538                               
     539                return true;
     540        }       
    368541
    369542        public boolean loadDescription(String descString) throws InvalidDescriptionException
     
    439612        ////////////////////////////////////////////////
    440613
    441         public boolean isRootDevice()
    442         {
    443                 return (getRootNode() != null) ? true : false;
     614        public boolean isRootDevice(){
     615                return getRootNode().getNode("device").getNodeValue(UDN).equals(getUDN());
    444616        }
    445617       
     
    604776        ////////////////////////////////////////////////
    605777
    606         private final static String MANUFACTURE = "manufacture";
     778        private final static String MANUFACTURE = "manufacturer";
    607779       
    608780        public void setManufacture(String value)
     
    620792        ////////////////////////////////////////////////
    621793
    622         private final static String MANUFACTURE_URL = "manufactureURL";
     794        private final static String MANUFACTURE_URL = "manufacturerURL";
    623795       
    624796        public void setManufactureURL(String value)
     
    10671239        }
    10681240
     1241        public Icon getSmallestIcon()
     1242        {
     1243                Icon smallestIcon = null;               
     1244                IconList iconList = getIconList();
     1245                int iconCount = iconList.size();
     1246                for (int n=0; n < iconCount; n++) {
     1247                        Icon icon = iconList.getIcon(n);
     1248                        if (null == smallestIcon) {
     1249                                smallestIcon = icon;
     1250                                continue;
     1251                        }
     1252                        if (icon.getWidth() < smallestIcon.getWidth())
     1253                                smallestIcon = icon;                   
     1254                }
     1255               
     1256                return smallestIcon;
     1257        }
     1258       
    10691259        ////////////////////////////////////////////////
    10701260        //      Notify
     
    11041294                TimerUtil.waitRandom(DEFAULT_DISCOVERY_WAIT_TIME);
    11051295        }
    1106                
    11071296        public void announce(String bindAddr)
    11081297        {
     
    11241313                        ssdpReq.setUSN(devUSN);
    11251314                        ssdpSock.post(ssdpReq);
     1315                         
     1316                        String devUDN = getUDN();
     1317                        ssdpReq.setNT(devUDN);
     1318                        ssdpReq.setUSN(devUDN);
     1319                        ssdpSock.post(ssdpReq);                         
    11261320                }
    11271321               
     
    11511345        }
    11521346
    1153         public void announce()
    1154         {
     1347        public void announce(){
    11551348                notifyWait();
    1156                
    1157                 int nHostAddrs = HostInterface.getNHostAddresses();
    1158                 for (int n=0; n<nHostAddrs; n++) {
    1159                         String bindAddr = HostInterface.getHostAddress(n);
    1160                         if (bindAddr == null || bindAddr.length() <= 0)
     1349                InetAddress[] binds = getDeviceData().getHTTPBindAddress();
     1350                String[] bindAddresses;
     1351                if(binds!=null){                       
     1352                        bindAddresses = new String[binds.length];
     1353                        for (int i = 0; i < binds.length; i++) {
     1354                                bindAddresses[i] = binds[i].getHostAddress();
     1355                        }
     1356                }else{
     1357                        int nHostAddrs = HostInterface.getNHostAddresses();
     1358                        bindAddresses = new String[nHostAddrs];
     1359                        for (int n=0; n<nHostAddrs; n++) {
     1360                                bindAddresses[n] = HostInterface.getHostAddress(n);
     1361                        }
     1362                }               
     1363                for (int j = 0; j < bindAddresses.length; j++) {
     1364                        if(bindAddresses[j] == null || bindAddresses[j].length() == 0)
    11611365                                continue;
    11621366                        int ssdpCount = getSSDPAnnounceCount();
    11631367                        for (int i=0; i<ssdpCount; i++)
    1164                                 announce(bindAddr);
     1368                                announce(bindAddresses[j]);
     1369                       
    11651370                }
    11661371        }
     
    12071412        }
    12081413
    1209         public void byebye()
    1210         {
    1211                 int nHostAddrs = HostInterface.getNHostAddresses();
    1212                 for (int n=0; n<nHostAddrs; n++) {
    1213                         String bindAddr = HostInterface.getHostAddress(n);
    1214                         if (bindAddr == null || bindAddr.length() <= 0)
     1414        public void byebye(){
     1415
     1416                InetAddress[] binds = getDeviceData().getHTTPBindAddress();
     1417                String[] bindAddresses;
     1418                if(binds!=null){                       
     1419                        bindAddresses = new String[binds.length];
     1420                        for (int i = 0; i < binds.length; i++) {
     1421                                bindAddresses[i] = binds[i].getHostAddress();
     1422                        }
     1423                }else{
     1424                        int nHostAddrs = HostInterface.getNHostAddresses();
     1425                        bindAddresses = new String[nHostAddrs];
     1426                        for (int n=0; n<nHostAddrs; n++) {
     1427                                bindAddresses[n] = HostInterface.getHostAddress(n);
     1428                        }
     1429                }               
     1430               
     1431                for (int j = 0; j < bindAddresses.length; j++) {                       
     1432                        if (bindAddresses[j] == null || bindAddresses[j].length() <= 0)
    12151433                                continue;
    12161434                        int ssdpCount = getSSDPAnnounceCount();
    12171435                        for (int i=0; i<ssdpCount; i++)
    1218                                 byebye(bindAddr);
    1219                 }
     1436                                byebye(bindAddresses[j]);
     1437                }               
    12201438        }
    12211439
     
    12241442        ////////////////////////////////////////////////
    12251443
    1226         public boolean postSearchResponse(SSDPPacket ssdpPacket, String st, String usn)
     1444    private static Calendar cal = Calendar.getInstance();
     1445    public boolean postSearchResponse(SSDPPacket ssdpPacket, String st, String usn)
    12271446        {
    12281447                String localAddr = ssdpPacket.getLocalAddress();
     
    12321451                SSDPSearchResponse ssdpRes = new SSDPSearchResponse();
    12331452                ssdpRes.setLeaseTime(getLeaseTime());
    1234                 ssdpRes.setDate(Calendar.getInstance());
     1453                ssdpRes.setDate(cal);
    12351454                ssdpRes.setST(st);
    12361455                ssdpRes.setUSN(usn);
     
    13251544        }
    13261545
     1546        public void setHTTPBindAddress(InetAddress[] inets){
     1547                this.getDeviceData().setHTTPBindAddress(inets);
     1548        }
     1549       
     1550        public InetAddress[] getHTTPBindAddress(){
     1551                return this.getDeviceData().getHTTPBindAddress();
     1552        }       
     1553       
     1554        /**
     1555         *
     1556         * @return
     1557         * @since 1.8
     1558         */
     1559        public String getSSDPIPv4MulticastAddress(){
     1560                return this.getDeviceData().getMulticastIPv4Address();
     1561        }       
     1562       
     1563        /**
     1564         *
     1565         * @param ip
     1566         * @since 1.8
     1567         */
     1568        public void getSSDPIPv4MulticastAddress(String ip){
     1569                this.getDeviceData().setMulticastIPv4Address(ip);
     1570        }       
     1571       
     1572        /**
     1573         *
     1574         * @return
     1575         * @since 1.8
     1576         */
     1577        public String getSSDPIPv6MulticastAddress(){
     1578                return this.getDeviceData().getMulticastIPv6Address();
     1579        }       
     1580       
     1581        /**
     1582         *
     1583         * @param ip
     1584         * @since 1.8
     1585         */
     1586        public void getSSDPIPv6MulticastAddress(String ip){
     1587                this.getDeviceData().setMulticastIPv6Address(ip);
     1588        }       
     1589       
    13271590        public void httpRequestRecieved(HTTPRequest httpReq)
    13281591        {
     
    13301593                        httpReq.print();
    13311594       
    1332                 if (httpReq.isGetRequest() == true) {
     1595                if (httpReq.isGetRequest() == true || httpReq.isHeadRequest() == true) {
    13331596                        httpGetRequestRecieved(httpReq);
    13341597                        return;
     
    13781641                if (isDescriptionURI(uri) == true) {
    13791642                        String localAddr = httpReq.getLocalAddress();
     1643                        if ((localAddr == null) || (localAddr.length() <= 0))
     1644                                localAddr = HostInterface.getInterface();
    13801645                        fileByte = getDescriptionData(localAddr);
    13811646                }
     
    14521717                ctlReq.post(actRes);
    14531718        }
     1719
     1720   private void invalidArgumentsControlRecieved(ControlRequest ctlReq)
     1721    {
     1722        ControlResponse actRes = new ActionResponse();
     1723        actRes.setFaultResponse(UPnPStatus.INVALID_ARGS);
     1724        ctlReq.post(actRes);
     1725    }
    14541726
    14551727        private void deviceActionControlRecieved(ActionRequest ctlReq, Service service)
     
    14661738                ArgumentList actionArgList = action.getArgumentList();
    14671739                ArgumentList reqArgList = ctlReq.getArgumentList();
    1468                 actionArgList.set(reqArgList);
     1740        try {
     1741            actionArgList.setReqArgs(reqArgList);
     1742        } catch (IllegalArgumentException ex){
     1743            invalidArgumentsControlRecieved(ctlReq);
     1744            return;
     1745       }
    14691746                if (action.performActionListener(ctlReq) == false)
    14701747                        invalidActionControlRecieved(ctlReq);
     
    16161893                return getDeviceData().getHTTPServerList();
    16171894        }
     1895        /**
     1896         *
     1897         * @param port The port to use for binding the SSDP service
     1898         */
     1899        public void setSSDPPort(int port){
     1900                this.getDeviceData().setSSDPPort(port);
     1901        }
     1902
     1903        /**
     1904         *
     1905         * @return The port to use for binding the SSDP service
     1906         */
     1907        public int getSSDPPort(){
     1908                return this.getDeviceData().getSSDPPort();
     1909        }
     1910       
     1911       
     1912
     1913        /**
     1914         *
     1915         * @param inets The IP that will be used for binding the SSDP service.
     1916         *              Use <code>null</code> to get the default beahvior
     1917         */
     1918        public void setSSDPBindAddress(InetAddress[] inets){
     1919                this.getDeviceData().setSSDPBindAddress(inets);
     1920        }
     1921               
     1922       
     1923        /**
     1924         *
     1925         * @return inets The IP that will be used for binding the SSDP service.
     1926         *              null means the default setted by the class UPnP
     1927         */
     1928        public InetAddress[] getSSDPBindAddress(){
     1929                return this.getDeviceData().getSSDPBindAddress();
     1930        }       
     1931       
     1932        /**
     1933         *
     1934         * @param ip The IPv4 address used for Multicast comunication
     1935         */
     1936        public void setMulticastIPv4Address(String ip){
     1937                this.getDeviceData().setMulticastIPv4Address(ip);
     1938        }
     1939
     1940        /**
     1941         *
     1942         * @return The IPv4 address used for Multicast comunication
     1943         */
     1944        public String getMulticastIPv4Address(){
     1945                return this.getDeviceData().getMulticastIPv4Address();
     1946        }
     1947       
     1948        /**
     1949         *
     1950         * @param ip The IPv address used for Multicast comunication
     1951         */
     1952        public void setMulticastIPv6Address(String ip){
     1953                this.getDeviceData().setMulticastIPv6Address(ip);
     1954        }
     1955
     1956        /**
     1957         *
     1958         * @return The IPv address used for Multicast comunication
     1959         */
     1960        public String getMulticastIPv6Address(){
     1961                return this.getDeviceData().getMulticastIPv6Address();
     1962        }
     1963       
    16181964
    16191965        private SSDPSearchSocketList getSSDPSearchSocketList()
     
    17092055        }
    17102056
     2057        public boolean isRunning()
     2058        {
     2059                return (getAdvertiser() != null) ? true : false;
     2060        }
     2061
    17112062        ////////////////////////////////////////////////
    17122063        // Interface Address
     
    17762127                }
    17772128        }
     2129
     2130        ////////////////////////////////////////////////
     2131        //      userData
     2132        ////////////////////////////////////////////////
     2133
     2134        private Object userData = null;
     2135       
     2136        public void setUserData(Object data)
     2137        {
     2138                userData = data;
     2139        }
     2140
     2141        public Object getUserData()
     2142        {
     2143                return userData;
     2144        }
    17782145       
    17792146        ////////////////////////////////////////////////
  • router/java/src/org/cybergarage/upnp/DeviceList.java

    rb033db96 r21466e0  
    1616package org.cybergarage.upnp;
    1717
    18 import java.util.*;
     18import java.util.Vector;
    1919
    2020public class DeviceList extends Vector
     
    2424        ////////////////////////////////////////////////
    2525       
    26         private static final long serialVersionUID = 3773784061607435126L;
    2726        public final static String ELEM_NAME = "deviceList";
    2827
  • router/java/src/org/cybergarage/upnp/Icon.java

    rb033db96 r21466e0  
    1111*       11/28/02
    1212*               - first revision.
     13*       04/12/06
     14*               - Added setUserData() and getUserData() to set a user original data object.
    1315*       
    1416******************************************************************/
     
    1618package org.cybergarage.upnp;
    1719
    18 import org.cybergarage.xml.*;
     20import org.cybergarage.xml.Node;
    1921
    2022public class Icon
     
    8284        }
    8385
    84         public String getWidth()
     86        public void setWidth(int value)
    8587        {
    86                 return getIconNode().getNodeValue(WIDTH);
     88                try {
     89                        setWidth(Integer.toString(value));
     90                }
     91                catch (Exception e) {};
     92        }
     93       
     94        public int getWidth()
     95        {
     96                try {
     97                        return Integer.parseInt(getIconNode().getNodeValue(WIDTH));
     98                }
     99                catch (Exception e) {};
     100                return 0;
    87101        }
    88102
     
    98112        }
    99113
    100         public String getHeight()
     114        public void setHeight(int value)
    101115        {
    102                 return getIconNode().getNodeValue(HEIGHT);
     116                try {
     117                        setHeight(Integer.toString(value));
     118                }
     119                catch (Exception e) {};
     120        }
     121       
     122        public int getHeight()
     123        {
     124                try {
     125                        return Integer.parseInt(getIconNode().getNodeValue(HEIGHT));
     126                }
     127                catch (Exception e) {};
     128                return 0;
    103129        }
    104130
     
    134160                return getIconNode().getNodeValue(URL);
    135161        }
     162       
     163        ////////////////////////////////////////////////
     164        //      userData
     165        ////////////////////////////////////////////////
     166
     167        private Object userData = null;
     168       
     169        public void setUserData(Object data)
     170        {
     171                userData = data;
     172        }
     173
     174        public Object getUserData()
     175        {
     176                return userData;
     177        }
    136178}
  • router/java/src/org/cybergarage/upnp/IconList.java

    rb033db96 r21466e0  
    1616package org.cybergarage.upnp;
    1717
    18 import java.util.*;
     18import java.util.Vector;
    1919
    2020public class IconList extends Vector
     
    2424        ////////////////////////////////////////////////
    2525       
    26         private static final long serialVersionUID = -1097238335037012991L;
    2726        public final static String ELEM_NAME = "iconList";
    2827
  • router/java/src/org/cybergarage/upnp/Service.java

    rb033db96 r21466e0  
    6161*               - Thanks for Mikael Hakman <mhakman@dkab.net>
    6262*               - Changed getSCPDData() to add a XML declaration at first line.
     63*       06/21/05
     64*               - Changed notify() to continue when the subscriber is null.
     65*       04/12/06
     66*               - Added setUserData() and getUserData() to set a user original data object.
     67*       09/18/2010 Robin V. <robinsp@gmail.com>
     68*               - Fixed getSCPDNode() not to occur recursive http get requests.
    6369*
    6470******************************************************************/
     
    6672package org.cybergarage.upnp;
    6773
    68 import java.io.*;
    69 import java.net.*;
    70 
    71 import org.cybergarage.http.*;
    72 import org.cybergarage.xml.*;
    73 import org.cybergarage.util.*;
    74 
    75 import org.cybergarage.upnp.ssdp.*;
    76 import org.cybergarage.upnp.xml.*;
    77 import org.cybergarage.upnp.device.*;
    78 import org.cybergarage.upnp.control.*;
    79 import org.cybergarage.upnp.event.*;
     74import java.io.File;
     75import java.io.InputStream;
     76import java.net.URL;
     77import java.util.Iterator;
     78
     79import org.cybergarage.http.HTTP;
     80import org.cybergarage.http.HTTPResponse;
     81import org.cybergarage.upnp.control.ActionListener;
     82import org.cybergarage.upnp.control.QueryListener;
     83import org.cybergarage.upnp.device.InvalidDescriptionException;
     84import org.cybergarage.upnp.device.NTS;
     85import org.cybergarage.upnp.device.ST;
     86import org.cybergarage.upnp.event.NotifyRequest;
     87import org.cybergarage.upnp.event.Subscriber;
     88import org.cybergarage.upnp.event.SubscriberList;
     89import org.cybergarage.upnp.ssdp.SSDPNotifyRequest;
     90import org.cybergarage.upnp.ssdp.SSDPNotifySocket;
     91import org.cybergarage.upnp.ssdp.SSDPPacket;
     92import org.cybergarage.upnp.xml.ServiceData;
     93import org.cybergarage.util.Debug;
     94import org.cybergarage.util.Mutex;
     95import org.cybergarage.util.StringUtil;
     96import org.cybergarage.xml.Node;
     97import org.cybergarage.xml.Parser;
     98import org.cybergarage.xml.ParserException;
    8099
    81100public class Service
     
    101120        //      Constructor
    102121        ////////////////////////////////////////////////
     122        public static final String SCPD_ROOTNODE="scpd";
     123        public static final String SCPD_ROOTNODE_NS="urn:schemas-upnp-org:service-1-0";
     124       
     125        public static final String SPEC_VERSION="specVersion";
     126        public static final String MAJOR="major";
     127        public static final String MAJOR_VALUE="1";
     128        public static final String MINOR="minor";
     129        public static final String MINOR_VALUE="0";
     130       
     131        public Service(){
     132                this(new Node(ELEM_NAME));
     133               
     134                Node sp = new Node(SPEC_VERSION);
     135               
     136                Node M =new Node(MAJOR);
     137                M.setValue(MAJOR_VALUE);
     138                sp.addNode(M);
     139                               
     140                Node m =new Node(MINOR);
     141                m.setValue(MINOR_VALUE);
     142                sp.addNode(m);
     143               
     144                //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)
     147                scpd.addNode(sp);
     148                getServiceData().setSCPDNode(scpd);
     149        }
    103150
    104151        public Service(Node node)
     
    307354                return true;
    308355        }
     356
     357        /**
     358         * @since 1.8.0
     359         */
     360        public boolean loadSCPD(InputStream input) throws ParserException
     361        {
     362                Parser parser = UPnP.getXMLParser();
     363                Node scpdNode = parser.parse(input);
     364                if (scpdNode == null)
     365                        return false;
     366                ServiceData data = getServiceData();
     367                data.setSCPDNode(scpdNode);
     368                return true;
     369        }
     370       
     371       
     372    public void setDescriptionURL(String value)
     373    {
     374            getServiceData().setDescriptionURL(value);
     375    }
     376
     377    public String getDescriptionURL()
     378    {
     379            return getServiceData().getDescriptionURL();
     380    }
     381       
    309382       
    310383        private Node getSCPDNode(URL scpdUrl) throws ParserException
     
    327400                        return scpdNode;
    328401               
     402                // Thanks for Jaap (Sep 18, 2010)
     403                Device rootDev = getRootDevice();
     404                if (rootDev == null)
     405                        return null;
     406               
    329407                String scpdURLStr = getSCPDURL();
    330                 try {
    331                         URL scpdUrl = new URL(scpdURLStr);
    332                         scpdNode = getSCPDNode(scpdUrl);
    333                 }
    334                 catch (Exception e1) {
    335                         Device rootDev = getRootDevice();
    336                         String urlBaseStr = rootDev.getURLBase();
    337                         // Thanks for Steven Yen (2003/09/03)
    338                         if (urlBaseStr == null || urlBaseStr.length() <= 0) {
    339                                 String location = rootDev.getLocation();
    340                                 String locationHost = HTTP.getHost(location);
    341                                 int locationPort = HTTP.getPort(location);
    342                                 urlBaseStr = HTTP.getRequestHostURL(locationHost, locationPort);
    343                         }
    344                         scpdURLStr = HTTP.toRelativeURL(scpdURLStr);
    345                         String newScpdURLStr = urlBaseStr + scpdURLStr;
    346                         try {
    347                                 URL newScpdURL = new URL(newScpdURLStr);
    348                                 scpdNode = getSCPDNode(newScpdURL);
    349                         }
    350                         catch (Exception e2) {
    351                                 newScpdURLStr = HTTP.getAbsoluteURL(urlBaseStr, scpdURLStr);
     408
     409                // Thanks for Robin V. (Sep 18, 2010)
     410                String rootDevPath = rootDev.getDescriptionFilePath();
     411                if(rootDevPath!=null) {
     412                        File f;
     413                        f = new File(rootDevPath.concat(scpdURLStr));
     414               
     415                        if(f.exists()) {
    352416                                try {
    353                                         URL newScpdURL = new URL(newScpdURLStr);
    354                                         scpdNode = getSCPDNode(newScpdURL);
     417                                        scpdNode = getSCPDNode(f);
     418                                } catch (ParserException e) {
     419                                        // TODO Auto-generated catch block
     420                                        e.printStackTrace();
    355421                                }
    356                                 catch (Exception e3) {
    357                                         newScpdURLStr = rootDev.getDescriptionFilePath() + scpdURLStr;
    358                                         try {
    359                                                 scpdNode = getSCPDNode(new File(newScpdURLStr));
    360                                         }
    361                                         catch (Exception e4) {
    362                                                 Debug.warning(e4);
    363                                         }
     422                                if(scpdNode!=null) {
     423                                        data.setSCPDNode(scpdNode);
     424                                        return scpdNode;
    364425                                }
    365426                        }
    366427                }
    367428
    368                 data.setSCPDNode(scpdNode);
    369                
    370                 return scpdNode;
     429                try {
     430                        URL scpdUrl = new URL(rootDev.getAbsoluteURL(scpdURLStr));
     431                        scpdNode = getSCPDNode(scpdUrl);               
     432                        if (scpdNode != null) {
     433                                data.setSCPDNode(scpdNode);
     434                                return scpdNode;
     435                        }
     436                }
     437                catch (Exception e) {}
     438               
     439                String newScpdURLStr = rootDev.getDescriptionFilePath() + HTTP.toRelativeURL(scpdURLStr);
     440                try {
     441                        scpdNode = getSCPDNode(new File(newScpdURLStr));
     442                        return scpdNode;
     443                }
     444                catch (Exception e) {
     445                        Debug.warning(e);
     446                }
     447               
     448                return null;
    371449        }
    372450
     
    397475                if (actionListNode == null)
    398476                        return actionList;
    399                 Node serviceNode = getServiceNode();
    400477                int nNode = actionListNode.getNNodes();
    401478                for (int n=0; n<nNode; n++) {
     
    422499                }
    423500                return null;
     501        }
     502       
     503        public void addAction(Action a){
     504                Iterator i = a.getArgumentList().iterator();
     505                while (i.hasNext()) {
     506                        Argument arg = (Argument) i.next();
     507                        arg.setService(this);
     508                }
     509
     510                Node scdpNode = getSCPDNode();
     511                Node actionListNode = scdpNode.getNode(ActionList.ELEM_NAME);
     512                if (actionListNode == null){                   
     513                        actionListNode = new Node(ActionList.ELEM_NAME);
     514                        scdpNode.addNode(actionListNode);
     515                }
     516                actionListNode.addNode(a.getActionNode());
    424517        }
    425518       
     
    658751                for (int n=0; n<subListCnt; n++) {
    659752                        Subscriber sub = subs[n];
     753                        if (sub == null)
     754                                continue;
    660755                        if (sub.isExpired() == true)
    661756                                removeSubscriber(sub);
     
    669764                for (int n=0; n<subListCnt; n++) {
    670765                        Subscriber sub = subs[n];
     766                        if (sub == null)
     767                                continue;
    671768                        if (notify(sub, stateVar) == false) {
    672769                                /* Don't remove for NMPR specification.
     
    745842                }
    746843        }
     844
     845        /**
     846         * Add the StateVariable to the service.<br>
     847         * <br>
     848         * Note: This method should be used to create a dynamic<br>
     849         * Device withtout writing any XML that describe the device<br>.
     850         * <br>
     851         * Note: that no control for duplicate StateVariable is done.
     852         *
     853         * @param var StateVariable that will be added
     854         *
     855         * @author Stefano "Kismet" Lenzi - kismet-sl@users.sourceforge.net  - 2005
     856         */
     857        public void addStateVariable(StateVariable var) {
     858                //TODO Some test are done not stable
     859                Node stateTableNode = getSCPDNode().getNode(ServiceStateTable.ELEM_NAME);
     860                if (stateTableNode == null){
     861                        stateTableNode = new Node(ServiceStateTable.ELEM_NAME);
     862                        /*
     863                         * Force the node <serviceStateTable> to be the first node inside <scpd>
     864                         */
     865                        //getSCPDNode().insertNode(stateTableNode,0);
     866                        getSCPDNode().addNode(stateTableNode);         
     867                }
     868                var.setServiceNode(getServiceNode());
     869                stateTableNode.addNode(var.getStateVariableNode());
     870        }
     871
     872        ////////////////////////////////////////////////
     873        //      userData
     874        ////////////////////////////////////////////////
     875
     876        private Object userData = null;
     877       
     878        public void setUserData(Object data)
     879        {
     880                userData = data;
     881        }
     882
     883        public Object getUserData()
     884        {
     885                return userData;
     886        }
    747887}
  • router/java/src/org/cybergarage/upnp/ServiceList.java

    rb033db96 r21466e0  
    1818package org.cybergarage.upnp;
    1919
    20 import java.util.*;
     20import java.util.Vector;
    2121
    2222public class ServiceList extends Vector
     
    2626        ////////////////////////////////////////////////
    2727       
    28         private static final long serialVersionUID = 6372904993975135597L;
    2928        public final static String ELEM_NAME = "serviceList";
    3029
  • router/java/src/org/cybergarage/upnp/ServiceStateTable.java

    rb033db96 r21466e0  
    1616package org.cybergarage.upnp;
    1717
    18 import java.util.*;
     18import java.util.Vector;
    1919
    2020public class ServiceStateTable extends Vector
     
    2424        ////////////////////////////////////////////////
    2525       
    26         private static final long serialVersionUID = 7626909231678469365L;
    2726        public final static String ELEM_NAME = "serviceStateTable";
    2827
  • router/java/src/org/cybergarage/upnp/StateVariable.java

    rb033db96 r21466e0  
    4040*       02/28/05
    4141*               - Changed getAllowedValueList() to use AllowedValue instead of String as the member.
     42*       04/12/06
     43*               - Added setUserData() and getUserData() to set a user original data object.
    4244*       
    4345******************************************************************/
    4446
    4547package org.cybergarage.upnp;
    46 
    47 import org.cybergarage.xml.*;
    48 import org.cybergarage.util.*;
    49 
    50 import org.cybergarage.upnp.control.*;
    51 import org.cybergarage.upnp.xml.*;
     48import java.util.Iterator;
     49
     50import org.cybergarage.upnp.control.QueryListener;
     51import org.cybergarage.upnp.control.QueryRequest;
     52import org.cybergarage.upnp.control.QueryResponse;
     53import org.cybergarage.upnp.xml.NodeData;
     54import org.cybergarage.upnp.xml.StateVariableData;
     55import org.cybergarage.util.Debug;
     56import org.cybergarage.xml.Node;
    5257
    5358public class StateVariable extends NodeData
     
    6974        {
    7075                return serviceNode;
     76        }
     77       
     78        void setServiceNode(Node n){
     79                serviceNode=n;
    7180        }
    7281
     
    91100        {
    92101                this.serviceNode = null;
    93                 this.stateVariableNode = new Node();
     102                this.stateVariableNode = new Node(ELEM_NAME);
    94103        }
    95104       
     
    239248                Node valueListNode = getStateVariableNode().getNode(AllowedValueList.ELEM_NAME);
    240249                if (valueListNode == null)
    241                         return valueList;
     250                        return null;
    242251                int nNode = valueListNode.getNNodes();
    243252                for (int n=0; n<nNode; n++) {
     
    251260        }
    252261
     262        /**
     263         * This method ovverride the value of the AllowedValueList Node<br>
     264         * of this object. <br>
     265         * <br>
     266         * Note: This method should be used to create a dynamic<br>
     267         * Device withtout writing any XML that describe the device<br>.
     268         * <br>
     269         * Note2: The enforce the constraint of the SCPD rule the<br>
     270         * AllowedValueList and AllowedValueRange are mutal exclusive<br>
     271         * the last set will be the only present<br>
     272         *
     273         * @param avl The new AllowedValueList
     274         *
     275         * @author Stefano "Kismet" Lenzi - kismet-sl@users.sourceforge.net  - 2005
     276         */
     277        public void setAllowedValueList(AllowedValueList avl) {
     278                //TODO Some test done not stable       
     279                getStateVariableNode().removeNode(AllowedValueList.ELEM_NAME);
     280                getStateVariableNode().removeNode(AllowedValueRange.ELEM_NAME);
     281                Node n = new Node(AllowedValueList.ELEM_NAME);
     282                Iterator i=avl.iterator();
     283                while (i.hasNext()) {
     284                        AllowedValue av = (AllowedValue) i.next();
     285                        //n.addNode(new Node(AllowedValue.ELEM_NAME,av.getValue())); wrong!
     286                        n.addNode(av.getAllowedValueNode());                                            //better (twa)
     287                }
     288                getStateVariableNode().addNode(n);             
     289               
     290        }
     291
     292       
    253293        public boolean hasAllowedValueList()
    254294        {
    255295                AllowedValueList valueList = getAllowedValueList();
    256                 return (0 < valueList.size()) ? true : false;
     296                return (valueList != null) ? true : false;
    257297        }
    258298       
     
    267307                        return null;
    268308                return new AllowedValueRange(valueRangeNode);
     309        }
     310       
     311        /**
     312         * This method ovverride the value of the AllowedValueRange Node<br>
     313         * of this object. <br>
     314         * <br>
     315         * Note: This method should be used to create a dynamic<br>
     316         * Device withtout writing any XML that describe the device<br>.
     317         * <br>
     318         * Note2: The enforce the constraint of the SCPD rule the<br>
     319         * AllowedValueList and AllowedValueRange are mutal exclusive<br>
     320         * the last set will be the only present<br>
     321         *
     322         * @param avr The new AllowedValueRange
     323         *
     324         * @author Stefano "Kismet" Lenzi - kismet-sl@users.sourceforge.net  - 2005
     325         */     
     326        public void setAllowedValueRange(AllowedValueRange avr){
     327                //TODO Some test done not stable
     328                getStateVariableNode().removeNode(AllowedValueList.ELEM_NAME);
     329                getStateVariableNode().removeNode(AllowedValueRange.ELEM_NAME);
     330                getStateVariableNode().addNode(avr.getAllowedValueRangeNode());
     331               
    269332        }
    270333
     
    372435                return upnpStatus;
    373436        }
     437
     438        private static final String DEFAULT_VALUE = "defaultValue";
     439        ////////////////////////////////////////////////
     440        /**
     441         * Get the value of DefaultValue of this StateVariable
     442         *
     443         * @author Stefano Lenzi kismet-sl@users.sourceforge.net
     444         */
     445        public String getDefaultValue() {
     446                return getStateVariableNode().getNodeValue(DEFAULT_VALUE);
     447        }
     448
     449        /**
     450         * This method ovverride the value of the DefaultValue of this object. <br>
     451         * <br>
     452         * Note: This method should be used to create a dynamic<br>
     453         * Device withtout writing any XML that describe the device<br>.
     454         *
     455         * @param value The new String value
     456         *
     457         * @author Stefano Lenzi kismet-sl@users.sourceforge.net
     458         */     
     459        public void setDefaultValue(String value){
     460                getStateVariableNode().setNode(DEFAULT_VALUE,value);
     461        }
     462        ////////////////////////////////////////////////
     463        //      userData
     464        ////////////////////////////////////////////////
     465
     466        private Object userData = null;
     467       
     468        public void setUserData(Object data)
     469        {
     470                userData = data;
     471        }
     472
     473        public Object getUserData()
     474        {
     475                return userData;
     476        }
    374477}
  • router/java/src/org/cybergarage/upnp/UPnP.java

    rb033db96 r21466e0  
    1717*       06/18/03
    1818*               - Added INMPR03 and INMPR03_VERSION.
     19*       04/14/06
     20*               - Added some functios about time-to-live, and the default value is 4.
     21*       05/11/09
     22*               - Changed loadDefaultXMLParser() to load org.cybergarage.xml.parser.XmlPullParser at first.
    1923*       
    2024******************************************************************/
     
    2226package org.cybergarage.upnp;
    2327
    24 import org.cybergarage.upnp.ssdp.*;
    25 //import org.cybergarage.util.*;
    26 import org.cybergarage.xml.*;
    27 import org.cybergarage.xml.parser.*;
    28 import org.cybergarage.soap.*;
    29 import org.cybergarage.net.*;
     28import org.cybergarage.net.HostInterface;
     29import org.cybergarage.soap.SOAP;
     30import org.cybergarage.upnp.ssdp.SSDP;
     31import org.cybergarage.util.Debug;
     32import org.cybergarage.xml.Parser;
    3033
    3134public class UPnP
     
    3538        ////////////////////////////////////////////////
    3639       
    37         public final static String NAME = "CyberLink";
    38         public final static String VERSION = "1.7";
     40        /**
     41         * Name of the system properties used to identifies the default XML Parser.<br>
     42         * The value of the properties MUST BE the fully qualified class name of<br>
     43         * XML Parser which CyberLink should use.
     44         */
     45        public final static String XML_CLASS_PROPERTTY="cyberlink.upnp.xml.parser";
     46       
     47        public final static String NAME = "CyberLinkJava";
     48        public final static String VERSION = "1.8";
    3949
    4050        // I2P was 100
     
    5363        public final static int INMPR03_DISCOVERY_OVER_WIRELESS_COUNT = 4;
    5464
    55         public final static String XML_DECLARATION = "<?xml version=\"1.0\"?>";
     65        public final static String XML_DECLARATION = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
    5666       
    5767        ////////////////////////////////////////////////
     
    195205        public final static Parser getXMLParser()
    196206        {
     207                if(xmlParser == null){
     208                        xmlParser = loadDefaultXMLParser();
     209                        if(xmlParser == null)
     210                                throw new RuntimeException("No XML parser defined. And unable to laod any. \n" +
     211                                                "Try to invoke UPnP.setXMLParser before UPnP.getXMLParser");                   
     212                        SOAP.setXMLParser(xmlParser);
     213                }
    197214                return xmlParser;
    198215        }
     216
     217        /**
     218         * This method loads the default XML Parser using the following behavior:
     219         *  - First if present loads the parsers specified by the system property {@link UPnP#XML_CLASS_PROPERTTY}<br>
     220         *  - Second by a fall-back technique, it tries to load the XMLParser from one<br>
     221         *  of the following classes: {@link JaxpParser}, {@link kXML2Parser}, {@link XercesParser}
     222         *
     223         * @return {@link Parser} which has been loaded successuflly or null otherwise
     224         *
     225         * @since 1.8.0
     226         */
     227        private static Parser loadDefaultXMLParser() {
     228                Parser parser = null;
     229               
     230                String[] parserClass = new String[]{
     231                                System.getProperty(XML_CLASS_PROPERTTY),
     232                                "org.cybergarage.xml.parser.XmlPullParser",
     233                                "org.cybergarage.xml.parser.JaxpParser",
     234                                "org.cybergarage.xml.parser.kXML2Parser",
     235                                "org.cybergarage.xml.parser.XercesParser"
     236                };
     237               
     238                for (int i = 0; i < parserClass.length; i++) {
     239                        if(parserClass[i]==null)
     240                                continue;
     241                        try {
     242                                parser = (Parser) Class.forName(parserClass[i]).newInstance();
     243                                return parser;
     244                        } catch (Throwable e) {
     245                                Debug.warning("Unable to load "+parserClass[i]+" as XMLParser due to "+e);
     246                        }
     247                }
     248                return null;
     249        }
     250       
     251        ////////////////////////////////////////////////
     252        //      TTL
     253        ////////////////////////////////////////////////       
     254
     255        public final static int DEFAULT_TTL = 4;
     256
     257        private static int timeToLive = DEFAULT_TTL;
     258       
     259        public final static void setTimeToLive(int value)
     260        {
     261                timeToLive = value;
     262        }
     263       
     264        public final static int getTimeToLive()
     265        {
     266                return timeToLive;
     267        }
    199268       
    200269        ////////////////////////////////////////////////
     
    208277                ////////////////////////////
    209278               
    210                 setXMLParser(new JaxpParser());
    211279                //setXMLParser(new kXML2Parser());
    212280               
    213                 ////////////////////////////
    214                 // Interface Option
    215                 ////////////////////////////
    216                 /*
    217                 if (HostInterface.hasIPv6Addresses() == true)
    218                         setEnable(USE_ONLY_IPV6_ADDR);
    219                 */
     281               
     282                ////////////////////////////
     283                // TimeToLive
     284                ////////////////////////////
     285               
     286                setTimeToLive(DEFAULT_TTL);
    220287               
    221288                ////////////////////////////
  • router/java/src/org/cybergarage/upnp/UPnPStatus.java

    rb033db96 r21466e0  
    1717
    1818package org.cybergarage.upnp;
     19import org.cybergarage.http.HTTPStatus;
    1920
    2021public class UPnPStatus
     
    4041                case PRECONDITION_FAILED: return "Precondition Failed";
    4142                case ACTION_FAILED: return "Action Failed";
     43                default: return HTTPStatus.code2String(code);
    4244                }
    43                 return "";
    4445        }
    4546       
  • router/java/src/org/cybergarage/upnp/control/ControlResponse.java

    rb033db96 r21466e0  
    103103        }
    104104       
     105        private Node createFaultResponseNode(int errCode)
     106        {
     107                return createFaultResponseNode(errCode, UPnPStatus.code2String(errCode));
     108        }
     109
    105110        ////////////////////////////////////////////////
    106111        //      UPnP Error
  • router/java/src/org/cybergarage/upnp/control/QueryRequest.java

    rb033db96 r21466e0  
    7575                Service service = stateVar.getService();               
    7676               
     77                String ctrlURL = service.getControlURL();
     78
    7779                setRequestHost(service);
    7880
  • router/java/src/org/cybergarage/upnp/device/InvalidDescriptionException.java

    rb033db96 r21466e0  
    2020public class InvalidDescriptionException extends Exception
    2121{
    22         private static final long serialVersionUID = -3144583349586910509L;
    23 
    2422        public InvalidDescriptionException()
    2523        {
  • router/java/src/org/cybergarage/upnp/event/NotifyRequest.java

    rb033db96 r21466e0  
    116116        public boolean setRequest(Subscriber sub, String varName, String value)
    117117        {
     118                String callback = sub.getDeliveryURL();
    118119                String sid = sub.getSID();
    119120                long notifyCnt = sub.getNotifyCount();
     
    155156        }
    156157       
     158        private Node getVariableNode()
     159        {
     160                Node rootNode = getEnvelopeNode();
     161                if (rootNode == null)
     162                        return null;
     163                if (rootNode.hasNodes() == false)
     164                        return null;
     165                Node propNode = rootNode.getNode(0);
     166                if (propNode.hasNodes() == false)
     167                        return null;
     168                return propNode.getNode(0);
     169        }
     170
    157171        // Thanks for Giordano Sassaroli <sassarol@cefriel.it> (09/08/03)
    158172        private Property getProperty(Node varNode)
  • router/java/src/org/cybergarage/upnp/event/PropertyList.java

    rb033db96 r21466e0  
    2424        ////////////////////////////////////////////////
    2525       
    26         private static final long serialVersionUID = 8718064210738306226L;
    2726        public final static String ELEM_NAME = "PropertyList";
    2827
  • router/java/src/org/cybergarage/upnp/event/SubscriberList.java

    rb033db96 r21466e0  
    2626        ////////////////////////////////////////////////
    2727       
    28         private static final long serialVersionUID = -648427977601494972L;
    29 
    3028        public SubscriberList()
    3129        {
  • router/java/src/org/cybergarage/upnp/event/Subscription.java

    rb033db96 r21466e0  
    6969                if (headerValue == null)
    7070                        return "";
     71                if (headerValue.startsWith(Subscription.UUID) == false)
     72                        return headerValue;
    7173                return headerValue.substring(Subscription.UUID.length(), headerValue.length());
    7274        }
  • router/java/src/org/cybergarage/upnp/event/SubscriptionRequest.java

    rb033db96 r21466e0  
    4444        ////////////////////////////////////////////////
    4545
    46         public SubscriptionRequest()
    47         {
    48         }
    49 
    50         public SubscriptionRequest(HTTPRequest httpReq)
    51         {
     46        public SubscriptionRequest(){
     47                setContentLength(0);
     48        }
     49
     50        public SubscriptionRequest(HTTPRequest httpReq){
     51                this();
    5252                set(httpReq);
    5353        }
  • router/java/src/org/cybergarage/upnp/ssdp/HTTPMUSocket.java

    rb033db96 r21466e0  
    2020*               - Theo Beisch <theo.beisch@gmx.de>
    2121*               - Changed send() to set the TTL as 4.
     22*       08/23/07
     23*               - Thanks for Kazuyuki Shudo
     24*               - Changed receive() to throw IOException.
     25*       01/10/08
     26*               - Changed getLocalAddress() to return a brank string when the ssdpMultiGroup or ssdpMultiIf is null on Android m3-rc37a.
    2227*       
    2328******************************************************************/
     
    2530package org.cybergarage.upnp.ssdp;
    2631
    27 import java.net.*;
    28 import java.util.*;
    29 
    30 import org.cybergarage.http.*;
    31 import org.cybergarage.util.*;
     32import java.net.DatagramPacket;
     33import java.net.MulticastSocket;
     34import java.net.Inet4Address;
     35import java.net.Inet6Address;
     36import java.net.InetAddress;
     37import java.net.InetSocketAddress;
     38import java.net.NetworkInterface;
     39import java.util.Enumeration;
     40import java.io.IOException;
     41
     42import org.cybergarage.http.HTTPRequest;
     43import org.cybergarage.upnp.UPnP;
     44import org.cybergarage.util.Debug;
     45
     46// Dummy Class for Android m3-rc37a
     47// import org.cybergarage.android.MulticastSocket;
    3248
    3349public class HTTPMUSocket
     
    4056        private MulticastSocket ssdpMultiSock = null;
    4157        private NetworkInterface ssdpMultiIf = null;
    42                        
     58       
    4359        ////////////////////////////////////////////////
    4460        //      Constructor
     
    6581        public String getLocalAddress()
    6682        {
     83                if (ssdpMultiGroup == null || ssdpMultiIf == null)
     84                        return "";
    6785                InetAddress mcastAddr = ssdpMultiGroup.getAddress();
    6886                Enumeration addrs = ssdpMultiIf.getInetAddresses();
     
    7795        }
    7896
     97        /**
     98         *
     99         * @return the destination port for multicast packet
     100         * @since 1.8
     101         */
     102        public int getMulticastPort(){
     103                return ssdpMultiGroup.getPort();
     104        }
     105       
     106        /**
     107         *
     108         * @return the source port for multicast packet
     109         * @since 1.8
     110         */
     111        public int getLocalPort(){
     112                return ssdpMultiSock.getLocalPort();
     113        }
     114       
     115        /**
     116         *
     117         * @return the opened {@link MulticastSocket}
     118         * @since 1.8
     119         */
     120        public MulticastSocket getSocket(){
     121                return ssdpMultiSock;
     122        }
     123       
     124       
    79125        ////////////////////////////////////////////////
    80126        //      MulticastAddr
     
    91137        }
    92138       
    93         ////////////////////////////////////////////////
    94         //      open/close
    95         ////////////////////////////////////////////////
    96 
    97         public boolean open(String addr, int port, String bindAddr)
    98         {
     139        /**
     140         * @param addr {@link String} rappresenting the multicast hostname to join into.
     141         * @param port int rappresenting the port to be use poth as source and destination
     142         * @param bindAddr {@link InetAddress} which identify the hostname of the interface
     143         *              to use for sending and recieving multicast packet
     144         */
     145        public boolean open(String addr,int port, InetAddress bindAddr){
    99146                try {
    100147                        ssdpMultiSock = new MulticastSocket(null);
     
    103150                        ssdpMultiSock.bind(bindSockAddr);
    104151                        ssdpMultiGroup = new InetSocketAddress(InetAddress.getByName(addr), port);
    105                         ssdpMultiIf = NetworkInterface.getByInetAddress(InetAddress.getByName(bindAddr));
     152                        ssdpMultiIf = NetworkInterface.getByInetAddress(bindAddr);
    106153                        ssdpMultiSock.joinGroup(ssdpMultiGroup, ssdpMultiIf);
    107154                }
     
    111158                }
    112159               
    113                 return true;
     160                return true;           
     161        }
     162       
     163        public boolean open(String addr, int port, String bindAddr)
     164        {
     165                try {
     166                        return open(addr,port,InetAddress.getByName(bindAddr));
     167                }catch (Exception e) {
     168                        Debug.warning(e);
     169                        return false;
     170                }
    114171        }
    115172
     
    121178                try {
    122179                        ssdpMultiSock.leaveGroup(ssdpMultiGroup, ssdpMultiIf);
     180            ssdpMultiSock.close();
    123181                        ssdpMultiSock = null;
    124182                }
     
    142200                                msock = new MulticastSocket(null);
    143201                                msock.bind(new InetSocketAddress(bindAddr, bindPort));
     202                        }else{
     203                                msock = new MulticastSocket();
    144204                        }
    145                         else
    146                                 msock = new MulticastSocket();
    147205                        DatagramPacket dgmPacket = new DatagramPacket(msg.getBytes(), msg.length(), ssdpMultiGroup);
    148                         // Thnaks for Tho Beisch (11/09/04)
    149                         msock.setTimeToLive(4);
     206                        // Thnaks for Theo Beisch (11/09/04)
     207                        msock.setTimeToLive(UPnP.getTimeToLive());
    150208                        msock.send(dgmPacket);
    151209                        msock.close();
     
    181239        ////////////////////////////////////////////////
    182240
    183         public SSDPPacket receive()
     241        public SSDPPacket receive() throws IOException
    184242        {
    185243                byte ssdvRecvBuf[] = new byte[SSDP.RECV_MESSAGE_BUFSIZE];
    186244                SSDPPacket recvPacket = new SSDPPacket(ssdvRecvBuf, ssdvRecvBuf.length);
    187245                recvPacket.setLocalAddress(getLocalAddress());
    188                 try {
    189                         ssdpMultiSock.receive(recvPacket.getDatagramPacket());
    190                         recvPacket.setTimeStamp(System.currentTimeMillis());
    191                 }
    192                 catch (Exception e) {
    193                         //Debug.warning(e);
    194                 }
    195                 return recvPacket;
     246
     247                // Thanks for Kazuyuki Shudo (08/23/07)
     248                // Thanks for Stephan Mehlhase (2010-10-26)
     249                if (ssdpMultiSock != null)
     250                        ssdpMultiSock.receive(recvPacket.getDatagramPacket()); // throws IOException
     251                else
     252                        throw new IOException("Multicast socket has already been closed.");
     253               
     254                recvPacket.setTimeStamp(System.currentTimeMillis());
     255               
     256                return recvPacket;
    196257        }
    197258}
  • router/java/src/org/cybergarage/upnp/ssdp/HTTPUSocket.java

    rb033db96 r21466e0  
    2424package org.cybergarage.upnp.ssdp;
    2525
    26 import java.net.*;
    27 
    28 import org.cybergarage.util.*;
     26import java.net.DatagramPacket;
     27import java.net.DatagramSocket;
     28import java.net.InetAddress;
     29import java.net.InetSocketAddress;
     30
     31import org.cybergarage.util.Debug;
    2932
    3033public class HTTPUSocket
     
    7679                localAddr = addr;
    7780        }
     81
     82        /**
     83         *
     84         * @return {@link DatagramSocket} open for receieving packets
     85         * @since 1.8
     86         */
     87        public DatagramSocket getUDPSocket(){
     88                return ssdpUniSock;
     89        }       
    7890       
    7991        public String getLocalAddress()
     
    108120               
    109121                try {
     122                        // Changed to bind the specified address and port for Android v1.6 (2009/10/07)
     123                        InetSocketAddress bindInetAddr = new InetSocketAddress(InetAddress.getByName(bindAddr), bindPort);
     124                        ssdpUniSock = new DatagramSocket(bindInetAddr);
     125                }
     126                catch (Exception e) {
     127                        Debug.warning(e);
     128                        return false;
     129                }
     130
     131                /*
     132                try {
    110133                        // Bind only using the port without the interface address. (2003/12/12)
    111                         InetSocketAddress bindSock = new InetSocketAddress(/*InetAddress.getByName(bindAddr), */ bindPort);
     134                        InetSocketAddress bindInetAddr = new InetSocketAddress(bindPort);
    112135                        ssdpUniSock = new DatagramSocket(null);
    113136                        ssdpUniSock.setReuseAddress(true);
    114                         ssdpUniSock.bind(bindSock);
    115                 }
    116                 catch (Exception e) {
    117                         Debug.warning(e);
    118                         return false;
    119                 }
     137                        ssdpUniSock.bind(bindInetAddr);
     138                        return true;
     139                }
     140                catch (Exception e) {
     141                        Debug.warning(e);
     142                        return false;
     143                }
     144                */
    120145               
    121146                setLocalAddress(bindAddr);
  • router/java/src/org/cybergarage/upnp/ssdp/SSDP.java

    rb033db96 r21466e0  
    1313*       05/13/03
    1414*               - Added constants for IPv6.
     15*       08/03/05
     16*               - Thanks for Stefano Lenzi <kismet-sl at users.sourceforge.net>
     17*                 and Mikael <mhakman at users.sourceforge.net>
     18*               - Fixed getLeaseTime() to parse normally when the value includes extra strings such as white space.
    1519*       
    1620******************************************************************/
     
    1822package org.cybergarage.upnp.ssdp;
    1923
     24import org.cybergarage.util.Debug;
     25
     26/**
     27 *
     28 * This class defines constant value related to SSDP.<br>
     29 * All the values defined here are complaint to the UPnP Standard
     30 *
     31 * @author Satoshi "skonno" Konno
     32 * @author Stefano "Kismet" Lenzi
     33 * @version 1.0
     34 *
     35 */
    2036public class SSDP
    2137{
     
    2440        ////////////////////////////////////////////////
    2541
     42        /**
     43         * Default destination port for SSDP multicast messages
     44         */
    2645        public static final int PORT = 1900;
    2746       
     47        /**
     48         * Default IPv4 multicast address for SSDP messages
     49         */
    2850        public static final String ADDRESS = "239.255.255.250";
    2951
     
    6284        //      LeaseTime
    6385        ////////////////////////////////////////////////
    64        
    65         public final static int getLeaseTime(String cacheCont)
    66         {
    67                 int equIdx = cacheCont.indexOf('=');
    68                 int mx = 0;
    69                 try {
    70                         String mxStr = new String(cacheCont.getBytes(), equIdx+1, cacheCont.length() - (equIdx+1));
    71                         mx = Integer.parseInt(mxStr);
    72                 }
    73                 catch (Exception e) {}
    74                 return mx;
     86
     87        public final static int getLeaseTime(String cacheCont){
     88                /*
     89                 * Search for max-age keyword instead of equals sign Found value of
     90                 * max-age ends at next comma or end of string
     91                 */
     92                int mx = 0; 
     93                int maxAgeIdx = cacheCont.indexOf("max-age"); 
     94                if (maxAgeIdx >= 0) { 
     95                        int endIdx = cacheCont.indexOf(',',maxAgeIdx); 
     96                        if (endIdx < 0) 
     97                                endIdx = cacheCont.length(); 
     98                        try { 
     99                                maxAgeIdx = cacheCont.indexOf("=",maxAgeIdx);
     100                                String mxStr = cacheCont.substring(maxAgeIdx+1,endIdx).trim(); 
     101                                mx = Integer.parseInt(mxStr); 
     102                        } catch (Exception e) { 
     103                                Debug.warning (e); 
     104                        }
     105                } 
     106                return mx;
    75107        }
    76108}
  • router/java/src/org/cybergarage/upnp/ssdp/SSDPNotifyRequest.java

    rb033db96 r21466e0  
    1616package org.cybergarage.upnp.ssdp;
    1717
    18 import org.cybergarage.http.*;
     18import org.cybergarage.http.HTTP;
    1919
    2020public class SSDPNotifyRequest extends SSDPRequest
  • router/java/src/org/cybergarage/upnp/ssdp/SSDPNotifySocket.java

    rb033db96 r21466e0  
    2020*               - Handle receive() returning null.
    2121*               - Added close() in stop().
     22*       08/23/07
     23*               - Thanks for Kazuyuki Shudo
     24*               - Changed run() to catch IOException of HTTPMUSocket::receive().
     25*       01/31/08
     26*               - Changed start() not to abort when the interface infomation is null on Android m3-rc37a.
    2227*       
    2328******************************************************************/
     
    2631
    2732import java.net.*;
     33import java.io.IOException;
    2834
    2935import org.cybergarage.net.*;
     
    3238import org.cybergarage.upnp.*;
    3339
     40/**
     41 *
     42 * This class identifies a SSDP socket only for <b>notifing packet</b>.<br>
     43 *
     44 * @author Satoshi "skonno" Konno
     45 * @author Stefano "Kismet" Lenzi
     46 * @version 1.8
     47 *
     48 */
    3449public class SSDPNotifySocket extends HTTPMUSocket implements Runnable
    3550{
     
    6883        }
    6984
    70         ////////////////////////////////////////////////
    71         //      post (SSDPNotifySocket)
    72         ////////////////////////////////////////////////
    73 
     85        /**
     86         * This method send a {@link SSDPNotifyRequest} over {@link SSDPNotifySocket}
     87         *
     88         * @param req the {@link SSDPNotifyRequest} to send
     89         * @return true if and only if the trasmission succeced<br>
     90         *      Because it rely on UDP doesn't mean that it's also recieved
     91         */
    7492        public boolean post(SSDPNotifyRequest req)
    7593        {
     
    95113                while (deviceNotifyThread == thisThread) {
    96114                        Thread.yield();
    97                         SSDPPacket packet = receive();
     115
     116                        // Thanks for Kazuyuki Shudo (08/23/07)
     117                        SSDPPacket packet = null;
     118                        try {
     119                                packet = receive();
     120                        }
     121                        catch (IOException e) {
     122                                break;
     123                        }
    98124                       
    99125                        // Thanks for Mikael Hakman (04/20/05)
     
    109135                                continue;
    110136                        }
    111                                                                                                
     137                        //TODO Must be performed on a different Thread in order to prevent UDP packet losses.
    112138                        if (ctrlPoint != null)
    113139                                ctrlPoint.notifyReceived(packet);
     
    115141        }
    116142       
    117         public void start()
    118         {
    119                 deviceNotifyThread = new Thread(this, "UPnP-SSDPNotifySocket");
    120                 deviceNotifyThread.setDaemon(true);
     143        public void start(){
     144                StringBuffer name = new StringBuffer("Cyber.SSDPNotifySocket/");
     145                String localAddr = this.getLocalAddress();
     146                // localAddr is null on Android m3-rc37a (01/30/08)
     147                if (localAddr != null && 0 < localAddr.length()) {
     148                        name.append(this.getLocalAddress()).append(':');
     149                        name.append(this.getLocalPort()).append(" -> ");
     150                        name.append(this.getMulticastAddress()).append(':');
     151                        name.append(this.getMulticastPort());
     152                }
     153                deviceNotifyThread = new Thread(this,name.toString());
    121154                deviceNotifyThread.start();
    122155        }
  • router/java/src/org/cybergarage/upnp/ssdp/SSDPNotifySocketList.java

    rb033db96 r21466e0  
    1616package org.cybergarage.upnp.ssdp;
    1717
     18import java.net.InetAddress;
    1819import java.util.*;
    1920
     
    2829        ////////////////////////////////////////////////
    2930       
    30         private static final long serialVersionUID = -7066290881503106399L;
     31        private InetAddress[] binds = null;
    3132
    32         public SSDPNotifySocketList()
    33         {
     33        public SSDPNotifySocketList() {
     34        }
     35       
     36        /**
     37         *
     38         * @param binds The host to bind the service <tt>null</tt> means to bind to default.
     39         * @since 1.8
     40         */
     41        public SSDPNotifySocketList(InetAddress[] binds){
     42                this.binds=binds;
    3443        }
    3544
     
    6069        ////////////////////////////////////////////////
    6170       
    62         public boolean open()
    63         {
    64                 int nHostAddrs = HostInterface.getNHostAddresses();
    65                 for (int n=0; n<nHostAddrs; n++) {
    66                         String bindAddr = HostInterface.getHostAddress(n);
    67                         SSDPNotifySocket ssdpNotifySocket = new SSDPNotifySocket(bindAddr);
    68                         add(ssdpNotifySocket);
     71        public boolean open(){
     72                InetAddress[] binds=this.binds ;
     73                String[] bindAddresses;
     74                if(binds!=null){                       
     75                        bindAddresses = new String[binds.length];
     76                        for (int i = 0; i < binds.length; i++) {
     77                                bindAddresses[i] = binds[i].getHostAddress();
     78                        }
     79                }else{
     80                        int nHostAddrs = HostInterface.getNHostAddresses();
     81                        bindAddresses = new String[nHostAddrs];
     82                        for (int n=0; n<nHostAddrs; n++) {
     83                                bindAddresses[n] = HostInterface.getHostAddress(n);
     84                        }
     85                }               
     86               
     87                for (int i = 0; i < bindAddresses.length; i++) {
     88                        if(bindAddresses[i]!=null){
     89                                SSDPNotifySocket ssdpNotifySocket = new SSDPNotifySocket(bindAddresses[i]);
     90                                add(ssdpNotifySocket);
     91                        }
    6992                }
    7093                return true;
  • router/java/src/org/cybergarage/upnp/ssdp/SSDPRequest.java

    rb033db96 r21466e0  
    1919package org.cybergarage.upnp.ssdp;
    2020
     21import java.io.InputStream;
     22
    2123import org.cybergarage.http.*;
    2224
     
    3234        }
    3335
     36        public SSDPRequest(InputStream in)
     37        {
     38                super(in);
     39        }
     40       
    3441        ////////////////////////////////////////////////
    3542        //      NT
  • router/java/src/org/cybergarage/upnp/ssdp/SSDPResponse.java

    rb033db96 r21466e0  
    2525package org.cybergarage.upnp.ssdp;
    2626
     27import java.io.InputStream;
     28
    2729import org.cybergarage.http.*;
    2830
     
    3840        }
    3941
     42        public SSDPResponse(InputStream in)
     43        {
     44                super(in);
     45        }
     46       
    4047        ////////////////////////////////////////////////
    4148        //      ST (SearchTarget)
     
    115122        public String getHeader()
    116123        {
    117                 StringBuilder str = new StringBuilder();
     124                StringBuffer str = new StringBuffer();
    118125       
    119126                str.append(getStatusLineString());
  • router/java/src/org/cybergarage/upnp/ssdp/SSDPSearchResponseSocket.java

    rb033db96 r21466e0  
    1313*       05/28/03
    1414*               - Added post() to send a SSDPSearchRequest.
     15*       01/31/08
     16*               - Changed start() not to abort when the interface infomation is null on Android m3-rc37a.
    1517*       
    1618******************************************************************/
    1719
    1820package org.cybergarage.upnp.ssdp;
     21
     22import java.net.DatagramSocket;
     23import java.net.InetAddress;
    1924
    2025import org.cybergarage.upnp.*;
     
    7580        }
    7681       
    77         public void start()
    78         {
    79                 deviceSearchResponseThread = new Thread(this, "UPnP-SSDPSearchResponseSocket");
    80                 deviceSearchResponseThread.setDaemon(true);
    81                 deviceSearchResponseThread.start();
     82        public void start()     {
     83
     84                StringBuffer name = new StringBuffer("Cyber.SSDPSearchResponseSocket/");
     85                DatagramSocket s = getDatagramSocket();
     86                // localAddr is null on Android m3-rc37a (01/30/08)
     87                InetAddress localAddr = s.getLocalAddress();
     88                if (localAddr != null) {
     89                        name.append(s.getLocalAddress()).append(':');
     90                        name.append(s.getLocalPort());
     91                }
     92                deviceSearchResponseThread = new Thread(this,name.toString());
     93                deviceSearchResponseThread.start();             
    8294        }
    8395       
  • router/java/src/org/cybergarage/upnp/ssdp/SSDPSearchResponseSocketList.java

    rb033db96 r21466e0  
    1818package org.cybergarage.upnp.ssdp;
    1919
     20import java.net.InetAddress;
    2021import java.util.*;
    2122
     
    3031        ////////////////////////////////////////////////
    3132       
    32         private static final long serialVersionUID = 4509857798038125744L;
     33        private InetAddress[] binds = null;
     34       
     35        public SSDPSearchResponseSocketList() {
     36        }
     37        /**
     38         *
     39         * @param binds The host to bind.Use <tt>null</tt> for the default behavior
     40         */
     41        public SSDPSearchResponseSocketList(InetAddress[] binds) {
     42                this.binds = binds;
     43        }
    3344
    34         public SSDPSearchResponseSocketList()
    35         {
    36         }
     45       
     46       
     47        ////////////////////////////////////////////////
     48        //      ControlPoint
    3749
    3850        ////////////////////////////////////////////////
     
    6274        ////////////////////////////////////////////////
    6375       
    64         public boolean open(int port)
    65         {
     76        public boolean open(int port){
     77                InetAddress[] binds=this.binds ;
     78                String[] bindAddresses;
     79                if(binds!=null){                       
     80                        bindAddresses = new String[binds.length];
     81                        for (int i = 0; i < binds.length; i++) {
     82                                bindAddresses[i] = binds[i].getHostAddress();
     83                        }
     84                }else{
     85                        int nHostAddrs = HostInterface.getNHostAddresses();
     86                        bindAddresses = new String[nHostAddrs];
     87                        for (int n=0; n<nHostAddrs; n++) {
     88                                bindAddresses[n] = HostInterface.getHostAddress(n);
     89                        }
     90                }               
    6691                try {
    67                         int nHostAddrs = HostInterface.getNHostAddresses();
    68                         for (int n=0; n<nHostAddrs; n++) {
    69                                 String bindAddr = HostInterface.getHostAddress(n);
    70                                 SSDPSearchResponseSocket socket = new SSDPSearchResponseSocket(bindAddr, port);
     92                        for (int j = 0; j < bindAddresses.length; j++) {                               
     93                                SSDPSearchResponseSocket socket = new SSDPSearchResponseSocket(bindAddresses[j], port);
    7194                                add(socket);
    7295                        }
    73                 }
    74                 catch (Exception e) {
     96                }catch (Exception e) {
    7597                        stop();
    7698                        close();
  • router/java/src/org/cybergarage/upnp/ssdp/SSDPSearchSocket.java

    rb033db96 r21466e0  
    1919*               - Added close() in stop().
    2020*               - Added test for null return from receive() in run().
     21*       08/23/07
     22*               - Thanks for Kazuyuki Shudo
     23*               - Changed run() to catch IOException of HTTPMUSocket::receive().
     24*       01/10/08
     25*               - Changed start() not to abort when the interface infomation is null on Android m3-rc37a.
    2126*       
    2227******************************************************************/
    2328
    2429package org.cybergarage.upnp.ssdp;
     30
     31import java.net.Inet4Address;
     32import java.net.Inet6Address;
     33import java.net.InetAddress;
     34import java.io.IOException;
    2535
    2636import org.cybergarage.net.*;
     
    3141public class SSDPSearchSocket extends HTTPMUSocket implements Runnable
    3242{
    33         public SSDPSearchSocket()
    34         {
     43        private boolean useIPv6Address;
     44       
     45        ////////////////////////////////////////////////
     46        //      Constructor
     47        ////////////////////////////////////////////////
     48
     49
     50        /**
     51         *
     52         * @param bindAddr The address to bind the service
     53         * @param port The port used for accepting message
     54         * @param multicast The multicast address to use as destination
     55         * @since 1.8
     56         */
     57        public SSDPSearchSocket(String bindAddr,int port,String multicast){
     58                open(bindAddr,multicast);
    3559        }
    36        
    37         public SSDPSearchSocket(String bindAddr)
    38         {
    39                 open(bindAddr);
     60
     61        /**
     62         *
     63         * @param bindAddr the binding address for senging multicast packet
     64         * @since 1.8
     65         */
     66        public SSDPSearchSocket(InetAddress bindAddr){
     67                if(bindAddr.getAddress().length!=4){
     68                        this.open((Inet6Address)bindAddr);
     69                }else{
     70                        this.open((Inet4Address)bindAddr);
     71                }
    4072        }
    4173
     
    4375        //      Constructor
    4476        ////////////////////////////////////////////////
     77        public boolean open(Inet4Address bindAddr){
     78                useIPv6Address = false;
     79                return open(SSDP.ADDRESS, SSDP.PORT, bindAddr);
     80        }
     81       
     82        public boolean open(Inet6Address bindAddr){
     83                useIPv6Address = true;
     84                return open(SSDP.getIPv6Address(), SSDP.PORT, bindAddr);
     85        }
     86       
     87        public boolean open(String bind,String multicast){             
     88                if ((HostInterface.isIPv6Address(bind) ) && (HostInterface.isIPv6Address(multicast))){
     89                        useIPv6Address = true;
     90                }else if(HostInterface.isIPv4Address(bind) && (HostInterface.isIPv4Address(multicast))){
     91                        useIPv6Address = false;
     92                }else{
     93                        throw new IllegalArgumentException("Cannot open a UDP Socket for IPv6 address on IPv4 interface or viceversa");
     94                }
     95                return open(multicast, SSDP.PORT, bind);
     96        }
    4597
     98        /**
     99         *
     100         * @param bindAddr the hostname of the interface to use for senfing multicast packet
     101         * @return true if and only if it open the socket
     102         * @see {@link SSDP} for default multicast and port destination of the packtes
     103         */
    46104        public boolean open(String bindAddr)
    47105        {
    48106                String addr = SSDP.ADDRESS;
     107                useIPv6Address = false;
    49108                if (HostInterface.isIPv6Address(bindAddr) == true) {
    50109                        addr = SSDP.getIPv6Address();
     110                        useIPv6Address = true;
    51111                }
    52112                return open(addr, SSDP.PORT, bindAddr);
     
    90150                while (deviceSearchThread == thisThread) {
    91151                        Thread.yield();
    92                         SSDPPacket packet = receive();
     152
     153                        // Thanks for Kazuyuki Shudo (08/23/07)
     154                        SSDPPacket packet = null;
     155                        try {
     156                                packet = receive();
     157                        }
     158                        catch (IOException e) {
     159                                break;
     160                        }
    93161                       
    94162                        // Thanks for Mikael Hakman (04/20/05)
     
    96164                                continue;
    97165                               
     166                        //TODO perform delegation with Thread Pooling
    98167                        if (packet.isDiscover() == true)
    99168                                performSearchListener(packet);
     
    101170        }
    102171       
    103         public void start()
    104         {
    105                 deviceSearchThread = new Thread(this,"UPnP-SSDPSearchSocket");
    106                 deviceSearchThread.setDaemon(true);
     172        public void start() {
     173                StringBuffer name = new StringBuffer("Cyber.SSDPSearchSocket/");
     174                String localAddr = this.getLocalAddress();
     175                // localAddr is null on Android m3-rc37a (01/30/08)
     176                if (localAddr != null && 0 < localAddr.length()) {
     177                        name.append(this.getLocalAddress()).append(':');
     178                        name.append(this.getLocalPort()).append(" -> ");
     179                        name.append(this.getMulticastAddress()).append(':');
     180                        name.append(this.getMulticastPort());
     181                }
     182                deviceSearchThread = new Thread(this,name.toString());
    107183                deviceSearchThread.start();
    108184        }
  • router/java/src/org/cybergarage/upnp/ssdp/SSDPSearchSocketList.java

    rb033db96 r21466e0  
    1919package org.cybergarage.upnp.ssdp;
    2020
    21 import java.util.*;
     21import java.net.InetAddress;
     22import java.util.Vector;
    2223
    23 import org.cybergarage.net.*;
    24 
    25 import org.cybergarage.upnp.device.*;
     24import org.cybergarage.net.HostInterface;
     25import org.cybergarage.upnp.device.SearchListener;
    2626
    2727public class SSDPSearchSocketList extends Vector
     
    3131        ////////////////////////////////////////////////
    3232       
    33         private static final long serialVersionUID = 4071292828166415028L;
     33        private InetAddress[] binds = null;
     34        private String multicastIPv4 = SSDP.ADDRESS;
     35        private String multicastIPv6 = SSDP.getIPv6Address();
     36        private int port = SSDP.PORT;
    3437
    3538        public SSDPSearchSocketList()
    3639        {
    3740        }
     41        /**
     42         *
     43         * @param binds The IP address that we will used for bindind the service
     44         */
     45        public SSDPSearchSocketList(InetAddress[] binds) {
     46                this.binds = binds;
     47        }       
     48
     49        /**
     50         *
     51         * @param binds The IP address that we will used for bindind the service
     52         * @param port  The port that we will used for bindind the service
     53         * @param multicastIPv4 The IPv4 address that we will used for multicast comunication
     54         * @param multicastIPv6 The IPv6 address that we will used for multicast comunication
     55         * @since 1.8
     56         */
     57        public SSDPSearchSocketList(InetAddress[] binds,int port, String multicastIPv4, String multicastIPv6) {
     58                this.binds = binds;
     59                this.port = port;
     60                this.multicastIPv4 = multicastIPv4;
     61                this.multicastIPv6 = multicastIPv6;
     62        }
     63
     64       
     65       
    3866
    3967        ////////////////////////////////////////////////
     
    5987        ////////////////////////////////////////////////
    6088       
    61         public boolean open()
    62         {
    63                 int nHostAddrs = HostInterface.getNHostAddresses();
    64                 for (int n=0; n<nHostAddrs; n++) {
    65                         String bindAddr = HostInterface.getHostAddress(n);
    66                         SSDPSearchSocket ssdpSearchSocket = new SSDPSearchSocket(bindAddr);
    67                         add(ssdpSearchSocket);
     89        public boolean open() {
     90                InetAddress[] binds=this.binds;
     91                String[] bindAddresses;
     92                if(binds!=null){                       
     93                        bindAddresses = new String[binds.length];
     94                        for (int i = 0; i < binds.length; i++) {
     95                                bindAddresses[i] = binds[i].getHostAddress();
     96                        }
     97                }else{
     98                        int nHostAddrs = HostInterface.getNHostAddresses();
     99                        bindAddresses = new String[nHostAddrs];
     100                        for (int n=0; n<nHostAddrs; n++) {
     101                                bindAddresses[n] = HostInterface.getHostAddress(n);
     102                        }
     103                }               
     104               
     105                for (int i = 0; i < bindAddresses.length; i++) {
     106                        if(bindAddresses[i]!=null){
     107                                SSDPSearchSocket ssdpSearchSocket;
     108                                if(HostInterface.isIPv6Address(bindAddresses[i]))
     109                                        ssdpSearchSocket = new SSDPSearchSocket(bindAddresses[i],port ,multicastIPv6 );
     110                                else
     111                                        ssdpSearchSocket = new SSDPSearchSocket(bindAddresses[i],port,multicastIPv4 );
     112                                add(ssdpSearchSocket);
     113                        }
    68114                }
    69115                return true;
  • router/java/src/org/cybergarage/upnp/xml/DeviceData.java

    rb033db96 r21466e0  
    1919
    2020import java.io.*;
     21import java.net.InetAddress;
    2122
    2223import org.cybergarage.util.*;
     
    9091        ////////////////////////////////////////////////
    9192
    92         private HTTPServerList httpServerList = new HTTPServerList();           
     93        private HTTPServerList httpServerList = null;           
    9394
    9495        public HTTPServerList getHTTPServerList() {
    95                 return httpServerList;
     96                if(this.httpServerList==null){
     97                        this.httpServerList = new HTTPServerList(this.httpBinds,this.httpPort);
     98                }
     99                return this.httpServerList;
     100        }
     101       
     102        private InetAddress[] httpBinds = null;
     103       
     104        public void setHTTPBindAddress(InetAddress[] inets){
     105                this.httpBinds=inets;
     106        }
     107       
     108        public InetAddress[] getHTTPBindAddress(){
     109                return this.httpBinds;
    96110        }
    97111
     
    130144        ////////////////////////////////////////////////
    131145       
    132         private SSDPSearchSocketList ssdpSearchSocketList = new SSDPSearchSocketList();
     146        private SSDPSearchSocketList ssdpSearchSocketList = null;
     147        private String ssdpMulticastIPv4 = SSDP.ADDRESS;
     148        private String ssdpMulticastIPv6 = SSDP.getIPv6Address();
     149        private int ssdpPort = SSDP.PORT;
     150        private InetAddress[] ssdpBinds = null;
    133151       
    134152        public SSDPSearchSocketList getSSDPSearchSocketList() {
     153                if(this.ssdpSearchSocketList==null){
     154                        this.ssdpSearchSocketList = new SSDPSearchSocketList(this.ssdpBinds,ssdpPort,ssdpMulticastIPv4,ssdpMulticastIPv6);                     
     155                }
    135156                return ssdpSearchSocketList;
    136157        }
     158       
     159        /**
     160         *
     161         * @param port The port to use for binding the SSDP service.
     162         *              The port will be used as source port for all SSDP messages
     163         * @since 1.8
     164         */
     165        public void setSSDPPort(int port){
     166                this.ssdpPort=port;
     167        }
     168
     169        /**
     170         *
     171         * @return The port used for binding the SSDP service.
     172         *              The port will be used as source port for all SSDP messages
     173         */
     174        public int getSSDPPort(){
     175                return this.ssdpPort;
     176        }
     177       
     178       
     179        /**
     180         *
     181         * @param inets The <tt>InetAddress</tt> that will be binded for listing this service.
     182         *              Use <code>null</code> for the default behaviur.
     183         * @see {@link UPnP}
     184         * @see {@link USSDP}
     185         * @see {@link HostInterface}
     186         * @since 1.8
     187         */
     188        public void setSSDPBindAddress(InetAddress[] inets){
     189                this.ssdpBinds=inets;
     190        }
     191       
     192        /**
     193         *
     194         * @return inets The <tt>InetAddress</tt> that will be binded for this service
     195         *              <code>null</code> means that defulat behaviur will be used
     196         * @since 1.8
     197         */     
     198        public InetAddress[] getSSDPBindAddress(){
     199                return this.ssdpBinds;
     200        }
     201       
     202        /**
     203         *
     204         * @param ip The IPv4 address used as destination address for Multicast comunication
     205         * @since 1.8
     206         */
     207        public void setMulticastIPv4Address(String ip){
     208                this.ssdpMulticastIPv4=ip;
     209        }
     210
     211        /**
     212         *
     213         * @return The IPv4 address used for Multicast comunication
     214         */
     215        public String getMulticastIPv4Address(){
     216                return this.ssdpMulticastIPv4;
     217        }
     218       
     219        /**
     220         *
     221         * @param ip The IPv6 address used as destination address for Multicast comunication
     222         * @since 1.8
     223         */
     224        public void setMulticastIPv6Address(String ip){
     225                this.ssdpMulticastIPv6=ip;
     226        }
     227
     228        /**
     229         *
     230         * @return The IPv6 address used as destination address for Multicast comunication
     231         * @since 1.8
     232         */
     233        public String getMulticastIPv6Address(){
     234                return this.ssdpMulticastIPv6;
     235        }
     236       
     237       
    137238
    138239        ////////////////////////////////////////////////
  • router/java/src/org/cybergarage/upnp/xml/ServiceData.java

    rb033db96 r21466e0  
    6969        ////////////////////////////////////////////////
    7070
     71    private String descriptionURL = "";
     72
     73    public String getDescriptionURL() {
     74            return descriptionURL;
     75    }
     76
     77    public void setDescriptionURL(String descriptionURL) {
     78            this.descriptionURL = descriptionURL;
     79    }
     80       
     81        ////////////////////////////////////////////////
     82        // SID
     83        ////////////////////////////////////////////////
     84
    7185        private String sid = "";
    7286       
  • router/java/src/org/cybergarage/util/FileUtil.java

    rb033db96 r21466e0  
    1616package org.cybergarage.util;
    1717
    18 import java.io.*;
     18import java.io.ByteArrayOutputStream;
     19import java.io.File;
     20import java.io.FileInputStream;
    1921
    2022public final class FileUtil
  • router/java/src/org/cybergarage/util/ListenerList.java

    rb033db96 r21466e0  
    1616package org.cybergarage.util;
    1717
    18 import java.util.*;
     18import java.util.Vector;
    1919
    2020public class ListenerList extends Vector
    2121{
    22         private static final long serialVersionUID = 8039231561720446173L;
    23 
    2422        public boolean add(Object obj)
    2523        {
  • router/java/src/org/cybergarage/util/ThreadCore.java

    rb033db96 r21466e0  
    1111*       01/05/04
    1212*               - first revision.
     13*       08/23/07
     14*               - Thanks for Kazuyuki Shudo
     15*               - Changed stop() to stop more safety using Thread::interrupt().
    1316*       
    1417******************************************************************/
     
    4447                java.lang.Thread threadObject = getThreadObject();
    4548                if (threadObject == null) {
    46                         threadObject = new java.lang.Thread(this);
     49                        threadObject = new java.lang.Thread(this,"Cyber.ThreadCore");
    4750                        setThreadObject(threadObject);
    4851                        threadObject.start();
     
    6568                        //threadObject.destroy();
    6669                        //threadObject.stop();
     70                       
     71                        // Thanks for Kazuyuki Shudo (08/23/07)
     72                        threadObject.interrupt();
     73                       
    6774                        setThreadObject(null);
    6875                }
  • router/java/src/org/cybergarage/xml/AttributeList.java

    rb033db96 r21466e0  
    1616package org.cybergarage.xml;
    1717
    18 import java.util.*;
     18import java.util.Vector;
    1919
    2020public class AttributeList extends Vector
    2121{
    22         private static final long serialVersionUID = -5516389508555401104L;
    23 
    2422        public AttributeList()
    2523        {
  • router/java/src/org/cybergarage/xml/Node.java

    rb033db96 r21466e0  
    2323*               - Brian Owens <brian@b-owens.com>
    2424*               - Fixed toXMLString() to convert from "'" to "&apos;" instead of "\".
     25*       11/07/05
     26*               - Changed toString() to return as utf-8 string.
     27*       02/08/08
     28*               - Added addValue().
    2529*
    2630******************************************************************/
     
    3034import java.io.ByteArrayOutputStream;
    3135import java.io.PrintWriter;
    32 
    33 public class Node
     36import java.io.UnsupportedEncodingException;
     37import java.util.Iterator;
     38
     39public class Node
    3440{
    3541
    36         public Node()
     42        /**
     43         * Create a Node with empty UserData and no Parent Node
     44         *
     45         */
     46        public Node()
    3747        {
    3848                setUserData(null);
     
    4050        }
    4151
    42         public Node(String name)
     52        public Node(String name) 
    4353        {
    4454                this();
     
    4656        }
    4757
    48         public Node(String ns, String name)
     58        public Node(String ns, String name) 
    4959        {
    5060                this();
     
    5666        ////////////////////////////////////////////////
    5767
    58         private Node parentNode = null;
    59        
    60         public void setParentNode(Node node)
     68        private Node parentNode = null; 
     69       
     70        public void setParentNode(Node node) 
    6171        {
    6272                parentNode = node;
    6373        }
    6474
    65         public Node getParentNode()
     75        public Node getParentNode() 
    6676        {
    6777                return parentNode;
     
    7282        ////////////////////////////////////////////////
    7383
    74         public Node getRootNode()
     84        public Node getRootNode() 
    7585        {
    7686                Node rootNode = null;
     
    8797        ////////////////////////////////////////////////
    8898
    89         private String name = new String();
    90        
    91         public void setName(String name)
     99        private String name = new String(); 
     100       
     101        public void setName(String name) 
    92102        {
    93103                this.name = name;
    94104        }
    95105
    96         public void setName(String ns, String name)
     106        public void setName(String ns, String name) 
    97107        {
    98108                this.name = ns + ":" + name;
    99109        }
    100110
    101         public String getName()
     111        public String getName() 
    102112        {
    103113                return name;
     
    106116        public boolean isName(String value)
    107117        {
    108                 return name.equals(value);
     118                return name.equals(value);     
    109119        }
    110120       
     
    113123        ////////////////////////////////////////////////
    114124
    115         private String value = "";
    116        
    117         public void setValue(String value)
     125        private String value = new String();
     126       
     127        public void setValue(String value) 
    118128        {
    119129                this.value = value;
    120130        }
    121131
    122         public void setValue(int value)
     132        public void setValue(int value) 
    123133        {
    124134                setValue(Integer.toString(value));
    125135        }
    126136
     137        public void addValue(String value)
     138        {
     139                if (this.value == null) {
     140                        this.value = value;
     141                        return;
     142                }
     143                if (value != null)
     144                        this.value += value;
     145        }
     146       
    127147        public String getValue()
    128148        {
     
    144164        }
    145165
    146         public Attribute getAttribute(String name)
     166        public Attribute getAttribute(String name) 
    147167        {
    148168                return attrList.getAttribute(name);
     
    215235        ////////////////////////////////////////////////
    216236
    217         public void setNameSpace(String ns, String value)
     237        public void setNameSpace(String ns, String value) 
    218238        {
    219239                setAttribute("xmlns:" + ns, value);
     
    234254        }
    235255
    236         public Node getNode(String name)
     256        public Node getNode(String name) 
    237257        {
    238258                return nodeList.getNode(name);
    239259        }
    240260       
    241         public Node getNodeEndsWith(String name)
     261        public Node getNodeEndsWith(String name) 
    242262        {
    243263                return nodeList.getEndsWith(name);
     
    252272                node.setParentNode(this);
    253273                nodeList.insertElementAt(node, index);
     274        }
     275
     276        public int getIndex(String name){
     277                int index = -1;
     278                for (Iterator i = nodeList.iterator(); i.hasNext();) {
     279                        index++;
     280                        Node n = (Node) i.next();
     281                        if(n.getName().equals(name))
     282                                return index;
     283                }
     284                return index;
    254285        }
    255286
     
    301332        ////////////////////////////////////////////////
    302333
    303         private Object userData = null;
    304        
    305         public void setUserData(Object data)
     334        private Object userData = null; 
     335       
     336        public void setUserData(Object data) 
    306337        {
    307338                userData = data;
    308339        }
    309340
    310         public Object getUserData()
     341        public Object getUserData() 
    311342        {
    312343                return userData;
    313344        }
    314 
    315        
    316         ////////////////////////////////////////////////
    317         //      toString
    318         ////////////////////////////////////////////////
    319 
    320         public String getIndentLevelString(int nIndentLevel)
    321         {
    322                 char indentString[] = new char[nIndentLevel];
    323                 for (int n=0; n<nIndentLevel; n++)
    324                         indentString[n] = '\t' ;
    325                 return new String(indentString);
    326         }
    327 
     345       
     346        ////////////////////////////////////////////////
     347        //      toString
     348        ////////////////////////////////////////////////
     349
     350        /**
     351         * Inovoke {@link #getIndentLevelString(int, String)} with <code>"   "</code> as String
     352         *
     353         * @see #getIndentLevelString(int, String)
     354         */
     355        public String getIndentLevelString(int nIndentLevel)
     356        {
     357                return getIndentLevelString(nIndentLevel,"   ");
     358        }
     359
     360        /**
     361         *
     362         * @param nIndentLevel the level of indentation to produce
     363         * @param space the String to use for the intendation
     364         * @since 1.8.0
     365         * @return an indentation String
     366         */
     367        public String getIndentLevelString(int nIndentLevel,String space)
     368        {
     369                StringBuffer indentString = new StringBuffer(nIndentLevel*space.length());
     370                for (int n=0; n<nIndentLevel; n++){
     371                        indentString.append(space);
     372                }
     373                return indentString.toString();
     374        }       
     375       
    328376        public void outputAttributes(PrintWriter ps)
    329377        {
     
    335383        }
    336384
    337         public void output(PrintWriter ps, int indentLevel, boolean hasChildNode)
     385        public void output(PrintWriter ps, int indentLevel, boolean hasChildNode) 
    338386        {
    339387                String indentString = getIndentLevelString(indentLevel);
     
    342390                String value = getValue();
    343391
    344                 if (hasNodes() == false || hasChildNode == false) {
     392                if (hasNodes() == false || hasChildNode == false) {             
    345393                        ps.print(indentString + "<" + name);
    346394                        outputAttributes(ps);
    347395                        // Thnaks for Tho Beisch (11/09/04)
    348396                        if (value == null || value.length() == 0) {
    349                                 // No value, so use short notation <node />
    350                                 ps.println(" />");
     397                                // Not using the short notation <node /> because it cause compatibility trouble
     398                                ps.println("></" + name + ">");
    351399                        } else {
    352400                                ps.println(">" + XML.escapeXMLChars(value) + "</" + name + ">");
     
    369417        }
    370418
    371         public String toString(boolean hasChildNode)
     419        public String toString(String enc, boolean hasChildNode)
    372420        {
    373421                ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
     
    375423                output(pr, 0, hasChildNode);
    376424                pr.flush();
     425                try {
     426                        if (enc != null && 0 < enc.length())
     427                                return byteOut.toString(enc);
     428                }
     429                catch (UnsupportedEncodingException e) {
     430                }
    377431                return byteOut.toString();
    378432        }
    379433               
    380         @Override
    381     public String toString()
    382         {
    383                 return toString(true);
     434        public String toString()
     435        {
     436                return toString(XML.CHARSET_UTF8, true);
    384437        }
    385438       
     
    387440        {
    388441                String xmlStr = toString();
    389                 xmlStr = xmlStr.replaceAll("<", "&lt;");
    390                 xmlStr = xmlStr.replaceAll(">", "&gt;");
     442                xmlStr = xmlStr.replaceAll("<", "&lt;");       
     443                xmlStr = xmlStr.replaceAll(">", "&gt;");       
    391444                // Thanks for Theo Beisch (11/09/04)
    392                 xmlStr = xmlStr.replaceAll("&", "&amp;");
    393                 xmlStr = xmlStr.replaceAll("\"", "&quot;");
     445                xmlStr = xmlStr.replaceAll("&", "&amp;");       
     446                xmlStr = xmlStr.replaceAll("\"", "&quot;");     
    394447                // Thanks for Brian Owens (12/02/04)
    395                 xmlStr = xmlStr.replaceAll("'", "&apos;");
     448                xmlStr = xmlStr.replaceAll("'", "&apos;");     
    396449                return xmlStr;
    397450        }
  • router/java/src/org/cybergarage/xml/NodeList.java

    rb033db96 r21466e0  
    1616package org.cybergarage.xml;
    1717
    18 import java.util.*;
     18import java.util.Vector;
    1919
    2020public class NodeList extends Vector
    2121{
    22         private static final long serialVersionUID = 1528884682346143213L;
    23 
    2422        public NodeList()
    2523        {
  • router/java/src/org/cybergarage/xml/Parser.java

    rb033db96 r21466e0  
    99*       Revision;
    1010*
    11 *       11/26/03
     11*       11/26/2003
    1212*               - first revision.
    13 *       03/30/05
     13*       03/30/2005
    1414*               - Change parse(String) to use StringBufferInputStream instead of URL.
     15*       11/11/2009
     16*               - Changed Parser::parser() to use ByteArrayInputStream instead of StringBufferInputStream because of bugs in Android v1.6.
    1517*
    1618******************************************************************/
     
    1820package org.cybergarage.xml;
    1921
    20 import java.net.*;
    21 import java.io.*;
     22import java.io.File;
     23import java.io.FileInputStream;
     24import java.io.InputStream;
     25import java.io.ByteArrayInputStream;
     26import java.net.HttpURLConnection;
     27import java.net.URL;
     28
     29import org.cybergarage.http.HTTP;
     30import org.cybergarage.http.HTTPRequest;
     31import org.cybergarage.http.HTTPResponse;
    2232
    2333public abstract class Parser
     
    4353        public Node parse(URL locationURL) throws ParserException
    4454        {
     55                String host = locationURL.getHost();
     56                int port = locationURL.getPort();
     57                // Thanks for Hao Hu
     58                if (port == -1)
     59                        port = 80;
     60                String uri = locationURL.getPath();
     61               
    4562                try {
    4663                        HttpURLConnection urlCon = (HttpURLConnection)locationURL.openConnection();
    47                         // I2P mods to prevent hangs (see HTTPRequest for more info)
    48                         // this seems to work, getInputStream actually does the connect(),
    49                         // (as shown by a thread dump)
    50                         // so we can set these after openConnection()
    51                         // Alternative would be foo = new HttpURLConnection(locationURL); foo.set timeouts; foo.connect()
    52                         urlCon.setConnectTimeout(2*1000);
    53                         urlCon.setReadTimeout(1000);
    5464                        urlCon.setRequestMethod("GET");
     65                        urlCon.setRequestProperty(HTTP.CONTENT_LENGTH,"0");
     66                        if (host != null)
     67                                urlCon.setRequestProperty(HTTP.HOST, host);
     68
    5569                        InputStream urlIn = urlCon.getInputStream();
    5670
     
    6377                       
    6478                } catch (Exception e) {
    65                         throw new ParserException(e);
     79                        //throw new ParserException(e);
    6680                }
    67                 /*
    68                 String host = locationURL.getHost();
    69                 int port = locationURL.getPort();
    70                 String uri = locationURL.getPath();
     81
    7182                HTTPRequest httpReq = new HTTPRequest();
    7283                httpReq.setMethod(HTTP.GET);
     
    7485                HTTPResponse httpRes = httpReq.post(host, port);
    7586                if (httpRes.isSuccessful() == false)
    76                         throw new ParserException(locationURL.toString());
     87                        throw new ParserException("HTTP comunication failed: no answer from peer." +
     88                                        "Unable to retrive resoure -> "+locationURL.toString());
    7789                String content = new String(httpRes.getContent());
    78                 StringBufferInputStream strBuf = new StringBufferInputStream(content);
     90                ByteArrayInputStream strBuf = new ByteArrayInputStream(content.getBytes());
    7991                return parse(strBuf);
    80                 */
    8192        }
    8293
  • router/java/src/org/cybergarage/xml/ParserException.java

    rb033db96 r21466e0  
    2020public class ParserException extends Exception
    2121{
    22         private static final long serialVersionUID = 7443033796560597360L;
    23 
    2422        public ParserException(Exception e)
    2523        {
  • router/java/src/org/cybergarage/xml/XML.java

    rb033db96 r21466e0  
    2222{
    2323        public final static String CONTENT_TYPE = "text/xml; charset=\"utf-8\"";
     24        public final static String CHARSET_UTF8 = "utf-8";
    2425
    2526        ////////////////////////////////////////////////
     
    2930        private final static String escapeXMLChars(String input, boolean quote)
    3031        {
    31                 StringBuilder out = new StringBuilder();
    3232                if (input == null)
    3333                        return null;
     34                StringBuffer out = new StringBuffer();
    3435                int oldsize=input.length();
    3536                char[] old=new char[oldsize];
     
    6263                return escapeXMLChars(input, true);
    6364        }
     65       
     66        ////////////////////////////////////////////////
     67        // unescapeXMLChars
     68        ////////////////////////////////////////////////
     69
     70        public final static String unescapeXMLChars(String input)
     71        {
     72                if (input == null)
     73                        return null;
     74               
     75                String outStr;
     76
     77                outStr = input.replace("&amp;", "&");
     78                outStr = outStr.replace("&lt;", "<");
     79                outStr = outStr.replace("&gt;", ">");
     80                outStr = outStr.replace("&apos;", "\'");
     81                outStr = outStr.replace("&quot;", "\"");
     82               
     83                return outStr;
     84        }
    6485}
    6586
  • router/java/src/org/cybergarage/xml/parser/JaxpParser.java

    rb033db96 r21466e0  
    1313*       06/15/04
    1414*               - first revision.
     15*       01/08/08
     16*               - Fixed parse() not to occur null exception when the NamedNodeMap is null on Android.
     17*       02/08/08
     18*               - Change parse() to use Node::addValue() instead of the setValue().
    1519*
    1620******************************************************************/
     
    5155                String domNodeName = domNode.getNodeName();
    5256                String domNodeValue = domNode.getNodeValue();
     57                NamedNodeMap attrs = domNode.getAttributes();
     58                int arrrsLen = (attrs != null) ? attrs.getLength() : 0;
    5359
    5460//              Debug.message("[" + rank + "] ELEM : " + domNodeName + ", " + domNodeValue + ", type = " + domNodeType + ", attrs = " + arrrsLen);
    5561
    5662                if (domNodeType == org.w3c.dom.Node.TEXT_NODE) {
    57                         parentNode.setValue(domNodeValue);
     63                        // Change to use Node::addValue() instead of the setValue(). (2008/02/07)
     64                        //parentNode.setValue(domNodeValue);
     65                        parentNode.addValue(domNodeValue);
    5866                        return parentNode;
    5967                }
     
    7078
    7179                NamedNodeMap attrMap = domNode.getAttributes();
    72                 int attrLen = attrMap.getLength();
    73                 //Debug.message("attrLen = " + attrLen);
    74                 for (int n = 0; n<attrLen; n++) {
    75                         org.w3c.dom.Node attr = attrMap.item(n);
    76                         String attrName = attr.getNodeName();
    77                         String attrValue = attr.getNodeValue();
    78                         node.setAttribute(attrName, attrValue);
     80                if (attrMap != null) {
     81                        int attrLen = attrMap.getLength();
     82                        //Debug.message("attrLen = " + attrLen);
     83                        for (int n = 0; n<attrLen; n++) {
     84                                org.w3c.dom.Node attr = attrMap.item(n);
     85                                String attrName = attr.getNodeName();
     86                                String attrValue = attr.getNodeValue();
     87                                node.setAttribute(attrName, attrValue);
     88                        }
    7989                }
    8090               
    8191                org.w3c.dom.Node child = domNode.getFirstChild();
    82                 while (child != null) {
     92                if(child==null){
     93                        node.setValue("");
     94                        return node;
     95                }
     96                do{
    8397                        parse(node, child, rank+1);
    8498                        child = child.getNextSibling();
    85                 }
     99                }while (child != null);         
    86100               
    87101                return node;
Note: See TracChangeset for help on using the changeset viewer.