Changeset 65efefb


Ignore:
Timestamp:
Aug 14, 2012 1:50:15 PM (8 years ago)
Author:
zzz <zzz@…>
Branches:
master
Children:
e22882b
Parents:
44edf70 (diff), df00725 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

propagate from branch 'i2p.i2p' (head 51b3351f42e7ff6e2f2bd8512e4b4402e08631f4)

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

Files:
1 added
72 edited

Legend:

Unmodified
Added
Removed
  • licenses/LICENSE-UPnP.txt

    r44edf70 r65efefb  
    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/Date.java

    r44edf70 r65efefb  
    137137        {
    138138                // Thanks for Theo Beisch (10/20/04)
    139                 Calendar _cal = getCalendar();
     139                Calendar cal = getCalendar();
    140140                return
    141                         toWeekString(_cal.get(Calendar.DAY_OF_WEEK)) +", " +
    142                         toTimeString(_cal.get(Calendar.DATE)) + " " +
    143                         toMonthString(_cal.get(Calendar.MONTH)) + " " +
    144                         Integer.toString(_cal.get(Calendar.YEAR)) + " " +
    145                         toTimeString(_cal.get(Calendar.HOUR_OF_DAY)) + ":" +
    146                         toTimeString(_cal.get(Calendar.MINUTE)) + ":" +
    147                         toTimeString(_cal.get(Calendar.SECOND)) + " GMT";
     141                        toWeekString(cal.get(Calendar.DAY_OF_WEEK)) +", " +
     142                        toTimeString(cal.get(Calendar.DATE)) + " " +
     143                        toMonthString(cal.get(Calendar.MONTH)) + " " +
     144                        Integer.toString(cal.get(Calendar.YEAR)) + " " +
     145                        toTimeString(cal.get(Calendar.HOUR_OF_DAY)) + ":" +
     146                        toTimeString(cal.get(Calendar.MINUTE)) + ":" +
     147                        toTimeString(cal.get(Calendar.SECOND)) + " GMT";
    148148        }
    149149
     
    155155        {
    156156                // Thanks for Theo Beisch (10/20/04)
    157                 Calendar _cal = getCalendar();
     157                Calendar cal = getCalendar();
    158158                return
    159                         toDateString(_cal.get(Calendar.HOUR_OF_DAY)) +
    160                         (((_cal.get(Calendar.SECOND) % 2) == 0) ? ":" : " ") +
    161                         toDateString(_cal.get(Calendar.MINUTE));
     159                        toDateString(cal.get(Calendar.HOUR_OF_DAY)) +
     160                        (((cal.get(Calendar.SECOND) % 2) == 0) ? ":" : " ") +
     161                        toDateString(cal.get(Calendar.MINUTE));
    162162        }
    163163               
  • router/java/src/org/cybergarage/http/HTTP.java

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    1919package org.cybergarage.http;
    2020
    21 import java.io.*;
     21import java.io.IOException;
     22import java.io.LineNumberReader;
     23import java.io.StringReader;
    2224import java.util.Locale;
    2325
    24 import org.cybergarage.util.*;
     26import org.cybergarage.util.Debug;
    2527
    2628public class HTTPHeader
    2729{
     30        private static int MAX_LENGTH = 1024;
    2831        private String name;
    2932        private String value;
     
    4447                if (colonIdx < 0)
    4548                        return;
    46                 String _name = new String(lineStr.getBytes(), 0, colonIdx);
    47                 String _value = new String(lineStr.getBytes(), colonIdx+1, lineStr.length()-colonIdx-1);
    48                 setName(_name.trim());
    49                 setValue(_value.trim());
     49                String name = new String(lineStr.getBytes(), 0, colonIdx);                             
     50                String value = new String(lineStr.getBytes(), colonIdx+1, lineStr.length()-colonIdx-1);                         
     51                setName(name.trim());
     52                setValue(value.trim());
    5053        }
    5154
     
    114117        public final static String getValue(String data, String name)
    115118        {
     119                /* Thanks for Stephan Mehlhase (2010-10-26) */
    116120                StringReader strReader = new StringReader(data);
    117                 LineNumberReader lineReader = new LineNumberReader(strReader);
     121                LineNumberReader lineReader = new LineNumberReader(strReader, Math.min(data.length(), MAX_LENGTH));
    118122                return getValue(lineReader, name);
    119123        }
  • router/java/src/org/cybergarage/http/HTTPPacket.java

    r44edf70 r65efefb  
    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();
    138                         if (_firstLine == null || _firstLine.length() <= 0)
     181                        String firstLine = readLine(reader);
     182                        if (firstLine == null || firstLine.length() <= 0)
    139183                                return false;
    140                         setFirstLine(_firstLine);
     184                        setFirstLine(firstLine);
    141185                       
    142186                        // Thanks for Giordano Sassaroli <sassarol@cefriel.it> (09/03/03)
    143                         HTTPStatus httpStatus = new HTTPStatus(_firstLine);
     187                        HTTPStatus httpStatus = new HTTPStatus(firstLine);
    144188                        int statCode = httpStatus.getStatusCode();
    145189                        if (statCode == HTTPStatus.CONTINUE){
     
    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                                }
    189                                 catch (Exception e) {}
     235                                catch (Exception e) {};
    190236                        }
    191237                        else
    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) {
    233283                                                contentLen = 0;
    234                                         }
     284                                        };
    235285                                }
    236286                                else
     
    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)
     
    651734                        range[0] = Long.parseLong(firstPosStr);
    652735                }
    653                 catch (NumberFormatException e) {}
     736                catch (NumberFormatException e) {};
    654737                if (strToken.hasMoreTokens() == false)
    655738                        return range;
     
    658741                        range[1] = Long.parseLong(lastPosStr);
    659742                }
    660                 catch (NumberFormatException e) {}
     743                catch (NumberFormatException e) {};
    661744                if (strToken.hasMoreTokens() == false)
    662745                        return range;
     
    665748                        range[2] = Long.parseLong(lengthStr);
    666749                }
    667                 catch (NumberFormatException e) {}
     750                catch (NumberFormatException e) {};
    668751                return range;
    669752        }
     
    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

    r44edf70 r65efefb  
    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.SocketAddress;
     63import java.net.SocketException;
     64import java.net.InetSocketAddress;
     65import java.util.StringTokenizer;
    5566
    5667import org.cybergarage.util.Debug;
    57 
     68/**
     69 *
     70 * This class rappresnet an HTTP <b>request</b>, and act as HTTP client when it sends the request<br>
     71 *
     72 * @author Satoshi "skonno" Konno
     73 * @author Stefano "Kismet" Lenzi
     74 * @version 1.8
     75 *
     76 */
    5877public class HTTPRequest extends HTTPPacket
    5978{
     
    6483        public HTTPRequest()
    6584        {
     85                setVersion(HTTP.VERSION_10);
    6686        }
    6787
     
    167187        {
    168188                ParameterList paramList = new ParameterList();
    169                 String _uri = getURI();
    170                 if (_uri == null)
     189                String uri = getURI();
     190                if (uri == null)
    171191                        return paramList;
    172                 int paramIdx = _uri.indexOf('?');
     192                int paramIdx = uri.indexOf('?');
    173193                if (paramIdx < 0)
    174194                        return paramList;
    175195                while (0 < paramIdx) {
    176                         int eqIdx = _uri.indexOf('=', (paramIdx+1));
    177                         String name = _uri.substring(paramIdx+1, eqIdx);
    178                         int nextParamIdx = _uri.indexOf('&', (eqIdx+1));
    179                         String value = _uri.substring(eqIdx+1, (0 < nextParamIdx) ? nextParamIdx : _uri.length());
     196                        int eqIdx = uri.indexOf('=', (paramIdx+1));
     197                        String name = uri.substring(paramIdx+1, eqIdx);
     198                        int nextParamIdx = uri.indexOf('&', (eqIdx+1));
     199                        String value = uri.substring(eqIdx+1, (0 < nextParamIdx) ? nextParamIdx : uri.length());
    180200                        Parameter param = new Parameter(name, value);
    181201                        paramList.add(param);
     
    299319        public String getHeader()
    300320        {
    301                 StringBuilder str = new StringBuilder();
     321                StringBuffer str = new StringBuffer();
    302322               
    303323                str.append(getFirstLineString());
     
    373393                HTTPResponse httpRes = new HTTPResponse();
    374394
     395                setHost(host);
     396               
    375397                setConnection((isKeepAlive == true) ? HTTP.KEEP_ALIVE : HTTP.CLOSE);
    376398               
     
    411433                        if (0 < contentLength) {
    412434                                if (isChunkedRequest == true) {
    413                                         String chunSizeBuf = Long.toString(contentLength);
     435                                        // Thanks for Lee Peik Feng <pflee@users.sourceforge.net> (07/07/05)
     436                                        String chunSizeBuf = Long.toHexString(contentLength);
    414437                                        pout.print(chunSizeBuf);
    415438                                        pout.print(HTTP.CRLF);
     
    429452                        in = postSocket.getInputStream();
    430453                        httpRes.set(in, isHeaderRequest);               
    431                 }
    432                 catch (Exception e) {
     454                } catch (SocketException e) {
    433455                        httpRes.setStatusCode(HTTPStatus.INTERNAL_SERVER_ERROR);
    434                         // I2P addition
     456                        Debug.warning(e);
     457                } catch (IOException e) {
     458                        //Socket create but without connection
     459                        //TODO Blacklistening the device
     460                        httpRes.setStatusCode(HTTPStatus.INTERNAL_SERVER_ERROR);
    435461                        Debug.warning(e);
    436462                } finally {
     
    438464                                try {
    439465                                        in.close();
    440                                 } catch (Exception e) {}
     466                                } catch (Exception e) {};
    441467                                if (in != null)
    442468                                try {
    443469                                        out.close();
    444                                 } catch (Exception e) {}
     470                                } catch (Exception e) {};
    445471                                if (out != null)
    446472                                try {
    447473                                        postSocket.close();
    448                                 } catch (Exception e) {}
     474                                } catch (Exception e) {};
    449475                                postSocket = null;
    450476                        }
     
    495521        ////////////////////////////////////////////////
    496522       
    497     @Override
    498523        public String toString()
    499524        {
    500                 StringBuilder str = new StringBuilder();
     525                StringBuffer str = new StringBuffer();
    501526
    502527                str.append(getHeader());
  • router/java/src/org/cybergarage/http/HTTPResponse.java

    r44edf70 r65efefb  
    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());
     
    9899        ////////////////////////////////////////////////
    99100       
    100     @Override
    101101        public String toString()
    102102        {
    103                 StringBuilder str = new StringBuilder();
     103                StringBuffer str = new StringBuffer();
    104104
    105105                str.append(getStatusLineString());
  • router/java/src/org/cybergarage/http/HTTPServer.java

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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
     
    3838        ////////////////////////////////////////////////
    3939
    40     @Override
    4140        public void run()
    4241        {
  • router/java/src/org/cybergarage/http/HTTPSocket.java

    r44edf70 r65efefb  
    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
     
    4652        }
    4753       
    48     @Override
    4954        public void finalize()
    5055        {
     
    121126                }
    122127                catch (Exception e) {
     128                        //TODO Add blacklistening of the UPnP Device
    123129                        return false;
    124130                }
     
    148154        private boolean post(HTTPResponse httpRes, byte content[], long contentOffset, long contentLength, boolean isOnlyHeader)
    149155        {
     156                //TODO Check for bad HTTP agents, this method may be list for IOInteruptedException and for blacklistening
    150157                httpRes.setDate(Calendar.getInstance());
     158               
    151159                OutputStream out = getOutputStream();
    152160
     
    164172                       
    165173                        if (isChunkedResponse == true) {
    166                                 String chunSizeBuf = Long.toString(contentLength);
     174                                // Thanks for Lee Peik Feng <pflee@users.sourceforge.net> (07/07/05)
     175                                String chunSizeBuf = Long.toHexString(contentLength);
    167176                                out.write(chunSizeBuf.getBytes());
    168177                                out.write(HTTP.CRLF.getBytes());
     
    189198        private boolean post(HTTPResponse httpRes, InputStream in, long contentOffset, long contentLength, boolean isOnlyHeader)
    190199        {
     200                //TODO Check for bad HTTP agents, this method may be list for IOInteruptedException and for blacklistening
    191201                httpRes.setDate(Calendar.getInstance());
     202               
    192203                OutputStream out = getOutputStream();
    193204
     
    215226                        while (0 < readLen && readCnt < contentLength) {
    216227                                if (isChunkedResponse == true) {
    217                                         String chunSizeBuf = Long.toString(readLen);
     228                                        // Thanks for Lee Peik Feng <pflee@users.sourceforge.net> (07/07/05)
     229                                        String chunSizeBuf = Long.toHexString(readLen);
    218230                                        out.write(chunSizeBuf.getBytes());
    219231                                        out.write(HTTP.CRLF.getBytes());
     
    244256        public boolean post(HTTPResponse httpRes, long contentOffset, long contentLength, boolean isOnlyHeader)
    245257        {
     258                //TODO Close if Connection != keep-alive
    246259                if (httpRes.hasContentInputStream() == true)
    247260                        return post(httpRes,httpRes.getContentInputStream(), contentOffset, contentLength, isOnlyHeader);
  • router/java/src/org/cybergarage/http/HTTPStatus.java

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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        {
     
    132195                        }
    133196                }
    134                 catch(Exception e){}
     197                catch(Exception e){};
    135198                return "";
    136199        }
     
    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

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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
     
    9094                        ByteArrayInputStream byteIn = new ByteArrayInputStream(content);
    9195                        Parser xmlParser = SOAP.getXMLParser();
    92                         Node _rootNode = xmlParser.parse(byteIn);
    93                         soapRes.setEnvelopeNode(_rootNode);
     96                        Node rootNode = xmlParser.parse(byteIn);
     97                        soapRes.setEnvelopeNode(rootNode);
    9498                }
    9599                catch (Exception e) {
     
    171175        ////////////////////////////////////////////////
    172176       
    173     @Override
    174177        public void print()
    175178        {
  • router/java/src/org/cybergarage/soap/SOAPResponse.java

    r44edf70 r65efefb  
    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
     
    180181        ////////////////////////////////////////////////
    181182       
    182     @Override
    183183        public void print()
    184184        {
  • router/java/src/org/cybergarage/upnp/Action.java

    r44edf70 r65efefb  
    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       
     
    273336                }
    274337                else {
    275                         UPnPStatus _upnpStatus = getStatus();
    276                         actionRes.setFaultResponse(_upnpStatus.getCode(), _upnpStatus.getDescription());
     338                        UPnPStatus upnpStatus = getStatus();
     339                        actionRes.setFaultResponse(upnpStatus.getCode(), upnpStatus.getDescription());
    277340                }
    278341                if (Debug.isOn() == true)
     
    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

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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);
     
    126150                setRenewSubscriber(null);
    127151        }
     152       
     153        public ControlPoint(int ssdpPort, int httpPort){
     154                this(ssdpPort,httpPort,null);
     155        }
    128156
    129157        public ControlPoint()
     
    132160        }
    133161
    134     @Override
    135162        public void finalize()
    136163        {
     
    317344        }
    318345
    319         private void removeDevice(Device dev)
     346        protected void removeDevice(Device dev)
    320347        {
    321348                if (dev == null)
     
    324351        }
    325352       
    326         private void removeDevice(String name)
     353        protected void removeDevice(String name)
    327354        {
    328355                Device dev = getDevice(name);
     
    402429                for (int n=0; n<listenerSize; n++) {
    403430                        NotifyListener listener = (NotifyListener)deviceNotifyListenerList.get(n);
    404                         listener.deviceNotifyReceived(ssdpPacket);
     431                        try{
     432                                listener.deviceNotifyReceived(ssdpPacket);
     433                        }catch(Exception e){
     434                                Debug.warning("NotifyListener returned an error:", e);
     435                        }
    405436                }
    406437        }
     
    427458                for (int n=0; n<listenerSize; n++) {
    428459                        SearchResponseListener listener = (SearchResponseListener)deviceSearchResponseListenerList.get(n);
    429                         listener.deviceSearchResponseReceived(ssdpPacket);
     460                        try{
     461                                listener.deviceSearchResponseReceived(ssdpPacket);
     462                        }catch(Exception e){
     463                                Debug.warning("SearchResponseListener returned an error:", e);
     464                        }
     465
     466
    430467                }
    431468        }
     
    475512        {
    476513                if (packet.isRootDevice() == true) {
    477                         if (packet.isAlive() == true)
     514                        if (packet.isAlive() == true){
    478515                                addDevice(packet);
    479                         if (packet.isByeBye() == true)
     516                        }else if (packet.isByeBye() == true){
    480517                                removeDevice(packet);
     518                        }
    481519                }
    482520                performNotifyListener(packet);
     
    509547        {
    510548                SSDPSearchRequest msReq = new SSDPSearchRequest(target, mx);
    511                 SSDPSearchResponseSocketList _ssdpSearchResponseSocketList = getSSDPSearchResponseSocketList();
    512                 _ssdpSearchResponseSocketList.post(msReq);
     549                SSDPSearchResponseSocketList ssdpSearchResponseSocketList = getSSDPSearchResponseSocketList();
     550                ssdpSearchResponseSocketList.post(msReq);
    513551        }
    514552
     
    793831                int retryCnt = 0;
    794832                int bindPort = getHTTPPort();
    795                 HTTPServerList _httpServerList = getHTTPServerList();
    796                 while (_httpServerList.open(bindPort) == false) {
     833                HTTPServerList httpServerList = getHTTPServerList();
     834                while (httpServerList.open(bindPort) == false) {
    797835                        retryCnt++;
    798836                        if (UPnP.SERVER_RETRY_COUNT < retryCnt) {
     
    805843                        bindPort = getHTTPPort();
    806844                }
    807                 _httpServerList.addRequestListener(this);
    808                 _httpServerList.start();
     845                httpServerList.addRequestListener(this);
     846                httpServerList.start();
    809847               
    810848                ////////////////////////////////////////
     
    812850                ////////////////////////////////////////
    813851               
    814                 SSDPNotifySocketList _ssdpNotifySocketList = getSSDPNotifySocketList();
    815                 if (_ssdpNotifySocketList.open() == false) {
     852                SSDPNotifySocketList ssdpNotifySocketList = getSSDPNotifySocketList();
     853                if (ssdpNotifySocketList.open() == false) {
    816854                        Debug.warning("Failed to open SSDP notify port 1900");
    817855                        return false;
    818856                }
    819                 _ssdpNotifySocketList.setControlPoint(this);
    820                 _ssdpNotifySocketList.start();
     857                ssdpNotifySocketList.setControlPoint(this);                     
     858                ssdpNotifySocketList.start();
    821859               
    822860                ////////////////////////////////////////
     
    824862                ////////////////////////////////////////
    825863               
    826                 int _ssdpPort = getSSDPPort();
     864                int ssdpPort = getSSDPPort();
    827865                retryCnt = 0;
    828                 SSDPSearchResponseSocketList _ssdpSearchResponseSocketList = getSSDPSearchResponseSocketList();
    829                 while (_ssdpSearchResponseSocketList.open(_ssdpPort) == false) {
     866                SSDPSearchResponseSocketList ssdpSearchResponseSocketList = getSSDPSearchResponseSocketList();
     867                while (ssdpSearchResponseSocketList.open(ssdpPort) == false) {
    830868                        retryCnt++;
    831869                        if (UPnP.SERVER_RETRY_COUNT < retryCnt) {
    832                                 Debug.warning("Failed to open SSDP search response port " + _ssdpPort);
     870                                Debug.warning("Failed to open SSDP search response port " + ssdpPort);
    833871                                return false;
    834872                        }
    835873                        // I2P go down not up so we don't run into other I2P things
    836                         setSSDPPort(_ssdpPort - 1);
    837                         _ssdpPort = getSSDPPort();
    838                 }
    839                 _ssdpSearchResponseSocketList.setControlPoint(this);
    840                 _ssdpSearchResponseSocketList.start();
     874                        setSSDPPort(ssdpPort - 1);
     875                        ssdpPort = getSSDPPort();
     876                }
     877                ssdpSearchResponseSocketList.setControlPoint(this);
     878                ssdpSearchResponseSocketList.start();
    841879
    842880                ////////////////////////////////////////
     
    881919                unsubscribe();
    882920               
    883                 SSDPNotifySocketList _ssdpNotifySocketList = getSSDPNotifySocketList();
    884                 _ssdpNotifySocketList.stop();
    885                 _ssdpNotifySocketList.close();
    886                 _ssdpNotifySocketList.clear();
    887                
    888                 SSDPSearchResponseSocketList _ssdpSearchResponseSocketList = getSSDPSearchResponseSocketList();
    889                 _ssdpSearchResponseSocketList.stop();
    890                 _ssdpSearchResponseSocketList.close();
    891                 _ssdpSearchResponseSocketList.clear();
    892 
    893                 HTTPServerList _httpServerList = getHTTPServerList();
    894                 _httpServerList.stop();
    895                 _httpServerList.close();
    896                 _httpServerList.clear();
     921                SSDPNotifySocketList ssdpNotifySocketList = getSSDPNotifySocketList();
     922                ssdpNotifySocketList.stop();
     923                ssdpNotifySocketList.close();
     924                ssdpNotifySocketList.clear();
     925               
     926                SSDPSearchResponseSocketList ssdpSearchResponseSocketList = getSSDPSearchResponseSocketList();
     927                ssdpSearchResponseSocketList.stop();
     928                ssdpSearchResponseSocketList.close();
     929                ssdpSearchResponseSocketList.clear();
     930
     931                HTTPServerList httpServerList = getHTTPServerList();
     932                httpServerList.stop();
     933                httpServerList.close();
     934                httpServerList.clear();
    897935                       
    898936                ////////////////////////////////////////
     
    925963        }
    926964
     965        ////////////////////////////////////////////////
     966        //      userData
     967        ////////////////////////////////////////////////
     968
     969        private Object userData = null;
     970       
     971        public void setUserData(Object data)
     972        {
     973                userData = data;
     974        }
     975
     976        public Object getUserData()
     977        {
     978                return userData;
     979        }
     980       
    927981        ////////////////////////////////////////////////
    928982        //      print   
  • router/java/src/org/cybergarage/upnp/Device.java

    r44edf70 r65efefb  
    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
     
    286377        public Device getRootDevice()
    287378        {
    288                 Node _rootNode = getRootNode();
    289                 if (_rootNode == null)
     379                Node rootNode = getRootNode();
     380                if (rootNode == null)
    290381                        return null;
    291                 Node devNode = _rootNode.getNode(Device.ELEM_NAME);
     382                Node devNode = rootNode.getNode(Device.ELEM_NAME);
    292383                if (devNode == null)
    293384                        return null;
    294                 return new Device(_rootNode, devNode);
     385                return new Device(rootNode, devNode);
    295386        }
    296387
     
    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

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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++) {
     
    403480                        if (Action.isActionNode(node) == false)
    404481                                continue;
    405                         Action action = new Action(_serviceNode, node);
     482                        Action action = new Action(serviceNode, node);
    406483                        actionList.add(action);
    407484                }
     
    424501        }
    425502       
     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());
     517        }
     518       
    426519        ////////////////////////////////////////////////
    427520        //      serviceStateTable
     
    434527                if (stateTableNode == null)
    435528                        return stateTable;
    436                 Node _serviceNode = getServiceNode();
     529                Node serviceNode = getServiceNode();
    437530                int nNode = stateTableNode.getNNodes();
    438531                for (int n=0; n<nNode; n++) {
     
    440533                        if (StateVariable.isStateVariableNode(node) == false)
    441534                                continue;
    442                         StateVariable serviceVar = new StateVariable(_serviceNode, node);
     535                        StateVariable serviceVar = new StateVariable(serviceNode, node);
    443536                        stateTable.add(serviceVar);
    444537                }
     
    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

    r44edf70 r65efefb  
    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
     
    4746                        obj = get(n);
    4847                }
    49                 catch (Exception e) {}
     48                catch (Exception e) {};
    5049                return (Service)obj;
    5150        }
  • router/java/src/org/cybergarage/upnp/ServiceStateTable.java

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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
     
    7075                return serviceNode;
    7176        }
     77       
     78        void setServiceNode(Node n){
     79                serviceNode=n;
     80        }
    7281
    7382        public Service getService()
    7483        {
    75                 Node _serviceNode = getServiceNode();
    76                 if (_serviceNode == null)
     84                Node serviceNode = getServiceNode();
     85                if (serviceNode == null)
    7786                        return null;
    78                 return new Service(_serviceNode);
     87                return new Service(serviceNode);
    7988        }
    8089
     
    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
     
    302365                }
    303366                else {
    304                         UPnPStatus _upnpStatus = retVar.getStatus();
    305                         queryRes.setFaultResponse(_upnpStatus.getCode(), _upnpStatus.getDescription());
     367                        UPnPStatus upnpStatus = retVar.getStatus();
     368                        queryRes.setFaultResponse(upnpStatus.getCode(), upnpStatus.getDescription());
    306369                }
    307370                queryReq.post(queryRes);
     
    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

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    7575                Service service = stateVar.getService();               
    7676               
     77                String ctrlURL = service.getControlURL();
     78
    7779                setRequestHost(service);
    7880
  • router/java/src/org/cybergarage/upnp/control/RenewSubscriber.java

    r44edf70 r65efefb  
    5252        ////////////////////////////////////////////////
    5353       
    54     @Override
    5554        public void run()
    5655        {
  • router/java/src/org/cybergarage/upnp/device/Advertiser.java

    r44edf70 r65efefb  
    5252        ////////////////////////////////////////////////
    5353       
    54     @Override
    5554        public void run()
    5655        {
  • router/java/src/org/cybergarage/upnp/device/Disposer.java

    r44edf70 r65efefb  
    5050        ////////////////////////////////////////////////
    5151       
    52     @Override
    5352        public void run()
    5453        {
  • router/java/src/org/cybergarage/upnp/device/InvalidDescriptionException.java

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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

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

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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
     
    5470        }
    5571
    56     @Override
    5772        protected void finalize()
    5873        {
     
    6681        public String getLocalAddress()
    6782        {
     83                if (ssdpMultiGroup == null || ssdpMultiIf == null)
     84                        return "";
    6885                InetAddress mcastAddr = ssdpMultiGroup.getAddress();
    6986                Enumeration addrs = ssdpMultiIf.getInetAddresses();
     
    7895        }
    7996
     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       
    80125        ////////////////////////////////////////////////
    81126        //      MulticastAddr
     
    92137        }
    93138       
    94         ////////////////////////////////////////////////
    95         //      open/close
    96         ////////////////////////////////////////////////
    97 
    98         public boolean open(String addr, int port, String bindAddr)
    99         {
     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){
    100146                try {
    101147                        ssdpMultiSock = new MulticastSocket(null);
     
    104150                        ssdpMultiSock.bind(bindSockAddr);
    105151                        ssdpMultiGroup = new InetSocketAddress(InetAddress.getByName(addr), port);
    106                         ssdpMultiIf = NetworkInterface.getByInetAddress(InetAddress.getByName(bindAddr));
     152                        ssdpMultiIf = NetworkInterface.getByInetAddress(bindAddr);
    107153                        ssdpMultiSock.joinGroup(ssdpMultiGroup, ssdpMultiIf);
    108154                }
     
    112158                }
    113159               
    114                 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                }
    115171        }
    116172
     
    121177                       
    122178                try {
    123                         // I2P close it instead of leaving group so the thread dies
    124                         //ssdpMultiSock.leaveGroup(ssdpMultiGroup, ssdpMultiIf);
    125                         ssdpMultiSock.close();
     179                        ssdpMultiSock.leaveGroup(ssdpMultiGroup, ssdpMultiIf);
     180            ssdpMultiSock.close();
    126181                        ssdpMultiSock = null;
    127182                }
     
    145200                                msock = new MulticastSocket(null);
    146201                                msock.bind(new InetSocketAddress(bindAddr, bindPort));
     202                        }else{
     203                                msock = new MulticastSocket();
    147204                        }
    148                         else
    149                                 msock = new MulticastSocket();
    150205                        DatagramPacket dgmPacket = new DatagramPacket(msg.getBytes(), msg.length(), ssdpMultiGroup);
    151                         // Thnaks for Tho Beisch (11/09/04)
    152                         msock.setTimeToLive(4);
     206                        // Thnaks for Theo Beisch (11/09/04)
     207                        msock.setTimeToLive(UPnP.getTimeToLive());
    153208                        msock.send(dgmPacket);
    154209                        msock.close();
     
    184239        ////////////////////////////////////////////////
    185240
    186         public SSDPPacket receive()
     241        public SSDPPacket receive() throws IOException
    187242        {
    188243                byte ssdvRecvBuf[] = new byte[SSDP.RECV_MESSAGE_BUFSIZE];
    189244                SSDPPacket recvPacket = new SSDPPacket(ssdvRecvBuf, ssdvRecvBuf.length);
    190245                recvPacket.setLocalAddress(getLocalAddress());
    191                 try {
    192                         ssdpMultiSock.receive(recvPacket.getDatagramPacket());
    193                         recvPacket.setTimeStamp(System.currentTimeMillis());
    194                         Debug.message("Received SSDP multicast packet on " + getLocalAddress() + " from " + recvPacket.getRemoteAddress());
    195                 }
    196                 catch (Exception e) {
    197                         //Debug.warning(e);
    198                 }
    199                 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;
    200257        }
    201258}
  • router/java/src/org/cybergarage/upnp/ssdp/HTTPUSocket.java

    r44edf70 r65efefb  
    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
     
    6164        }
    6265
    63     @Override
    6466        protected void finalize()
    6567        {
     
    7779                localAddr = addr;
    7880        }
     81
     82        /**
     83         *
     84         * @return {@link DatagramSocket} open for receieving packets
     85         * @since 1.8
     86         */
     87        public DatagramSocket getUDPSocket(){
     88                return ssdpUniSock;
     89        }       
    7990       
    8091        public String getLocalAddress()
     
    109120               
    110121                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 {
    111133                        // Bind only using the port without the interface address. (2003/12/12)
    112                         InetSocketAddress bindSock = new InetSocketAddress(/*InetAddress.getByName(bindAddr), */ bindPort);
     134                        InetSocketAddress bindInetAddr = new InetSocketAddress(bindPort);
    113135                        ssdpUniSock = new DatagramSocket(null);
    114136                        ssdpUniSock.setReuseAddress(true);
    115                         ssdpUniSock.bind(bindSock);
    116                 }
    117                 catch (Exception e) {
    118                         Debug.warning(e);
    119                         return false;
    120                 }
     137                        ssdpUniSock.bind(bindInetAddr);
     138                        return true;
     139                }
     140                catch (Exception e) {
     141                        Debug.warning(e);
     142                        return false;
     143                }
     144                */
    121145               
    122146                setLocalAddress(bindAddr);
  • router/java/src/org/cybergarage/upnp/ssdp/SSDP.java

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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.*;
     36import org.cybergarage.util.*;
    3037import org.cybergarage.http.*;
    3138import org.cybergarage.upnp.*;
    3239import org.cybergarage.util.Debug;
    3340
     41/**
     42 *
     43 * This class identifies a SSDP socket only for <b>notifing packet</b>.<br>
     44 *
     45 * @author Satoshi "skonno" Konno
     46 * @author Stefano "Kismet" Lenzi
     47 * @version 1.8
     48 *
     49 */
    3450public class SSDPNotifySocket extends HTTPMUSocket implements Runnable
    3551{
     
    6985        }
    7086
    71         ////////////////////////////////////////////////
    72         //      post (SSDPNotifySocket)
    73         ////////////////////////////////////////////////
    74 
     87        /**
     88         * This method send a {@link SSDPNotifyRequest} over {@link SSDPNotifySocket}
     89         *
     90         * @param req the {@link SSDPNotifyRequest} to send
     91         * @return true if and only if the trasmission succeced<br>
     92         *      Because it rely on UDP doesn't mean that it's also recieved
     93         */
    7594        public boolean post(SSDPNotifyRequest req)
    7695        {
     
    96115                while (deviceNotifyThread == thisThread) {
    97116                        Thread.yield();
    98                         SSDPPacket packet = receive();
     117
     118                        // Thanks for Kazuyuki Shudo (08/23/07)
     119                        SSDPPacket packet = null;
     120                        try {
     121                                packet = receive();
     122                        }
     123                        catch (IOException e) {
     124                                break;
     125                        }
    99126                       
    100127                        // Thanks for Mikael Hakman (04/20/05)
     
    110137                                continue;
    111138                        }
    112                                                                                                
     139                        //TODO Must be performed on a different Thread in order to prevent UDP packet losses.
    113140                        if (ctrlPoint != null)
    114141                                ctrlPoint.notifyReceived(packet);
     
    116143        }
    117144       
    118         public void start()
    119         {
    120                 deviceNotifyThread = new Thread(this, "UPnP-SSDPNotifySocket");
    121                 deviceNotifyThread.setDaemon(true);
     145        public void start(){
     146                StringBuffer name = new StringBuffer("Cyber.SSDPNotifySocket/");
     147                String localAddr = this.getLocalAddress();
     148                // localAddr is null on Android m3-rc37a (01/30/08)
     149                if (localAddr != null && 0 < localAddr.length()) {
     150                        name.append(this.getLocalAddress()).append(':');
     151                        name.append(this.getLocalPort()).append(" -> ");
     152                        name.append(this.getMulticastAddress()).append(':');
     153                        name.append(this.getMulticastPort());
     154                }
     155                deviceNotifyThread = new Thread(this,name.toString());
    122156                deviceNotifyThread.start();
    123157        }
  • router/java/src/org/cybergarage/upnp/ssdp/SSDPNotifySocketList.java

    r44edf70 r65efefb  
    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/SSDPPacket.java

    r44edf70 r65efefb  
    236236        ////////////////////////////////////////////////
    237237
    238     @Override
    239238        public String toString()
    240239        {
  • router/java/src/org/cybergarage/upnp/ssdp/SSDPRequest.java

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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)
     
    113120        ////////////////////////////////////////////////
    114121       
    115     @Override
    116122        public String getHeader()
    117123        {
    118                 StringBuilder str = new StringBuilder();
     124                StringBuffer str = new StringBuffer();
    119125       
    120126                str.append(getStatusLineString());
  • router/java/src/org/cybergarage/upnp/ssdp/SSDPSearchResponseSocket.java

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    1818package org.cybergarage.upnp.ssdp;
    1919
     20import java.net.InetAddress;
    2021import java.util.*;
    2122
     
    2324
    2425import org.cybergarage.upnp.*;
    25 import org.cybergarage.util.Debug;
    2626
    2727public class SSDPSearchResponseSocketList extends Vector
     
    3131        ////////////////////////////////////////////////
    3232       
    33         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        }
    3444
    35         public SSDPSearchResponseSocketList()
    36         {
    37         }
     45       
     46       
     47        ////////////////////////////////////////////////
     48        //      ControlPoint
    3849
    3950        ////////////////////////////////////////////////
     
    6374        ////////////////////////////////////////////////
    6475       
    65         public boolean open(int port)
    66         {
     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                }               
    6791                try {
    68                         int nHostAddrs = HostInterface.getNHostAddresses();
    69                         for (int n=0; n<nHostAddrs; n++) {
    70                                 String bindAddr = HostInterface.getHostAddress(n);
    71                                 SSDPSearchResponseSocket socket = new SSDPSearchResponseSocket(bindAddr, port);
    72                                 Debug.message("Opened SSDP search response socket at " + bindAddr + ':' + port);
     92                        for (int j = 0; j < bindAddresses.length; j++) {                               
     93                                SSDPSearchResponseSocket socket = new SSDPSearchResponseSocket(bindAddresses[j], port);
    7394                                add(socket);
    7495                        }
    75                 }
    76                 catch (Exception e) {
     96                }catch (Exception e) {
    7797                        stop();
    7898                        close();
  • router/java/src/org/cybergarage/upnp/ssdp/SSDPSearchSocket.java

    r44edf70 r65efefb  
    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);
    40                 Debug.message("Opened SSDP search socket at " + bindAddr + ':' + SSDP.PORT);
     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                }
    4172        }
    4273
     
    4475        //      Constructor
    4576        ////////////////////////////////////////////////
     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        }
    4697
     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         */
    47104        public boolean open(String bindAddr)
    48105        {
    49106                String addr = SSDP.ADDRESS;
     107                useIPv6Address = false;
    50108                if (HostInterface.isIPv6Address(bindAddr) == true) {
    51109                        addr = SSDP.getIPv6Address();
     110                        useIPv6Address = true;
    52111                }
    53112                return open(addr, SSDP.PORT, bindAddr);
     
    91150                while (deviceSearchThread == thisThread) {
    92151                        Thread.yield();
    93                         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                        }
    94161                       
    95162                        // Thanks for Mikael Hakman (04/20/05)
     
    97164                                continue;
    98165                               
     166                        //TODO perform delegation with Thread Pooling
    99167                        if (packet.isDiscover() == true)
    100168                                performSearchListener(packet);
     
    102170        }
    103171       
    104         public void start()
    105         {
    106                 deviceSearchThread = new Thread(this,"UPnP-SSDPSearchSocket");
    107                 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());
    108183                deviceSearchThread.start();
    109184        }
  • router/java/src/org/cybergarage/upnp/ssdp/SSDPSearchSocketList.java

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    1616package org.cybergarage.util;
    1717
    18 import java.io.*;
     18import java.io.ByteArrayOutputStream;
     19import java.io.File;
     20import java.io.FileInputStream;
    1921import java.util.Locale;
    2022
  • router/java/src/org/cybergarage/util/ListenerList.java

    r44edf70 r65efefb  
    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 
    24     @Override
    2522        public boolean add(Object obj)
    2623        {
  • router/java/src/org/cybergarage/util/Mutex.java

    r44edf70 r65efefb  
    4141                        catch (Exception e) {
    4242                                Debug.warning(e);
    43                         }
     43                        };
    4444                }
    4545                syncLock = true;
  • router/java/src/org/cybergarage/util/ThreadCore.java

    r44edf70 r65efefb  
    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                        // I2P break Disposer out of sleep()
  • router/java/src/org/cybergarage/xml/AttributeList.java

    r44edf70 r65efefb  
    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

    r44edf70 r65efefb  
    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;
    77                 Node _parentNode = getParentNode();
    78                 while (_parentNode != null) {
    79                          rootNode = _parentNode;
    80                          _parentNode = rootNode.getParentNode();
     87                Node parentNode = getParentNode();
     88                while (parentNode != null) {
     89                         rootNode = parentNode;
     90                         parentNode = rootNode.getParentNode();
    8191                }
    8292                return rootNode;
     
    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