zzz/i2p.i2p
1
0
Fork 0
forked from I2P_Developers/i2p.i2p
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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

Browse Source 
to branch 'i2p.i2p.zzz.upnp' (head d28cfe73c2741ea264f73a7317f8a9919e108170)
This commit is contained in:
zzz
2012-08-14 13:50:15 +00:00
parent 44edf70842 df00725077
commit 65efefb094
73 changed files with 4446 additions and 2600 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
router/java/src/org/cybergarage/http/Date.java
View File

@@ -1,8 +1,8 @@
/******************************************************************
*
* CyberHTTP for Java
*
* Copyright (C) Satoshi Konno 2002-2003
* CyberHTTP for Java
*
* Copyright (C) Satoshi Konno 2002-2003
*
* File : Date.java
*
@@ -16,7 +16,7 @@
* getHour(), getDateString() getTimeString()
* - Fixed getInstance() to return GMT instance.
*
******************************************************************/
******************************************************************/
package org.cybergarage.http;
@@ -136,15 +136,15 @@ public class Date
public String getDateString()
{
// Thanks for Theo Beisch (10/20/04)
Calendar _cal = getCalendar();
Calendar cal = getCalendar();
return
toWeekString(_cal.get(Calendar.DAY_OF_WEEK)) +", " +
toTimeString(_cal.get(Calendar.DATE)) + " " +
toMonthString(_cal.get(Calendar.MONTH)) + " " +
Integer.toString(_cal.get(Calendar.YEAR)) + " " +
toTimeString(_cal.get(Calendar.HOUR_OF_DAY)) + ":" +
toTimeString(_cal.get(Calendar.MINUTE)) + ":" +
toTimeString(_cal.get(Calendar.SECOND)) + " GMT";
toWeekString(cal.get(Calendar.DAY_OF_WEEK)) +", " +
toTimeString(cal.get(Calendar.DATE)) + " " +
toMonthString(cal.get(Calendar.MONTH)) + " " +
Integer.toString(cal.get(Calendar.YEAR)) + " " +
toTimeString(cal.get(Calendar.HOUR_OF_DAY)) + ":" +
toTimeString(cal.get(Calendar.MINUTE)) + ":" +
toTimeString(cal.get(Calendar.SECOND)) + " GMT";
}
////////////////////////////////////////////////
@@ -154,11 +154,11 @@ public class Date
public String getTimeString()
{
// Thanks for Theo Beisch (10/20/04)
Calendar _cal = getCalendar();
Calendar cal = getCalendar();
return
toDateString(_cal.get(Calendar.HOUR_OF_DAY)) +
(((_cal.get(Calendar.SECOND) % 2) == 0) ? ":" : " ") +
toDateString(_cal.get(Calendar.MINUTE));
toDateString(cal.get(Calendar.HOUR_OF_DAY)) +
(((cal.get(Calendar.SECOND) % 2) == 0) ? ":" : " ") +
toDateString(cal.get(Calendar.MINUTE));
}
}

15
router/java/src/org/cybergarage/http/HTTP.java
View File

@@ -30,7 +30,7 @@
package org.cybergarage.http;
import java.net.*;
import java.net.URL;
public class HTTP
{
@@ -45,6 +45,8 @@ public class HTTP
public static final String VERSION_11 = "1.1";
public static final String CRLF = "\r\n";
public static final byte CR = '\r';
public static final byte LF = '\n';
public static final String TAB = "\t";
public static final String SOAP_ACTION = "SOAPACTION";
@@ -59,19 +61,20 @@ public class HTTP
public static final String DATE = "Date";
public static final String CACHE_CONTROL = "Cache-Control";
public static final String NO_CACHE = "no-cache";
public static final String MAX_AGE = "max-age";
public static final String NO_CACHE = "no-cache";
public static final String MAX_AGE = "max-age";
public static final String CONNECTION = "Connection";
public static final String CLOSE = "close";
public static final String CLOSE = "close";
public static final String KEEP_ALIVE = "Keep-Alive";
public static final String CONTENT_TYPE = "Content-Type";
public static final String CHARSET = "charset";
public static final String CONTENT_LENGTH = "Content-Length";
public static final String CONTENT_RANGE = "Content-Range";
public static final String CONTENT_RANGE_BYTES = "bytes";
public static final String CONTENT_RANGE_BYTES = "bytes";
// Thanks for Brent Hills (10/20/04)
public static final String RANGE = "Range";
public static final String TRANSFER_ENCODING = "Transfer-Encoding";
public static final String CHUNKED = "Chunked";
public static final String CHUNKED = "Chunked";
public static final String LOCATION = "Location";
public static final String SERVER = "Server";

182
router/java/src/org/cybergarage/http/HTTPHeader.java
View File

@@ -5,34 +5,37 @@
* Copyright (C) Satoshi Konno 2002
*
* File: HTTPHeader.java
*
* Revision;
*
* 11/19/02
* - first revision.
*
* Revision;
*
* 11/19/02
* - first revision.
* 05/26/04
* - Jan Newmarch <jan.newmarch@infotech.monash.edu.au> (05/26/04)
* - Fixed getValue() to compare using String::equals() instead of String::startWidth().
*
******************************************************************/
package org.cybergarage.http;
import java.io.*;
import java.io.IOException;
import java.io.LineNumberReader;
import java.io.StringReader;
import java.util.Locale;
import org.cybergarage.util.*;
public class HTTPHeader
import org.cybergarage.util.Debug;
public class HTTPHeader
{
private String name;
private String value;
public HTTPHeader(String name, String value)
{
setName(name);
setValue(value);
}
private static int MAX_LENGTH = 1024;
private String name;
private String value;
public HTTPHeader(String name, String value)
{
setName(name);
setValue(value);
}
public HTTPHeader(String lineStr)
{
@@ -43,35 +46,35 @@ public class HTTPHeader
int colonIdx = lineStr.indexOf(':');
if (colonIdx < 0)
return;
String _name = new String(lineStr.getBytes(), 0, colonIdx);
String _value = new String(lineStr.getBytes(), colonIdx+1, lineStr.length()-colonIdx-1);
setName(_name.trim());
setValue(_value.trim());
String name = new String(lineStr.getBytes(), 0, colonIdx);
String value = new String(lineStr.getBytes(), colonIdx+1, lineStr.length()-colonIdx-1);
setName(name.trim());
setValue(value.trim());
}
////////////////////////////////////////////////
// Member
////////////////////////////////////////////////
public void setName(String name)
{
this.name = name;
}
public void setValue(String value)
{
this.value = value;
}
public String getName()
{
return name;
}
public String getValue()
{
return value;
}
public void setName(String name)
{
this.name = name;
}
public void setValue(String value)
{
this.value = value;
}
public String getName()
{
return name;
}
public String getValue()
{
return value;
}
public boolean hasName()
{
@@ -79,67 +82,68 @@ public class HTTPHeader
return false;
return true;
}
////////////////////////////////////////////////
// static methods
////////////////////////////////////////////////
public final static String getValue(LineNumberReader reader, String name)
{
String bigName = name.toUpperCase(Locale.US);
try {
String lineStr = reader.readLine();
while (lineStr != null && 0 < lineStr.length()) {
////////////////////////////////////////////////
// static methods
////////////////////////////////////////////////
public final static String getValue(LineNumberReader reader, String name)
{
String bigName = name.toUpperCase(Locale.US);
try {
String lineStr = reader.readLine();
while (lineStr != null && 0 < lineStr.length()) {
HTTPHeader header = new HTTPHeader(lineStr);
if (header.hasName() == false) {
lineStr = reader.readLine();
continue;
}
if (header.hasName() == false) {
lineStr = reader.readLine();
continue;
}
String bigLineHeaderName = header.getName().toUpperCase(Locale.US);
// Thanks for Jan Newmarch <jan.newmarch@infotech.monash.edu.au> (05/26/04)
if (bigLineHeaderName.equals(bigName) == false) {
lineStr = reader.readLine();
continue;
}
return header.getValue();
}
}
// Thanks for Jan Newmarch <jan.newmarch@infotech.monash.edu.au> (05/26/04)
if (bigLineHeaderName.equals(bigName) == false) {
lineStr = reader.readLine();
continue;
}
return header.getValue();
}
}
catch (IOException e) {
Debug.warning(e);
return "";
}
return "";
}
public final static String getValue(String data, String name)
Debug.warning(e);
return "";
}
return "";
}
public final static String getValue(String data, String name)
{
/* Thanks for Stephan Mehlhase (2010-10-26) */
StringReader strReader = new StringReader(data);
LineNumberReader lineReader = new LineNumberReader(strReader);
return getValue(lineReader, name);
}
public final static String getValue(byte[] data, String name)
{
return getValue(new String(data), name);
}
public final static int getIntegerValue(String data, String name)
LineNumberReader lineReader = new LineNumberReader(strReader, Math.min(data.length(), MAX_LENGTH));
return getValue(lineReader, name);
}
public final static String getValue(byte[] data, String name)
{
return getValue(new String(data), name);
}
public final static int getIntegerValue(String data, String name)
{
try {
return Integer.parseInt(getValue(data, name));
}
catch (Exception e) {
return 0;
}
}
public final static int getIntegerValue(byte[] data, String name)
{
}
}
public final static int getIntegerValue(byte[] data, String name)
{
try {
return Integer.parseInt(getValue(data, name));
}
catch (Exception e) {
return 0;
}
}
}
}

155
router/java/src/org/cybergarage/http/HTTPPacket.java
View File

@@ -59,17 +59,35 @@
* hasTransferEncoding(), setTransferEncoding(), getTransferEncoding(), isChunked().
* 03/02/05
* - Changed post() to suppot chunked stream.
* 06/11/05
* - Added setHost().
* 07/07/05
* - Lee Peik Feng <pflee@users.sourceforge.net>
* - Andrey Ovchar <AOvchar@consultitnow.com>
* - Fixed set() to parse the chunk size as a hex string.
* 11/02/05
* - Changed set() to use BufferedInputStream instead of BufferedReader to
* get the content as a byte stream.
* 11/06/05
* - Added getCharSet().
* - Changed getContentString() to return the content string using the charset.
*
*******************************************************************/
package org.cybergarage.http;
import java.io.*;
import java.util.*;
import org.cybergarage.net.*;
import org.cybergarage.util.*;
import java.io.BufferedInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InterruptedIOException;
import java.util.Calendar;
import java.util.StringTokenizer;
import java.util.Vector;
import org.cybergarage.net.HostInterface;
import org.cybergarage.util.Debug;
import org.cybergarage.util.StringUtil;
public class HTTPPacket
{
@@ -129,18 +147,44 @@ public class HTTPPacket
// set
////////////////////////////////////////////////
private String readLine(BufferedInputStream in)
{
ByteArrayOutputStream lineBuf = new ByteArrayOutputStream();
byte readBuf[] = new byte[1];
try {
int readLen = in.read(readBuf);
while (0 < readLen) {
if (readBuf[0] == HTTP.LF)
break;
if (readBuf[0] != HTTP.CR)
lineBuf.write(readBuf[0]);
readLen = in.read(readBuf);
}
}
catch (InterruptedIOException e) {
//Ignoring warning because it's a way to break the HTTP connecttion
//TODO Create a new level of Logging and log the event
}
catch (IOException e) {
Debug.warning(e);
}
return lineBuf.toString();
}
protected boolean set(InputStream in, boolean onlyHeaders)
{
try {
BufferedReader reader = new BufferedReader(new InputStreamReader(in));
BufferedInputStream reader = new BufferedInputStream(in);
String _firstLine = reader.readLine();
if (_firstLine == null || _firstLine.length() <= 0)
String firstLine = readLine(reader);
if (firstLine == null || firstLine.length() <= 0)
return false;
setFirstLine(_firstLine);
setFirstLine(firstLine);
// Thanks for Giordano Sassaroli <sassarol@cefriel.it> (09/03/03)
HTTPStatus httpStatus = new HTTPStatus(_firstLine);
HTTPStatus httpStatus = new HTTPStatus(firstLine);
int statCode = httpStatus.getStatusCode();
if (statCode == HTTPStatus.CONTINUE){
//ad hoc code for managing iis non-standard behaviour
@@ -148,15 +192,15 @@ public class HTTPPacket
//stream, so the code should check the presence of the actual
//response in the stream.
//skip all header lines
String headerLine = reader.readLine();
String headerLine = readLine(reader);
while ((headerLine != null) && (0 < headerLine.length()) ) {
HTTPHeader header = new HTTPHeader(headerLine);
if (header.hasName() == true)
setHeader(header);
headerLine = reader.readLine();
headerLine = readLine(reader);
}
//look forward another first line
String actualFirstLine = reader.readLine();
String actualFirstLine = readLine(reader);
if ((actualFirstLine != null) && (0 < actualFirstLine.length()) ) {
//this is the actual first line
setFirstLine(actualFirstLine);
@@ -165,12 +209,12 @@ public class HTTPPacket
}
}
String headerLine = reader.readLine();
String headerLine = readLine(reader);
while ((headerLine != null) && (0 < headerLine.length()) ) {
HTTPHeader header = new HTTPHeader(headerLine);
if (header.hasName() == true)
setHeader(header);
headerLine = reader.readLine();
headerLine = readLine(reader);
}
if (onlyHeaders == true) {
@@ -183,19 +227,24 @@ public class HTTPPacket
long contentLen = 0;
if (isChunkedRequest == true) {
try {
String chunkSizeLine = reader.readLine();
contentLen = Long.parseLong(new String(chunkSizeLine.getBytes(), 0, chunkSizeLine.length()-2));
String chunkSizeLine = readLine(reader);
// Thanks for Lee Peik Feng <pflee@users.sourceforge.net> (07/07/05)
//contentLen = Long.parseLong(new String(chunkSizeLine.getBytes(), 0, chunkSizeLine.length()-2), 16);
contentLen = (chunkSizeLine != null) ? Long.parseLong(chunkSizeLine.trim(), 16) : 0;
}
catch (Exception e) {}
catch (Exception e) {};
}
else
contentLen = getContentLength();
StringBuilder contentBuf = new StringBuilder();
ByteArrayOutputStream contentBuf = new ByteArrayOutputStream();
while (0 < contentLen) {
int chunkSize = HTTP.getChunkSize();
char readBuf[] = new char[chunkSize];
/* Thanks for Stephan Mehlhase (2010-10-26) */
byte readBuf[] = new byte[(int) (contentLen > chunkSize ? chunkSize : contentLen)];
long readCnt = 0;
while (readCnt < contentLen) {
try {
@@ -206,7 +255,7 @@ public class HTTPPacket
int readLen = reader.read(readBuf, 0, (int)bufReadLen);
if (readLen < 0)
break;
contentBuf.append(new String(readBuf, 0, readLen));
contentBuf.write(readBuf, 0, readLen);
readCnt += readLen;
}
catch (Exception e)
@@ -226,20 +275,19 @@ public class HTTPPacket
} while (skipLen < HTTP.CRLF.length());
// read next chunk size
try {
String chunkSizeLine = reader.readLine();
contentLen = Long.parseLong(new String(chunkSizeLine.getBytes(), 0, chunkSizeLine.length()-2));
String chunkSizeLine = readLine(reader);
// Thanks for Lee Peik Feng <pflee@users.sourceforge.net> (07/07/05)
contentLen = Long.parseLong(new String(chunkSizeLine.getBytes(), 0, chunkSizeLine.length()-2), 16);
}
catch (Exception e) {
contentLen = 0;
}
};
}
else
contentLen = 0;
}
// Thanks for Ralf G. R. Bergs (02/09/04)
String contentStr = contentBuf.toString();
setContent(contentStr.getBytes(), false);
setContent(contentBuf.toByteArray(), false);
}
catch (Exception e) {
Debug.warning(e);
@@ -464,7 +512,7 @@ public class HTTPPacket
public String getHeaderString()
{
StringBuilder str = new StringBuilder();
StringBuffer str = new StringBuffer();
int nHeaders = getNHeaders();
for (int n=0; n<nHeaders; n++) {
@@ -510,6 +558,15 @@ public class HTTPPacket
public String getContentString()
{
String charSet = getCharSet();
if (charSet == null || charSet.length() <= 0)
return new String(content);
try {
return new String(content, charSet);
}
catch (Exception e) {
Debug.warning(e);
}
return new String(content);
}
@@ -553,6 +610,32 @@ public class HTTPPacket
return getHeaderValue(HTTP.CONTENT_TYPE);
}
////////////////////////////////////////////////
// Charset
////////////////////////////////////////////////
public String getCharSet()
{
String contentType = getContentType();
if (contentType == null)
return "";
contentType = contentType.toLowerCase();
int charSetIdx = contentType.indexOf(HTTP.CHARSET);
if (charSetIdx < 0)
return "";
int charSetEndIdx = charSetIdx + HTTP.CHARSET.length() + 1;
String charSet = new String(contentType.getBytes(), charSetEndIdx, (contentType.length() - charSetEndIdx));
if (charSet.length() < 0)
return "";
if (charSet.charAt(0) == '\"')
charSet = charSet.substring(1, (charSet.length() - 1));
if (charSet.length() < 0)
return "";
if (charSet.charAt((charSet.length()-1)) == '\"')
charSet = charSet.substring(0, (charSet.length() - 1));
return charSet;
}
////////////////////////////////////////////////
// ContentLength
////////////////////////////////////////////////
@@ -642,7 +725,7 @@ public class HTTPPacket
// Skip bytes
if (strToken.hasMoreTokens() == false)
return range;
strToken.nextToken(" ");
String bytesStr = strToken.nextToken(" ");
// Get first-byte-pos
if (strToken.hasMoreTokens() == false)
return range;
@@ -650,21 +733,21 @@ public class HTTPPacket
try {
range[0] = Long.parseLong(firstPosStr);
}
catch (NumberFormatException e) {}
catch (NumberFormatException e) {};
if (strToken.hasMoreTokens() == false)
return range;
String lastPosStr = strToken.nextToken("-/");
try {
range[1] = Long.parseLong(lastPosStr);
}
catch (NumberFormatException e) {}
catch (NumberFormatException e) {};
if (strToken.hasMoreTokens() == false)
return range;
String lengthStr = strToken.nextToken("/");
try {
range[2] = Long.parseLong(lengthStr);
}
catch (NumberFormatException e) {}
catch (NumberFormatException e) {};
return range;
}
@@ -737,6 +820,14 @@ public class HTTPPacket
setHeader(HTTP.HOST, hostAddr + ":" + Integer.toString(port));
}
public void setHost(String host)
{
String hostAddr = host;
if (HostInterface.isIPv6Address(host) == true)
hostAddr = "[" + host + "]";
setHeader(HTTP.HOST, hostAddr);
}
public String getHost()
{
return getHeaderValue(HTTP.HOST);

317
router/java/src/org/cybergarage/http/HTTPRequest.java
View File

@@ -5,11 +5,11 @@
* Copyright (C) Satoshi Konno 2002-2004
*
* File: HTTPRequest.java
*
* Revision;
*
* 11/18/02
* - first revision.
*
* Revision;
*
* 11/18/02
* - first revision.
* 05/23/03
* - Giordano Sassaroli <sassarol@cefriel.it>
* - Add a relative URL check to setURI().
@@ -44,26 +44,46 @@
* - Added to check the range of Content-Range request in post().
* 03/02/05
* - Changed post() to suppot chunked stream.
* 06/10/05
* - Changed post() to add a HOST headedr before the posting.
* 07/07/05
* - Lee Peik Feng <pflee@users.sourceforge.net>
* - Fixed post() to output the chunk size as a hex string.
*
******************************************************************/
package org.cybergarage.http;
import java.io.*;
import java.net.*;
import java.util.*;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.net.SocketAddress;
import java.net.SocketException;
import java.net.InetSocketAddress;
import java.util.StringTokenizer;
import org.cybergarage.util.Debug;
public class HTTPRequest extends HTTPPacket
{
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public HTTPRequest()
{
}
/**
*
* This class rappresnet an HTTP <b>request</b>, and act as HTTP client when it sends the request<br>
*
* @author Satoshi "skonno" Konno
* @author Stefano "Kismet" Lenzi
* @version 1.8
*
*/
public class HTTPRequest extends HTTPPacket
{
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public HTTPRequest()
{
setVersion(HTTP.VERSION_10);
}
public HTTPRequest(InputStream in)
{
@@ -76,23 +96,23 @@ public class HTTPRequest extends HTTPPacket
setSocket(httpSock);
}
////////////////////////////////////////////////
// Method
////////////////////////////////////////////////
private String method = null;
public void setMethod(String value)
////////////////////////////////////////////////
// Method
////////////////////////////////////////////////
private String method = null;
public void setMethod(String value)
{
method = value;
}
public String getMethod()
{
method = value;
}
public String getMethod()
{
if (method != null)
if (method != null)
return method;
return getFirstLineToken(0);
}
return getFirstLineToken(0);
}
public boolean isMethod(String method)
{
@@ -101,16 +121,16 @@ public class HTTPRequest extends HTTPPacket
return false;
return headerMethod.equalsIgnoreCase(method);
}
public boolean isGetRequest()
{
return isMethod(HTTP.GET);
}
public boolean isPostRequest()
public boolean isGetRequest()
{
return isMethod(HTTP.GET);
}
public boolean isPostRequest()
{
return isMethod(HTTP.POST);
}
}
public boolean isHeadRequest()
{
@@ -132,33 +152,33 @@ public class HTTPRequest extends HTTPPacket
return isMethod(HTTP.NOTIFY);
}
////////////////////////////////////////////////
// URI
////////////////////////////////////////////////
private String uri = null;
public void setURI(String value, boolean isCheckRelativeURL)
{
////////////////////////////////////////////////
// URI
////////////////////////////////////////////////
private String uri = null;
public void setURI(String value, boolean isCheckRelativeURL)
{
uri = value;
if (isCheckRelativeURL == false)
return;
// Thanks for Giordano Sassaroli <sassarol@cefriel.it> (09/02/03)
uri = HTTP.toRelativeURL(uri);
}
}
public void setURI(String value)
{
setURI(value, false);
}
public String getURI()
public String getURI()
{
if (uri != null)
return uri;
if (uri != null)
return uri;
return getFirstLineToken(1);
}
}
////////////////////////////////////////////////
// URI Parameter
////////////////////////////////////////////////
@@ -166,17 +186,17 @@ public class HTTPRequest extends HTTPPacket
public ParameterList getParameterList()
{
ParameterList paramList = new ParameterList();
String _uri = getURI();
if (_uri == null)
String uri = getURI();
if (uri == null)
return paramList;
int paramIdx = _uri.indexOf('?');
int paramIdx = uri.indexOf('?');
if (paramIdx < 0)
return paramList;
while (0 < paramIdx) {
int eqIdx = _uri.indexOf('=', (paramIdx+1));
String name = _uri.substring(paramIdx+1, eqIdx);
int nextParamIdx = _uri.indexOf('&', (eqIdx+1));
String value = _uri.substring(eqIdx+1, (0 < nextParamIdx) ? nextParamIdx : _uri.length());
int eqIdx = uri.indexOf('=', (paramIdx+1));
String name = uri.substring(paramIdx+1, eqIdx);
int nextParamIdx = uri.indexOf('&', (eqIdx+1));
String value = uri.substring(eqIdx+1, (0 < nextParamIdx) ? nextParamIdx : uri.length());
Parameter param = new Parameter(name, value);
paramList.add(param);
paramIdx = nextParamIdx;
@@ -227,21 +247,21 @@ public class HTTPRequest extends HTTPPacket
return requestPort;
}
////////////////////////////////////////////////
// Socket
////////////////////////////////////////////////
private HTTPSocket httpSocket = null;
public void setSocket(HTTPSocket value)
{
httpSocket = value;
}
public HTTPSocket getSocket()
{
return httpSocket;
}
////////////////////////////////////////////////
// Socket
////////////////////////////////////////////////
private HTTPSocket httpSocket = null;
public void setSocket(HTTPSocket value)
{
httpSocket = value;
}
public HTTPSocket getSocket()
{
return httpSocket;
}
/////////////////////////// /////////////////////
// local address/port
@@ -256,25 +276,25 @@ public class HTTPRequest extends HTTPPacket
{
return getSocket().getLocalPort();
}
////////////////////////////////////////////////
// parseRequest
////////////////////////////////////////////////
public boolean parseRequestLine(String lineStr)
{
StringTokenizer st = new StringTokenizer(lineStr, HTTP.REQEST_LINE_DELIM);
if (st.hasMoreTokens() == false)
return false;
setMethod(st.nextToken());
if (st.hasMoreTokens() == false)
return false;
setURI(st.nextToken());
if (st.hasMoreTokens() == false)
return false;
setVersion(st.nextToken());
return true;
}
////////////////////////////////////////////////
// parseRequest
////////////////////////////////////////////////
public boolean parseRequestLine(String lineStr)
{
StringTokenizer st = new StringTokenizer(lineStr, HTTP.REQEST_LINE_DELIM);
if (st.hasMoreTokens() == false)
return false;
setMethod(st.nextToken());
if (st.hasMoreTokens() == false)
return false;
setURI(st.nextToken());
if (st.hasMoreTokens() == false)
return false;
setVersion(st.nextToken());
return true;
}
////////////////////////////////////////////////
// First Line
@@ -292,22 +312,22 @@ public class HTTPRequest extends HTTPPacket
return getMethod() + " " + getURI() + " " + getHTTPVersion() + HTTP.CRLF;
}
////////////////////////////////////////////////
// getHeader
////////////////////////////////////////////////
public String getHeader()
{
StringBuilder str = new StringBuilder();
str.append(getFirstLineString());
////////////////////////////////////////////////
// getHeader
////////////////////////////////////////////////
public String getHeader()
{
StringBuffer str = new StringBuffer();
str.append(getFirstLineString());
String headerString = getHeaderString();
str.append(headerString);
return str.toString();
}
return str.toString();
}
////////////////////////////////////////////////
// isKeepAlive
////////////////////////////////////////////////
@@ -334,9 +354,9 @@ public class HTTPRequest extends HTTPPacket
return super.read(getSocket());
}
////////////////////////////////////////////////
// POST (Response)
////////////////////////////////////////////////
////////////////////////////////////////////////
// POST (Response)
////////////////////////////////////////////////
public boolean post(HTTPResponse httpRes)
{
@@ -361,17 +381,19 @@ public class HTTPRequest extends HTTPPacket
return httpSock.post(httpRes, offset, length, isHeadRequest());
//httpSock.close();
}
////////////////////////////////////////////////
// POST (Request)
////////////////////////////////////////////////
private Socket postSocket = null;
public HTTPResponse post(String host, int port, boolean isKeepAlive)
{
public HTTPResponse post(String host, int port, boolean isKeepAlive)
{
HTTPResponse httpRes = new HTTPResponse();
setHost(host);
setConnection((isKeepAlive == true) ? HTTP.KEEP_ALIVE : HTTP.CLOSE);
boolean isHeaderRequest = isHeadRequest();
@@ -396,9 +418,9 @@ public class HTTPRequest extends HTTPPacket
postSocket.connect(sa, 3000);
}
out = postSocket.getOutputStream();
PrintStream pout = new PrintStream(out);
pout.print(getHeader());
out = postSocket.getOutputStream();
PrintStream pout = new PrintStream(out);
pout.print(getHeader());
pout.print(HTTP.CRLF);
boolean isChunkedRequest = isChunked();
@@ -407,10 +429,11 @@ public class HTTPRequest extends HTTPPacket
int contentLength = 0;
if (content != null)
contentLength = content.length();
if (0 < contentLength) {
if (isChunkedRequest == true) {
String chunSizeBuf = Long.toString(contentLength);
// Thanks for Lee Peik Feng <pflee@users.sourceforge.net> (07/07/05)
String chunSizeBuf = Long.toHexString(contentLength);
pout.print(chunSizeBuf);
pout.print(HTTP.CRLF);
}
@@ -424,34 +447,37 @@ public class HTTPRequest extends HTTPPacket
pout.print(HTTP.CRLF);
}
pout.flush();
pout.flush();
in = postSocket.getInputStream();
httpRes.set(in, isHeaderRequest);
}
catch (Exception e) {
} catch (SocketException e) {
httpRes.setStatusCode(HTTPStatus.INTERNAL_SERVER_ERROR);
Debug.warning(e);
} catch (IOException e) {
//Socket create but without connection
//TODO Blacklistening the device
httpRes.setStatusCode(HTTPStatus.INTERNAL_SERVER_ERROR);
// I2P addition
Debug.warning(e);
} finally {
if (isKeepAlive == false) {
try {
in.close();
} catch (Exception e) {}
} catch (Exception e) {};
if (in != null)
try {
out.close();
} catch (Exception e) {}
} catch (Exception e) {};
if (out != null)
try {
postSocket.close();
} catch (Exception e) {}
} catch (Exception e) {};
postSocket = null;
}
}
return httpRes;
}
}
public HTTPResponse post(String host, int port)
{
@@ -490,21 +516,20 @@ public class HTTPRequest extends HTTPPacket
return returnResponse(HTTPStatus.BAD_REQUEST);
}
////////////////////////////////////////////////
// toString
////////////////////////////////////////////////
@Override
public String toString()
{
StringBuilder str = new StringBuilder();
str.append(getHeader());
str.append(HTTP.CRLF);
str.append(getContentString());
return str.toString();
}
////////////////////////////////////////////////
// toString
////////////////////////////////////////////////
public String toString()
{
StringBuffer str = new StringBuffer();
str.append(getHeader());
str.append(HTTP.CRLF);
str.append(getContentString());
return str.toString();
}
public void print()
{

90
router/java/src/org/cybergarage/http/HTTPResponse.java
View File

@@ -5,11 +5,11 @@
* Copyright (C) Satoshi Konno 2002-2003
*
* File: HTTPResponse.java
*
* Revision;
*
* 11/18/02
* - first revision.
*
* Revision;
*
* 11/18/02
* - first revision.
* 10/22/03
* - Changed to initialize a content length header.
* 10/22/04
@@ -17,23 +17,24 @@
*
******************************************************************/
package org.cybergarage.http;
package org.cybergarage.http;
import java.io.*;
import java.io.InputStream;
import org.cybergarage.util.Debug;
public class HTTPResponse extends HTTPPacket
{
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public HTTPResponse()
{
public class HTTPResponse extends HTTPPacket
{
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public HTTPResponse()
{
setVersion(HTTP.VERSION_11);
setContentType(HTML.CONTENT_TYPE);
setServer(HTTPServer.getName());
setContent("");
}
}
public HTTPResponse(HTTPResponse httpRes)
{
@@ -49,25 +50,25 @@ public class HTTPResponse extends HTTPPacket
{
this(httpSock.getInputStream());
}
////////////////////////////////////////////////
// Status Line
////////////////////////////////////////////////
////////////////////////////////////////////////
// Status Line
////////////////////////////////////////////////
private int statusCode = 0;
public void setStatusCode(int code)
public void setStatusCode(int code)
{
statusCode = code;
}
public int getStatusCode()
statusCode = code;
}
public int getStatusCode()
{
if (statusCode != 0)
return statusCode;
return statusCode;
HTTPStatus httpStatus = new HTTPStatus(getFirstLine());
return httpStatus.getStatusCode();
}
return httpStatus.getStatusCode();
}
public boolean isSuccessful()
{
@@ -78,29 +79,28 @@ public class HTTPResponse extends HTTPPacket
{
return "HTTP/" + getVersion() + " " + getStatusCode() + " " + HTTPStatus.code2String(statusCode) + HTTP.CRLF;
}
////////////////////////////////////////////////
// getHeader
////////////////////////////////////////////////
public String getHeader()
{
StringBuilder str = new StringBuilder();
str.append(getStatusLineString());
////////////////////////////////////////////////
// getHeader
////////////////////////////////////////////////
public String getHeader()
{
StringBuffer str = new StringBuffer();
str.append(getStatusLineString());
str.append(getHeaderString());
return str.toString();
}
return str.toString();
}
////////////////////////////////////////////////
// toString
////////////////////////////////////////////////
@Override
public String toString()
{
StringBuilder str = new StringBuilder();
StringBuffer str = new StringBuffer();
str.append(getStatusLineString());
str.append(getHeaderString());

305
router/java/src/org/cybergarage/http/HTTPServer.java
View File

@@ -5,36 +5,57 @@
* Copyright (C) Satoshi Konno 2002-2003
*
* File: HTTPServer.java
*
* Revision;
*
* 12/12/02
* - first revision.
*
* Revision;
*
* 12/12/02
* - first revision.
* 10/20/03
* - Improved the HTTP server using multithreading.
* 08/27/04
* - Changed accept() to set a default timeout, HTTP.DEFAULT_TIMEOUT, to the socket.
*
******************************************************************/
package org.cybergarage.http;
import java.io.*;
import java.net.*;
import org.cybergarage.util.*;
public class HTTPServer implements Runnable
{
////////////////////////////////////////////////
// Constants
////////////////////////////////////////////////
package org.cybergarage.http;
import java.io.IOException;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import org.cybergarage.util.Debug;
import org.cybergarage.util.ListenerList;
/**
*
* This class identifies an HTTP over TCP server<br>
* The server must be initialized iether by the {@link HTTPServer#open(InetAddress, int)} or the {@link HTTPServer#open(String, int)} method.<br>
* Optionally a set of {@link HTTPRequestListener} may be set<br>
* The server then can be started or stopped by the method {@link HTTPServer#start()} and {@link HTTPServer#stop()}
*
* @author Satoshi "skonno" Konno
* @author Stefano "Kismet" Lenzi
* @version 1.8
*
*/
public class HTTPServer implements Runnable
{
////////////////////////////////////////////////
// Constants
////////////////////////////////////////////////
public final static String NAME = "CyberHTTP";
public final static String VERSION = "1.0";
public final static int DEFAULT_PORT = 80;
/**
* Default timeout connection for HTTP comunication
* @since 1.8
*/
public final static int DEFAULT_TIMEOUT = DEFAULT_PORT * 1000;
public static String getName()
{
String osName = System.getProperty("os.name");
@@ -42,27 +63,33 @@ public class HTTPServer implements Runnable
return osName + "/" + osVer + " " + NAME + "/" + VERSION;
}
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public HTTPServer()
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public HTTPServer()
{
serverSock = null;
}
////////////////////////////////////////////////
// ServerSocket
////////////////////////////////////////////////
private ServerSocket serverSock = null;
serverSock = null;
}
////////////////////////////////////////////////
// ServerSocket
////////////////////////////////////////////////
private ServerSocket serverSock = null;
private InetAddress bindAddr = null;
private int bindPort = 0;
public ServerSocket getServerSock()
{
return serverSock;
}
/**
* Store the current TCP timeout value
* The variable should be accessed by getter and setter metho
*/
protected int timeout = DEFAULT_TIMEOUT;
public ServerSocket getServerSock()
{
return serverSock;
}
public String getBindAddress()
{
@@ -76,106 +103,135 @@ public class HTTPServer implements Runnable
return bindPort;
}
////////////////////////////////////////////////
// open/close
////////////////////////////////////////////////
public boolean open(String addr, int port)
/**
* Get the current socket timeout
* @since 1.8
*/
public synchronized int getTimeout() {
return timeout;
}
/**
* Set the current socket timeout
* @param longout new timeout
* @since 1.8
*/
public synchronized void setTimeout(int timeout) {
this.timeout = timeout;
}
public boolean open(InetAddress addr,int port){
if (serverSock != null)
return true;
try {
serverSock = new ServerSocket(bindPort, 0, bindAddr);
}catch (IOException e) {
return false;
}
return true;
}
public boolean open(String addr, int port)
{
if (serverSock != null)
return true;
try {
try {
bindAddr = InetAddress.getByName(addr);
bindPort = port;
serverSock = new ServerSocket(bindPort, 0, bindAddr);
serverSock.setSoTimeout(10*1000);
}
catch (IOException e) {
Debug.warning("HTTP server open failed " + addr + " " + port, e);
return false;
}
return true;
}
public boolean close()
{
return true;
}
public boolean close()
{
if (serverSock == null)
return true;
try {
serverSock.close();
serverSock = null;
bindAddr = null;
bindPort = 0;
}
catch (Exception e) {
Debug.warning(e);
return false;
bindPort = 0;
}
return true;
}
public Socket accept()
{
catch (Exception e) {
Debug.warning(e);
return false;
}
return true;
}
public Socket accept()
{
if (serverSock == null)
return null;
try {
try {
Socket sock = serverSock.accept();
sock.setSoTimeout(HTTP.DEFAULT_TIMEOUT * 1000);
return sock;
}
catch (Exception e) {
return null;
}
}
public boolean isOpened()
{
return (serverSock != null) ? true : false;
}
////////////////////////////////////////////////
// httpRequest
////////////////////////////////////////////////
private ListenerList httpRequestListenerList = new ListenerList();
public void addRequestListener(HTTPRequestListener listener)
{
httpRequestListenerList.add(listener);
}
public void removeRequestListener(HTTPRequestListener listener)
{
httpRequestListenerList.remove(listener);
}
public void performRequestListener(HTTPRequest httpReq)
{
int listenerSize = httpRequestListenerList.size();
for (int n=0; n<listenerSize; n++) {
HTTPRequestListener listener = (HTTPRequestListener)httpRequestListenerList.get(n);
listener.httpRequestRecieved(httpReq);
}
}
////////////////////////////////////////////////
// run
////////////////////////////////////////////////
private Thread httpServerThread = null;
public void run()
{
if (isOpened() == false)
return;
Thread thisThread = Thread.currentThread();
while (httpServerThread == thisThread) {
sock.setSoTimeout(getTimeout());
return sock;
}
catch (Exception e) {
return null;
}
}
public boolean isOpened()
{
return (serverSock != null) ? true : false;
}
////////////////////////////////////////////////
// httpRequest
////////////////////////////////////////////////
private ListenerList httpRequestListenerList = new ListenerList();
public void addRequestListener(HTTPRequestListener listener)
{
httpRequestListenerList.add(listener);
}
public void removeRequestListener(HTTPRequestListener listener)
{
httpRequestListenerList.remove(listener);
}
public void performRequestListener(HTTPRequest httpReq)
{
int listenerSize = httpRequestListenerList.size();
for (int n=0; n<listenerSize; n++) {
HTTPRequestListener listener = (HTTPRequestListener)httpRequestListenerList.get(n);
listener.httpRequestRecieved(httpReq);
}
}
////////////////////////////////////////////////
// run
////////////////////////////////////////////////
private Thread httpServerThread = null;
public void run()
{
if (isOpened() == false)
return;
Thread thisThread = Thread.currentThread();
while (httpServerThread == thisThread) {
Thread.yield();
Socket sock;
try {
//Debug.message("accept ...");
Debug.message("accept ...");
sock = accept();
if (sock != null)
Debug.message("sock = " + sock.getRemoteSocketAddress());
@@ -186,20 +242,21 @@ public class HTTPServer implements Runnable
}
HTTPServerThread httpServThread = new HTTPServerThread(this, sock);
httpServThread.start();
//Debug.message("httpServThread ...");
}
}
public boolean start()
{
httpServerThread = new Thread(this, "UPnP-HTTPServer");
Debug.message("httpServThread ...");
}
}
public boolean start(){
StringBuffer name = new StringBuffer("Cyber.HTTPServer/");
name.append(serverSock.getLocalSocketAddress());
httpServerThread = new Thread(this,name.toString());
httpServerThread.start();
return true;
}
public boolean stop()
return true;
}
public boolean stop()
{
httpServerThread = null;
return true;
}
return true;
}
}

233
router/java/src/org/cybergarage/http/HTTPServerList.java
View File

@@ -1,104 +1,133 @@
/******************************************************************
*
* CyberUPnP for Java
*
* Copyright (C) Satoshi Konno 2002-2003
/******************************************************************
*
* File: HTTPServerList.java
*
* Revision;
*
* 05/08/03
* - first revision.
*
******************************************************************/
* CyberUPnP for Java
*
* Copyright (C) Satoshi Konno 2002-2003
*
* File: HTTPServerList.java
*
* Revision;
*
* 05/08/03
* - first revision.
* 24/03/06
* - Stefano Lenzi:added debug information as request by Stephen More
*
******************************************************************/
package org.cybergarage.http;
import java.net.InetAddress;
import java.util.Vector;
import org.cybergarage.net.HostInterface;
import org.cybergarage.upnp.Device;
public class HTTPServerList extends Vector
{
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
private InetAddress[] binds = null;
private int port = Device.HTTP_DEFAULT_PORT;
public HTTPServerList() {
}
public HTTPServerList(InetAddress[] list, int port) {
this.binds = list;
this.port = port;
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public void addRequestListener(HTTPRequestListener listener)
{
int nServers = size();
for (int n=0; n<nServers; n++) {
HTTPServer server = getHTTPServer(n);
server.addRequestListener(listener);
}
}
public HTTPServer getHTTPServer(int n)
{
return (HTTPServer)get(n);
}
////////////////////////////////////////////////
// open/close
////////////////////////////////////////////////
public void close()
{
int nServers = size();
for (int n=0; n<nServers; n++) {
HTTPServer server = getHTTPServer(n);
server.close();
}
}
public int open(){
InetAddress[] binds=this.binds;
String[] bindAddresses;
if(binds!=null){
bindAddresses = new String[binds.length];
for (int i = 0; i < binds.length; i++) {
bindAddresses[i] = binds[i].getHostAddress();
}
}else{
int nHostAddrs = HostInterface.getNHostAddresses();
bindAddresses = new String[nHostAddrs];
for (int n=0; n<nHostAddrs; n++) {
bindAddresses[n] = HostInterface.getHostAddress(n);
}
}
int j=0;
for (int i = 0; i < bindAddresses.length; i++) {
HTTPServer httpServer = new HTTPServer();
if((bindAddresses[i]==null) || (httpServer.open(bindAddresses[i], port) == false)) {
close();
clear();
}else{
add(httpServer);
j++;
}
}
return j;
}
public boolean open(int port)
{
this.port=port;
return open()!=0;
}
////////////////////////////////////////////////
// start/stop
////////////////////////////////////////////////
public void start()
{
int nServers = size();
for (int n=0; n<nServers; n++) {
HTTPServer server = getHTTPServer(n);
server.start();
}
}
public void stop()
{
int nServers = size();
for (int n=0; n<nServers; n++) {
HTTPServer server = getHTTPServer(n);
server.stop();
}
}
}
package org.cybergarage.http;
import java.util.*;
import org.cybergarage.net.*;
public class HTTPServerList extends Vector
{
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
private static final long serialVersionUID = 2379889735659369065L;
public HTTPServerList()
{
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public void addRequestListener(HTTPRequestListener listener)
{
int nServers = size();
for (int n=0; n<nServers; n++) {
HTTPServer server = getHTTPServer(n);
server.addRequestListener(listener);
}
}
public HTTPServer getHTTPServer(int n)
{
return (HTTPServer)get(n);
}
////////////////////////////////////////////////
// open/close
////////////////////////////////////////////////
public void close()
{
int nServers = size();
for (int n=0; n<nServers; n++) {
HTTPServer server = getHTTPServer(n);
server.close();
}
}
public boolean open(int port)
{
int nHostAddrs = HostInterface.getNHostAddresses();
for (int n=0; n<nHostAddrs; n++) {
String bindAddr = HostInterface.getHostAddress(n);
HTTPServer httpServer = new HTTPServer();
if (httpServer.open(bindAddr, port) == false) {
close();
clear();
return false;
}
add(httpServer);
}
return true;
}
////////////////////////////////////////////////
// start/stop
////////////////////////////////////////////////
public void start()
{
int nServers = size();
for (int n=0; n<nServers; n++) {
HTTPServer server = getHTTPServer(n);
server.start();
}
}
public void stop()
{
int nServers = size();
for (int n=0; n<nServers; n++) {
HTTPServer server = getHTTPServer(n);
server.stop();
}
}
}

5
router/java/src/org/cybergarage/http/HTTPServerThread.java
View File

@@ -15,7 +15,7 @@
package org.cybergarage.http;
import java.net.*;
import java.net.Socket;
public class HTTPServerThread extends Thread
{
@@ -28,16 +28,15 @@ public class HTTPServerThread extends Thread
public HTTPServerThread(HTTPServer httpServer, Socket sock)
{
super("Cyber.HTTPServerThread");
this.httpServer = httpServer;
this.sock = sock;
this.setDaemon(true);
}
////////////////////////////////////////////////
// run
////////////////////////////////////////////////
@Override
public void run()
{
HTTPSocket httpSock = new HTTPSocket(sock);

25
router/java/src/org/cybergarage/http/HTTPSocket.java
View File

@@ -17,14 +17,20 @@
* - Added a isOnlyHeader to post().
* 03/02/05
* - Changed post() to suppot chunked stream.
* 06/10/05
* - Changed post() to add a Date headedr to the HTTPResponse before the posting.
* 07/07/05
* - Lee Peik Feng <pflee@users.sourceforge.net>
* - Fixed post() to output the chunk size as a hex string.
*
******************************************************************/
package org.cybergarage.http;
import java.io.*;
import java.net.*;
import java.util.*;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.Calendar;
public class HTTPSocket
{
@@ -45,7 +51,6 @@ public class HTTPSocket
setOutputStream(socket.getOutputStream());
}
@Override
public void finalize()
{
close();
@@ -120,6 +125,7 @@ public class HTTPSocket
sockOut = sock.getOutputStream();
}
catch (Exception e) {
//TODO Add blacklistening of the UPnP Device
return false;
}
return true;
@@ -147,7 +153,9 @@ public class HTTPSocket
private boolean post(HTTPResponse httpRes, byte content[], long contentOffset, long contentLength, boolean isOnlyHeader)
{
//TODO Check for bad HTTP agents, this method may be list for IOInteruptedException and for blacklistening
httpRes.setDate(Calendar.getInstance());
OutputStream out = getOutputStream();
try {
@@ -163,7 +171,8 @@ public class HTTPSocket
boolean isChunkedResponse = httpRes.isChunked();
if (isChunkedResponse == true) {
String chunSizeBuf = Long.toString(contentLength);
// Thanks for Lee Peik Feng <pflee@users.sourceforge.net> (07/07/05)
String chunSizeBuf = Long.toHexString(contentLength);
out.write(chunSizeBuf.getBytes());
out.write(HTTP.CRLF.getBytes());
}
@@ -188,7 +197,9 @@ public class HTTPSocket
private boolean post(HTTPResponse httpRes, InputStream in, long contentOffset, long contentLength, boolean isOnlyHeader)
{
//TODO Check for bad HTTP agents, this method may be list for IOInteruptedException and for blacklistening
httpRes.setDate(Calendar.getInstance());
OutputStream out = getOutputStream();
try {
@@ -214,7 +225,8 @@ public class HTTPSocket
int readLen = in.read(readBuf, 0, (int)readSize);
while (0 < readLen && readCnt < contentLength) {
if (isChunkedResponse == true) {
String chunSizeBuf = Long.toString(readLen);
// Thanks for Lee Peik Feng <pflee@users.sourceforge.net> (07/07/05)
String chunSizeBuf = Long.toHexString(readLen);
out.write(chunSizeBuf.getBytes());
out.write(HTTP.CRLF.getBytes());
}
@@ -243,6 +255,7 @@ public class HTTPSocket
public boolean post(HTTPResponse httpRes, long contentOffset, long contentLength, boolean isOnlyHeader)
{
//TODO Close if Connection != keep-alive
if (httpRes.hasContentInputStream() == true)
return post(httpRes,httpRes.getContentInputStream(), contentOffset, contentLength, isOnlyHeader);
return post(httpRes,httpRes.getContent(), contentOffset, contentLength, isOnlyHeader);

6
router/java/src/org/cybergarage/http/HTTPStatus.java
View File

@@ -25,9 +25,9 @@
package org.cybergarage.http;
import java.util.*;
import org.cybergarage.util.*;
import java.util.StringTokenizer;
import org.cybergarage.util.Debug;
public class HTTPStatus
{

4
router/java/src/org/cybergarage/http/ParameterList.java
View File

@@ -15,12 +15,10 @@
package org.cybergarage.http;
import java.util.*;
import java.util.Vector;
public class ParameterList extends Vector
{
private static final long serialVersionUID = -6026765325018137641L;
public ParameterList()
{
}

99
router/java/src/org/cybergarage/net/HostInterface.java
View File

@@ -5,11 +5,11 @@
* Copyright (C) Satoshi Konno 2002-2003
*
* File: HostInterface.java
*
* Revision;
*
* 05/12/03
* - first revision.
*
* Revision;
*
* 05/12/03
* - first revision.
* 05/13/03
* - Added support for IPv6 and loopback address.
* 02/15/04
@@ -22,14 +22,22 @@
* - Changed isUseAddress() to isUsableAddress().
*
******************************************************************/
package org.cybergarage.net;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Vector;
package org.cybergarage.net;
import java.net.*;
import java.util.*;
public class HostInterface
{
import org.cybergarage.util.Debug;
public class HostInterface
{
////////////////////////////////////////////////
// Constants
////////////////////////////////////////////////
@@ -43,6 +51,9 @@ public class HostInterface
////////////////////////////////////////////////
private static String ifAddress = "";
public final static int IPV4_BITMASK = 0x0001;
public final static int IPV6_BITMASK = 0x0010;
public final static int LOCAL_BITMASK = 0x0100;
public final static void setInterface(String ifaddr)
{
@@ -101,10 +112,62 @@ public class HostInterface
}
}
}
catch(Exception e){}
catch(Exception e){
Debug.warning(e);
};
return nHostAddrs;
}
/**
*
* @param ipfilter
* @param interfaces
* @return
* @since 1.8.0
* @author Stefano "Kismet" Lenzi &lt;kismet.sl@gmail.com&gt;
*/
public final static InetAddress[] getInetAddress(int ipfilter,String[] interfaces){
Enumeration nis;
if(interfaces!=null){
Vector iflist = new Vector();
for (int i = 0; i < interfaces.length; i++) {
NetworkInterface ni;
try {
ni = NetworkInterface.getByName(interfaces[i]);
} catch (SocketException e) {
continue;
}
if(ni != null) iflist.add(ni);
}
nis = iflist.elements();
}else{
try {
nis = NetworkInterface.getNetworkInterfaces();
} catch (SocketException e) {
return null;
}
}
ArrayList addresses = new ArrayList();
while (nis.hasMoreElements()){
NetworkInterface ni = (NetworkInterface)nis.nextElement();
Enumeration addrs = ni.getInetAddresses();
while (addrs.hasMoreElements()) {
InetAddress addr = (InetAddress)addrs.nextElement();
if(((ipfilter & LOCAL_BITMASK)==0) && addr.isLoopbackAddress())
continue;
if (((ipfilter & IPV4_BITMASK)!=0) && addr instanceof Inet4Address ) {
addresses.add(addr);
}else if (((ipfilter & IPV6_BITMASK)!=0)&& addr instanceof InetAddress) {
addresses.add(addr);
}
}
}
return (InetAddress[]) addresses.toArray(new InetAddress[]{});
}
public final static String getHostAddress(int n)
{
if (hasAssignedInterface() == true)
@@ -131,7 +194,7 @@ public class HostInterface
}
}
}
catch(Exception e){}
catch(Exception e){};
return "";
}
@@ -143,7 +206,9 @@ public class HostInterface
{
try {
InetAddress addr = InetAddress.getByName(host);
return (addr instanceof Inet6Address);
if (addr instanceof Inet6Address)
return true;
return false;
}
catch (Exception e) {}
return false;
@@ -153,7 +218,9 @@ public class HostInterface
{
try {
InetAddress addr = InetAddress.getByName(host);
return (addr instanceof Inet4Address);
if (addr instanceof Inet4Address)
return true;
return false;
}
catch (Exception e) {}
return false;

3
router/java/src/org/cybergarage/soap/SOAP.java
View File

@@ -15,7 +15,8 @@
package org.cybergarage.soap;
import org.cybergarage.xml.*;
import org.cybergarage.xml.Node;
import org.cybergarage.xml.Parser;
public class SOAP
{

103
router/java/src/org/cybergarage/soap/SOAPRequest.java
View File

@@ -5,11 +5,11 @@
* Copyright (C) Satoshi Konno 2002
*
* File: SOAPRequest.java
*
* Revision;
*
* 12/11/02
* - first revision.
*
* Revision;
*
* 12/11/02
* - first revision.
* 02/13/04
* - Ralf G. R. Bergs <Ralf@Ber.gs>, Inma Marin Lopez <inma@dif.um.es>.
* - Added XML header, <?xml version=\"1.0\"?> to setContent().
@@ -17,28 +17,32 @@
* - Changed the XML header to <?xml version="1.0" encoding="utf-8"?> in setContent().
*
******************************************************************/
package org.cybergarage.soap;
import java.io.ByteArrayInputStream;
package org.cybergarage.soap;
import java.io.*;
import org.cybergarage.http.*;
import org.cybergarage.xml.*;
import org.cybergarage.util.*;
public class SOAPRequest extends HTTPRequest
import org.cybergarage.http.HTTP;
import org.cybergarage.http.HTTPRequest;
import org.cybergarage.http.HTTPResponse;
import org.cybergarage.util.Debug;
import org.cybergarage.xml.Node;
import org.cybergarage.xml.Parser;
import org.cybergarage.xml.ParserException;
public class SOAPRequest extends HTTPRequest
{
private final static String SOAPACTION = "SOAPACTION";
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public SOAPRequest()
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public SOAPRequest()
{
setContentType(SOAP.CONTENT_TYPE);
setMethod(HTTP.POST);
}
setContentType(SOAP.CONTENT_TYPE);
setMethod(HTTP.POST);
}
public SOAPRequest(HTTPRequest httpReq)
{
@@ -71,33 +75,33 @@ public class SOAPRequest extends HTTPRequest
return false;
return soapAction.equals(value);
}
////////////////////////////////////////////////
// post
////////////////////////////////////////////////
public SOAPResponse postMessage(String host, int port)
{
HTTPResponse httpRes = post(host, port);
////////////////////////////////////////////////
// post
////////////////////////////////////////////////
public SOAPResponse postMessage(String host, int port)
{
HTTPResponse httpRes = post(host, port);
SOAPResponse soapRes = new SOAPResponse(httpRes);
byte content[] = soapRes.getContent();
if (content.length <= 0)
return soapRes;
try {
ByteArrayInputStream byteIn = new ByteArrayInputStream(content);
Parser xmlParser = SOAP.getXMLParser();
Node _rootNode = xmlParser.parse(byteIn);
soapRes.setEnvelopeNode(_rootNode);
}
catch (Exception e) {
Debug.warning(e);
}
return soapRes;
}
SOAPResponse soapRes = new SOAPResponse(httpRes);
byte content[] = soapRes.getContent();
if (content.length <= 0)
return soapRes;
try {
ByteArrayInputStream byteIn = new ByteArrayInputStream(content);
Parser xmlParser = SOAP.getXMLParser();
Node rootNode = xmlParser.parse(byteIn);
soapRes.setEnvelopeNode(rootNode);
}
catch (Exception e) {
Debug.warning(e);
}
return soapRes;
}
////////////////////////////////////////////////
// Node
@@ -170,7 +174,6 @@ public class SOAPRequest extends HTTPRequest
// print
////////////////////////////////////////////////
@Override
public void print()
{
Debug.message(toString());

6
router/java/src/org/cybergarage/soap/SOAPResponse.java
View File

@@ -20,9 +20,10 @@
package org.cybergarage.soap;
import org.cybergarage.http.*;
import org.cybergarage.http.HTTPResponse;
import org.cybergarage.util.Debug;
import org.cybergarage.xml.*;
import org.cybergarage.xml.Node;
import org.cybergarage.xml.XML;
public class SOAPResponse extends HTTPResponse
{
@@ -179,7 +180,6 @@ public class SOAPResponse extends HTTPResponse
// print
////////////////////////////////////////////////
@Override
public void print()
{
Debug.message(toString());

99
router/java/src/org/cybergarage/upnp/Action.java
View File

@@ -22,16 +22,22 @@
* 07/09/04
* - Thanks for Dimas <cyberrate@users.sourceforge.net> and Stefano Lenzi <kismet-sl@users.sourceforge.net>
* - Changed postControlAction() to set the status code to the UPnPStatus.
* 04/12/06
* - Added setUserData() and getUserData() to set a user original data object.
*
******************************************************************/
package org.cybergarage.upnp;
import java.util.Iterator;
import org.cybergarage.xml.*;
import org.cybergarage.util.*;
import org.cybergarage.upnp.xml.*;
import org.cybergarage.upnp.control.*;
import org.cybergarage.upnp.control.ActionListener;
import org.cybergarage.upnp.control.ActionRequest;
import org.cybergarage.upnp.control.ActionResponse;
import org.cybergarage.upnp.control.ControlResponse;
import org.cybergarage.upnp.xml.ActionData;
import org.cybergarage.util.Debug;
import org.cybergarage.util.Mutex;
import org.cybergarage.xml.Node;
public class Action
{
@@ -58,6 +64,16 @@ public class Action
return new Service(getServiceNode());
}
void setService(Service s){
serviceNode=s.getServiceNode();
/*To ensure integrity of the XML structure*/
Iterator i = getArgumentList().iterator();
while (i.hasNext()) {
Argument arg = (Argument) i.next();
arg.setService(s);
}
}
public Node getActionNode()
{
return actionNode;
@@ -66,6 +82,11 @@ public class Action
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public Action(Node serviceNode){
//TODO Test
this.serviceNode = serviceNode;
this.actionNode = new Node(Action.ELEM_NAME);
}
public Action(Node serviceNode, Node actionNode)
{
@@ -139,6 +160,23 @@ public class Action
argumentList.add(argument);
}
return argumentList;
}
public void setArgumentList(ArgumentList al){
Node argumentListNode = getActionNode().getNode(ArgumentList.ELEM_NAME);
if (argumentListNode == null){
argumentListNode = new Node(ArgumentList.ELEM_NAME);
getActionNode().addNode(argumentListNode);
}else{
argumentListNode.removeAllNodes();
}
Iterator i = al.iterator();
while (i.hasNext()) {
Argument a = (Argument) i.next();
a.setService(getService());
argumentListNode.addNode(a.getArgumentNode());
}
}
public ArgumentList getInputArgumentList()
@@ -184,10 +222,35 @@ public class Action
return null;
}
/**
* @deprecated You should use one of the following methods instead:<br />
* - {@link #setInArgumentValues(ArgumentList)} <br/>
* - {@link #setOutArgumentValues(ArgumentList)}
*/
public void setArgumentValues(ArgumentList argList)
{
getArgumentList().set(argList);
}
/**
*
* @param argList
* @since 1.8.0
*/
public void setInArgumentValues(ArgumentList argList)
{
getArgumentList().setReqArgs(argList);
}
/**
*
* @param argList
* @since 1.8.0
*/
public void setOutArgumentValues(ArgumentList argList)
{
getArgumentList().setResArgs(argList);
}
public void setArgumentValue(String name, String value)
{
@@ -272,8 +335,8 @@ public class Action
actionRes.setResponse(this);
}
else {
UPnPStatus _upnpStatus = getStatus();
actionRes.setFaultResponse(_upnpStatus.getCode(), _upnpStatus.getDescription());
UPnPStatus upnpStatus = getStatus();
actionRes.setFaultResponse(upnpStatus.getCode(), upnpStatus.getDescription());
}
if (Debug.isOn() == true)
actionRes.print();
@@ -323,7 +386,12 @@ public class Action
if (ctrlRes.isSuccessful() == false)
return false;
ArgumentList outArgList = ctrlRes.getResponse();
actionArgList.set(outArgList);
try {
actionArgList.setResArgs(outArgList);
} catch (IllegalArgumentException ex){
setStatus(UPnPStatus.INVALID_ARGS,"Action succesfully delivered but invalid arguments returned.");
return false;
}
return true;
}
@@ -367,4 +435,19 @@ public class Action
return upnpStatus;
}
////////////////////////////////////////////////
// userData
////////////////////////////////////////////////
private Object userData = null;
public void setUserData(Object data)
{
userData = data;
}
public Object getUserData()
{
return userData;
}
}

5
router/java/src/org/cybergarage/upnp/ActionList.java
View File

@@ -15,15 +15,14 @@
package org.cybergarage.upnp;
import java.util.*;
import java.util.Vector;
public class ActionList extends Vector
{
////////////////////////////////////////////////
// Constants
////////////////////////////////////////////////
private static final long serialVersionUID = 1965922721316119846L;
public final static String ELEM_NAME = "actionList";
////////////////////////////////////////////////

67
router/java/src/org/cybergarage/upnp/AllowedValue.java
View File

@@ -5,26 +5,26 @@
* Copyright (C) Satoshi Konno 2002-2004
*
* File: AllowedValue.java
*
* Revision:
*
* 03/27/04
* - first revision.
*
* Revision:
*
* 03/27/04
* - first revision.
*
******************************************************************/
package org.cybergarage.upnp;
import org.cybergarage.xml.*;
public class AllowedValue
{
////////////////////////////////////////////////
// Constants
////////////////////////////////////////////////
public final static String ELEM_NAME = "allowedValue";
package org.cybergarage.upnp;
import org.cybergarage.xml.Node;
public class AllowedValue
{
////////////////////////////////////////////////
// Constants
////////////////////////////////////////////////
public final static String ELEM_NAME = "allowedValue";
////////////////////////////////////////////////
// Member
////////////////////////////////////////////////
@@ -45,15 +45,30 @@ public class AllowedValue
allowedValueNode = node;
}
////////////////////////////////////////////////
// isAllowedValueNode
////////////////////////////////////////////////
public static boolean isAllowedValueNode(Node node)
{
return ELEM_NAME.equals(node.getName());
}
/**
* Create an AllowedValue by the value String,
* and will create the Node structure by itself
*
* @param value The value that will be associate to thi object
*
* @author Stefano "Kismet" Lenzi - kismet-sl@users.sourceforge.net - 2005
*/
public AllowedValue(String value) {
//TODO Some test are done not stable
allowedValueNode = new Node(ELEM_NAME); //better (twa)
setValue(value); //better (twa)
}
////////////////////////////////////////////////
// isAllowedValueNode
////////////////////////////////////////////////
public static boolean isAllowedValueNode(Node node)
{
return ELEM_NAME.equals(node.getName());
}
////////////////////////////////////////////////
// Value
////////////////////////////////////////////////

54
router/java/src/org/cybergarage/upnp/AllowedValueList.java
View File

@@ -5,29 +5,29 @@
* Copyright (C) Satoshi Konno 2002-2004
*
* File: AllowedValueList.java
*
* Revision:
*
* 03/27/04
* - first revision.
*
* Revision:
*
* 03/27/04
* - first revision.
* 02/28/05
* - Changed to use AllowedValue instead of String as the member.
*
******************************************************************/
package org.cybergarage.upnp;
import java.util.*;
public class AllowedValueList extends Vector
{
////////////////////////////////////////////////
// Constants
////////////////////////////////////////////////
private static final long serialVersionUID = 5740394642751180992L;
public final static String ELEM_NAME = "allowedValueList";
package org.cybergarage.upnp;
import java.util.Iterator;
import java.util.Vector;
public class AllowedValueList extends Vector
{
////////////////////////////////////////////////
// Constants
////////////////////////////////////////////////
public final static String ELEM_NAME = "allowedValueList";
////////////////////////////////////////////////
// Constructor
@@ -36,6 +36,14 @@ public class AllowedValueList extends Vector
public AllowedValueList()
{
}
public AllowedValueList(String[] values) {
for (int i = 0; i < values.length; i++) {
add(new AllowedValue(values[i]));
};
}
////////////////////////////////////////////////
// Methods
@@ -46,4 +54,12 @@ public class AllowedValueList extends Vector
return (AllowedValue)get(n);
}
public boolean isAllowed(String v){
for (Iterator i = this.iterator(); i.hasNext();) {
AllowedValue av = (AllowedValue) i.next();
if(av.getValue().equals(v))
return true;
}
return false;
}
}

171
router/java/src/org/cybergarage/upnp/AllowedValueRange.java
View File

@@ -5,71 +5,86 @@
* Copyright (C) Satoshi Konno 2002-2004
*
* File: AllowedValueRange.java
*
* Revision:
*
* 03/27/04
* - first revision.
*
* Revision:
*
* 03/27/04
* - first revision.
*
******************************************************************/
package org.cybergarage.upnp;
import org.cybergarage.xml.*;
public class AllowedValueRange
{
////////////////////////////////////////////////
// Constants
////////////////////////////////////////////////
public final static String ELEM_NAME = "allowedValueRange";
////////////////////////////////////////////////
// Member
////////////////////////////////////////////////
private Node allowedValueRangeNode;
public Node getAllowedValueRangeNode()
{
return allowedValueRangeNode;
}
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public AllowedValueRange(Node node)
{
allowedValueRangeNode = node;
}
////////////////////////////////////////////////
// isAllowedValueRangeNode
////////////////////////////////////////////////
public static boolean isAllowedValueRangeNode(Node node)
{
return ELEM_NAME.equals(node.getName());
}
////////////////////////////////////////////////
// minimum
////////////////////////////////////////////////
private final static String MINIMUM = "minimum";
public void setMinimum(String value)
{
getAllowedValueRangeNode().setNode(MINIMUM, value);
}
public String getMinimum()
{
return getAllowedValueRangeNode().getNodeValue(MINIMUM);
}
package org.cybergarage.upnp;
import org.cybergarage.xml.Node;
public class AllowedValueRange
{
////////////////////////////////////////////////
// Constants
////////////////////////////////////////////////
public final static String ELEM_NAME = "allowedValueRange";
////////////////////////////////////////////////
// Member
////////////////////////////////////////////////
private Node allowedValueRangeNode;
public Node getAllowedValueRangeNode()
{
return allowedValueRangeNode;
}
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public AllowedValueRange(Node node)
{
allowedValueRangeNode = node;
}
public AllowedValueRange(){
//TODO Test
allowedValueRangeNode = new Node(ELEM_NAME);
}
////////////////////////////////////////////////
// isAllowedValueRangeNode
////////////////////////////////////////////////
public AllowedValueRange(Number max, Number min, Number step) {
//TODO Test
allowedValueRangeNode = new Node(ELEM_NAME);
if(max!=null)
setMaximum(max.toString());
if(min!=null)
setMinimum(min.toString());
if(step!=null)
setStep(step.toString());
}
public static boolean isAllowedValueRangeNode(Node node)
{
return ELEM_NAME.equals(node.getName());
}
////////////////////////////////////////////////
// minimum
////////////////////////////////////////////////
private final static String MINIMUM = "minimum";
public void setMinimum(String value)
{
getAllowedValueRangeNode().setNode(MINIMUM, value);
}
public String getMinimum()
{
return getAllowedValueRangeNode().getNodeValue(MINIMUM);
}
////////////////////////////////////////////////
// maximum
////////////////////////////////////////////////
@@ -86,19 +101,19 @@ public class AllowedValueRange
return getAllowedValueRangeNode().getNodeValue(MAXIMUM);
}
////////////////////////////////////////////////
// width
////////////////////////////////////////////////
private final static String STEP = "step";
public void setStep(String value)
{
getAllowedValueRangeNode().setNode(STEP, value);
}
public String getStep()
{
return getAllowedValueRangeNode().getNodeValue(STEP);
}
////////////////////////////////////////////////
// width
////////////////////////////////////////////////
private final static String STEP = "step";
public void setStep(String value)
{
getAllowedValueRangeNode().setNode(STEP, value);
}
public String getStep()
{
return getAllowedValueRangeNode().getNodeValue(STEP);
}
}

214
router/java/src/org/cybergarage/upnp/Argument.java
View File

@@ -5,11 +5,11 @@
* Copyright (C) Satoshi Konno 2002
*
* File: Argument.java
*
* Revision;
*
* 12/05/02
* - first revision.
*
* Revision;
*
* 12/05/02
* - first revision.
* 03/28/04
* - Added getRelatedStateVariable().
* - Changed setRelatedStateVariable() to setRelatedStateVariableName().
@@ -17,37 +17,38 @@
* - Added getActionNode() and getAction().
* - Added getServiceNode() and getService().
* - Added the parent service node to the constructor.
* 04/12/06
* - Added setUserData() and getUserData() to set a user original data object.
*
******************************************************************/
package org.cybergarage.upnp;
import org.cybergarage.xml.*;
import org.cybergarage.upnp.xml.*;
public class Argument
{
////////////////////////////////////////////////
// Constants
////////////////////////////////////////////////
public final static String ELEM_NAME = "argument";
package org.cybergarage.upnp;
import org.cybergarage.upnp.xml.ArgumentData;
import org.cybergarage.xml.Node;
public class Argument
{
////////////////////////////////////////////////
// Constants
////////////////////////////////////////////////
public final static String ELEM_NAME = "argument";
public final static String IN = "in";
public final static String OUT = "out";
////////////////////////////////////////////////
// Member
////////////////////////////////////////////////
private Node argumentNode;
////////////////////////////////////////////////
// Member
////////////////////////////////////////////////
private Node argumentNode;
private Node serviceNode;
public Node getArgumentNode()
{
return argumentNode;
}
public Node getArgumentNode()
{
return argumentNode;
}
private Node getServiceNode()
{
@@ -59,6 +60,10 @@ public class Argument
return new Service(getServiceNode());
}
void setService(Service s){
s.getServiceNode();
}
public Node getActionNode()
{
Node argumentLinstNode = getArgumentNode().getParentNode();
@@ -71,27 +76,32 @@ public class Argument
return null;
return actionNode;
}
public Action getAction()
{
return new Action(getServiceNode(), getActionNode());
}
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public Argument()
{
argumentNode = new Node();
argumentNode = new Node(ELEM_NAME);
serviceNode = null;
}
public Argument(Node servNode, Node argNode)
public Argument(Node servNode){
argumentNode = new Node(ELEM_NAME);
serviceNode = servNode;
}
public Argument(Node servNode, Node argNode)
{
serviceNode = servNode;
argumentNode = argNode;
}
serviceNode = servNode;
argumentNode = argNode;
}
public Argument(String name, String value)
{
@@ -100,46 +110,46 @@ public class Argument
setValue(value);
}
////////////////////////////////////////////////
// isArgumentNode
////////////////////////////////////////////////
public static boolean isArgumentNode(Node node)
{
return Argument.ELEM_NAME.equals(node.getName());
}
////////////////////////////////////////////////
// name
////////////////////////////////////////////////
private final static String NAME = "name";
public void setName(String value)
{
getArgumentNode().setNode(NAME, value);
}
public String getName()
{
return getArgumentNode().getNodeValue(NAME);
}
////////////////////////////////////////////////
// direction
////////////////////////////////////////////////
private final static String DIRECTION = "direction";
public void setDirection(String value)
{
getArgumentNode().setNode(DIRECTION, value);
}
public String getDirection()
{
return getArgumentNode().getNodeValue(DIRECTION);
}
////////////////////////////////////////////////
// isArgumentNode
////////////////////////////////////////////////
public static boolean isArgumentNode(Node node)
{
return Argument.ELEM_NAME.equals(node.getName());
}
////////////////////////////////////////////////
// name
////////////////////////////////////////////////
private final static String NAME = "name";
public void setName(String value)
{
getArgumentNode().setNode(NAME, value);
}
public String getName()
{
return getArgumentNode().getNodeValue(NAME);
}
////////////////////////////////////////////////
// direction
////////////////////////////////////////////////
private final static String DIRECTION = "direction";
public void setDirection(String value)
{
getArgumentNode().setNode(DIRECTION, value);
}
public String getDirection()
{
return getArgumentNode().getNodeValue(DIRECTION);
}
public boolean isInDirection()
{
@@ -153,22 +163,22 @@ public class Argument
{
return !isInDirection();
}
////////////////////////////////////////////////
// relatedStateVariable
////////////////////////////////////////////////
private final static String RELATED_STATE_VARIABLE = "relatedStateVariable";
public void setRelatedStateVariableName(String value)
{
getArgumentNode().setNode(RELATED_STATE_VARIABLE, value);
}
public String getRelatedStateVariableName()
{
return getArgumentNode().getNodeValue(RELATED_STATE_VARIABLE);
}
////////////////////////////////////////////////
// relatedStateVariable
////////////////////////////////////////////////
private final static String RELATED_STATE_VARIABLE = "relatedStateVariable";
public void setRelatedStateVariableName(String value)
{
getArgumentNode().setNode(RELATED_STATE_VARIABLE, value);
}
public String getRelatedStateVariableName()
{
return getArgumentNode().getNodeValue(RELATED_STATE_VARIABLE);
}
public StateVariable getRelatedStateVariable()
{
@@ -226,6 +236,18 @@ public class Argument
}
////////////////////////////////////////////////
// Related
// userData
////////////////////////////////////////////////
private Object userData = null;
public void setUserData(Object data)
{
userData = data;
}
public Object getUserData()
{
return userData;
}
}

194
router/java/src/org/cybergarage/upnp/ArgumentList.java
View File

@@ -1,77 +1,121 @@
/******************************************************************
*
* CyberUPnP for Java
*
* Copyright (C) Satoshi Konno 2002
/******************************************************************
*
* File: ArgumentList.java
*
* Revision:
*
* 12/05/02
* - first revision.
*
******************************************************************/
* CyberUPnP for Java
*
* Copyright (C) Satoshi Konno 2002
*
* File: ArgumentList.java
*
* Revision:
*
* 12/05/02
* - first revision.
*
******************************************************************/
package org.cybergarage.upnp;
import java.util.Vector;
public class ArgumentList extends Vector
{
////////////////////////////////////////////////
// Constants
////////////////////////////////////////////////
public final static String ELEM_NAME = "argumentList";
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public ArgumentList()
{
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public Argument getArgument(int n)
{
return (Argument)get(n);
}
public Argument getArgument(String name)
{
int nArgs = size();
for (int n=0; n<nArgs; n++) {
Argument arg = getArgument(n);
String argName = arg.getName();
if (argName == null)
continue;
if (argName.equals(name) == true)
return arg;
}
return null;
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
/**
* @deprecated
*/
public void set(ArgumentList inArgList)
{
int nInArgs = inArgList.size();
for (int n=0; n<nInArgs; n++) {
Argument inArg = inArgList.getArgument(n);
String inArgName = inArg.getName();
Argument arg = getArgument(inArgName);
if (arg == null)
continue;
arg.setValue(inArg.getValue());
}
}
/**
* Set all the Argument which are Input Argoument to the given value in
* the argument list
*
* @param inArgList
*/
public void setReqArgs(ArgumentList inArgList)
{
int nArgs = size();
for (int n=0; n<nArgs; n++) {
Argument arg = getArgument(n);
if (arg.isInDirection()){
String argName = arg.getName();
Argument inArg = inArgList.getArgument(argName);
if (inArg == null)
throw new IllegalArgumentException("Argument \"" + argName + "\" missing.");
arg.setValue(inArg.getValue());
}
}
}
/**
* Set all the Argument which are Output Argoument to the given value in
* the argument list
*
* @param outArgList
*/
public void setResArgs(ArgumentList outArgList)
{
int nArgs = size();
for (int n=0; n<nArgs; n++) {
Argument arg = getArgument(n);
if (arg.isOutDirection()){
String argName = arg.getName();
Argument outArg = outArgList.getArgument(argName);
if (outArg == null)
throw new IllegalArgumentException("Argument \"" + argName + "\" missing.");
arg.setValue(outArg.getValue());
}
}
}
}
package org.cybergarage.upnp;
import java.util.*;
public class ArgumentList extends Vector
{
////////////////////////////////////////////////
// Constants
////////////////////////////////////////////////
private static final long serialVersionUID = -5412792105767389170L;
public final static String ELEM_NAME = "argumentList";
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public ArgumentList()
{
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public Argument getArgument(int n)
{
return (Argument)get(n);
}
public Argument getArgument(String name)
{
int nArgs = size();
for (int n=0; n<nArgs; n++) {
Argument arg = getArgument(n);
String argName = arg.getName();
if (argName == null)
continue;
if (argName.equals(name) == true)
return arg;
}
return null;
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public void set(ArgumentList inArgList)
{
int nInArgs = inArgList.size();
for (int n=0; n<nInArgs; n++) {
Argument inArg = inArgList.getArgument(n);
String inArgName = inArg.getName();
Argument arg = getArgument(inArgName);
if (arg == null)
continue;
arg.setValue(inArg.getValue());
}
}
}

180
router/java/src/org/cybergarage/upnp/ControlPoint.java
View File

@@ -54,22 +54,47 @@
* the ControlPoint base class adds/removes a UPnP device
* 03/30/05
* - Changed addDevice() to use Parser::parse(URL).
* 04/12/06
* - Added setUserData() and getUserData() to set a user original data object.
*
*******************************************************************/
package org.cybergarage.upnp;
import org.cybergarage.net.*;
import org.cybergarage.util.*;
import org.cybergarage.xml.*;
import org.cybergarage.http.*;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.URL;
import org.cybergarage.upnp.control.*;
import org.cybergarage.upnp.ssdp.*;
import org.cybergarage.upnp.device.*;
import org.cybergarage.upnp.event.*;
import java.net.*;
import org.cybergarage.http.HTTPRequest;
import org.cybergarage.http.HTTPRequestListener;
import org.cybergarage.http.HTTPServerList;
import org.cybergarage.net.HostInterface;
import org.cybergarage.upnp.control.RenewSubscriber;
import org.cybergarage.upnp.device.DeviceChangeListener;
import org.cybergarage.upnp.device.Disposer;
import org.cybergarage.upnp.device.NotifyListener;
import org.cybergarage.upnp.device.ST;
import org.cybergarage.upnp.device.SearchResponseListener;
import org.cybergarage.upnp.device.USN;
import org.cybergarage.upnp.event.EventListener;
import org.cybergarage.upnp.event.NotifyRequest;
import org.cybergarage.upnp.event.Property;
import org.cybergarage.upnp.event.PropertyList;
import org.cybergarage.upnp.event.Subscription;
import org.cybergarage.upnp.event.SubscriptionRequest;
import org.cybergarage.upnp.event.SubscriptionResponse;
import org.cybergarage.upnp.ssdp.SSDP;
import org.cybergarage.upnp.ssdp.SSDPNotifySocketList;
import org.cybergarage.upnp.ssdp.SSDPPacket;
import org.cybergarage.upnp.ssdp.SSDPSearchRequest;
import org.cybergarage.upnp.ssdp.SSDPSearchResponseSocketList;
import org.cybergarage.util.Debug;
import org.cybergarage.util.ListenerList;
import org.cybergarage.util.Mutex;
import org.cybergarage.xml.Node;
import org.cybergarage.xml.NodeList;
import org.cybergarage.xml.Parser;
import org.cybergarage.xml.ParserException;
public class ControlPoint implements HTTPRequestListener
{
@@ -109,10 +134,9 @@ public class ControlPoint implements HTTPRequestListener
// Constructor
////////////////////////////////////////////////
public ControlPoint(int ssdpPort, int httpPort)
{
ssdpNotifySocketList = new SSDPNotifySocketList();
ssdpSearchResponseSocketList = new SSDPSearchResponseSocketList();
public ControlPoint(int ssdpPort, int httpPort,InetAddress[] binds){
ssdpNotifySocketList = new SSDPNotifySocketList(binds);
ssdpSearchResponseSocketList = new SSDPSearchResponseSocketList(binds);
setSSDPPort(ssdpPort);
setHTTPPort(httpPort);
@@ -125,13 +149,16 @@ public class ControlPoint implements HTTPRequestListener
setNMPRMode(false);
setRenewSubscriber(null);
}
public ControlPoint(int ssdpPort, int httpPort){
this(ssdpPort,httpPort,null);
}
public ControlPoint()
{
this(DEFAULT_SSDP_PORT, DEFAULT_EVENTSUB_PORT);
}
@Override
public void finalize()
{
stop();
@@ -267,22 +294,22 @@ public class ControlPoint implements HTTPRequestListener
for (int n=0; n<nRoots; n++) {
Node rootNode = devNodeList.getNode(n);
Device dev = getDevice(rootNode);
if (dev == null)
continue;
devList.add(dev);
}
return devList;
}
public Device getDevice(String name)
{
int nRoots = devNodeList.size();
for (int n=0; n<nRoots; n++) {
if (dev == null)
continue;
devList.add(dev);
}
return devList;
}
public Device getDevice(String name)
{
int nRoots = devNodeList.size();
for (int n=0; n<nRoots; n++) {
// AIOOB was thrown from here, maybe would be better to
// copy the list before traversal?
Node rootNode;
try {
rootNode = devNodeList.getNode(n);
rootNode = devNodeList.getNode(n);
} catch (ArrayIndexOutOfBoundsException aioob) {
break;
}
@@ -316,14 +343,14 @@ public class ControlPoint implements HTTPRequestListener
devNodeList.remove(rootNode);
}
private void removeDevice(Device dev)
protected void removeDevice(Device dev)
{
if (dev == null)
return;
removeDevice(dev.getRootNode());
}
private void removeDevice(String name)
protected void removeDevice(String name)
{
Device dev = getDevice(name);
removeDevice(dev);
@@ -401,7 +428,11 @@ public class ControlPoint implements HTTPRequestListener
int listenerSize = deviceNotifyListenerList.size();
for (int n=0; n<listenerSize; n++) {
NotifyListener listener = (NotifyListener)deviceNotifyListenerList.get(n);
listener.deviceNotifyReceived(ssdpPacket);
try{
listener.deviceNotifyReceived(ssdpPacket);
}catch(Exception e){
Debug.warning("NotifyListener returned an error:", e);
}
}
}
@@ -426,7 +457,13 @@ public class ControlPoint implements HTTPRequestListener
int listenerSize = deviceSearchResponseListenerList.size();
for (int n=0; n<listenerSize; n++) {
SearchResponseListener listener = (SearchResponseListener)deviceSearchResponseListenerList.get(n);
listener.deviceSearchResponseReceived(ssdpPacket);
try{
listener.deviceSearchResponseReceived(ssdpPacket);
}catch(Exception e){
Debug.warning("SearchResponseListener returned an error:", e);
}
}
}
@@ -474,10 +511,11 @@ public class ControlPoint implements HTTPRequestListener
public void notifyReceived(SSDPPacket packet)
{
if (packet.isRootDevice() == true) {
if (packet.isAlive() == true)
if (packet.isAlive() == true){
addDevice(packet);
if (packet.isByeBye() == true)
}else if (packet.isByeBye() == true){
removeDevice(packet);
}
}
performNotifyListener(packet);
}
@@ -508,8 +546,8 @@ public class ControlPoint implements HTTPRequestListener
public void search(String target, int mx)
{
SSDPSearchRequest msReq = new SSDPSearchRequest(target, mx);
SSDPSearchResponseSocketList _ssdpSearchResponseSocketList = getSSDPSearchResponseSocketList();
_ssdpSearchResponseSocketList.post(msReq);
SSDPSearchResponseSocketList ssdpSearchResponseSocketList = getSSDPSearchResponseSocketList();
ssdpSearchResponseSocketList.post(msReq);
}
public void search(String target)
@@ -792,8 +830,8 @@ public class ControlPoint implements HTTPRequestListener
int retryCnt = 0;
int bindPort = getHTTPPort();
HTTPServerList _httpServerList = getHTTPServerList();
while (_httpServerList.open(bindPort) == false) {
HTTPServerList httpServerList = getHTTPServerList();
while (httpServerList.open(bindPort) == false) {
retryCnt++;
if (UPnP.SERVER_RETRY_COUNT < retryCnt) {
Debug.warning("Failed to open HTTP event listener port " + bindPort);
@@ -804,40 +842,40 @@ public class ControlPoint implements HTTPRequestListener
setHTTPPort(bindPort - 1);
bindPort = getHTTPPort();
}
_httpServerList.addRequestListener(this);
_httpServerList.start();
httpServerList.addRequestListener(this);
httpServerList.start();
////////////////////////////////////////
// Notify Socket
////////////////////////////////////////
SSDPNotifySocketList _ssdpNotifySocketList = getSSDPNotifySocketList();
if (_ssdpNotifySocketList.open() == false) {
SSDPNotifySocketList ssdpNotifySocketList = getSSDPNotifySocketList();
if (ssdpNotifySocketList.open() == false) {
Debug.warning("Failed to open SSDP notify port 1900");
return false;
}
_ssdpNotifySocketList.setControlPoint(this);
_ssdpNotifySocketList.start();
ssdpNotifySocketList.setControlPoint(this);
ssdpNotifySocketList.start();
////////////////////////////////////////
// SeachResponse Socket
////////////////////////////////////////
int _ssdpPort = getSSDPPort();
int ssdpPort = getSSDPPort();
retryCnt = 0;
SSDPSearchResponseSocketList _ssdpSearchResponseSocketList = getSSDPSearchResponseSocketList();
while (_ssdpSearchResponseSocketList.open(_ssdpPort) == false) {
SSDPSearchResponseSocketList ssdpSearchResponseSocketList = getSSDPSearchResponseSocketList();
while (ssdpSearchResponseSocketList.open(ssdpPort) == false) {
retryCnt++;
if (UPnP.SERVER_RETRY_COUNT < retryCnt) {
Debug.warning("Failed to open SSDP search response port " + _ssdpPort);
Debug.warning("Failed to open SSDP search response port " + ssdpPort);
return false;
}
// I2P go down not up so we don't run into other I2P things
setSSDPPort(_ssdpPort - 1);
_ssdpPort = getSSDPPort();
setSSDPPort(ssdpPort - 1);
ssdpPort = getSSDPPort();
}
_ssdpSearchResponseSocketList.setControlPoint(this);
_ssdpSearchResponseSocketList.start();
ssdpSearchResponseSocketList.setControlPoint(this);
ssdpSearchResponseSocketList.start();
////////////////////////////////////////
// search root devices
@@ -880,20 +918,20 @@ public class ControlPoint implements HTTPRequestListener
{
unsubscribe();
SSDPNotifySocketList _ssdpNotifySocketList = getSSDPNotifySocketList();
_ssdpNotifySocketList.stop();
_ssdpNotifySocketList.close();
_ssdpNotifySocketList.clear();
SSDPNotifySocketList ssdpNotifySocketList = getSSDPNotifySocketList();
ssdpNotifySocketList.stop();
ssdpNotifySocketList.close();
ssdpNotifySocketList.clear();
SSDPSearchResponseSocketList _ssdpSearchResponseSocketList = getSSDPSearchResponseSocketList();
_ssdpSearchResponseSocketList.stop();
_ssdpSearchResponseSocketList.close();
_ssdpSearchResponseSocketList.clear();
SSDPSearchResponseSocketList ssdpSearchResponseSocketList = getSSDPSearchResponseSocketList();
ssdpSearchResponseSocketList.stop();
ssdpSearchResponseSocketList.close();
ssdpSearchResponseSocketList.clear();
HTTPServerList _httpServerList = getHTTPServerList();
_httpServerList.stop();
_httpServerList.close();
_httpServerList.clear();
HTTPServerList httpServerList = getHTTPServerList();
httpServerList.stop();
httpServerList.close();
httpServerList.clear();
////////////////////////////////////////
// Disposer
@@ -924,6 +962,22 @@ public class ControlPoint implements HTTPRequestListener
return true;
}
////////////////////////////////////////////////
// userData
////////////////////////////////////////////////
private Object userData = null;
public void setUserData(Object data)
{
userData = data;
}
public Object getUserData()
{
return userData;
}
////////////////////////////////////////////////
// print
////////////////////////////////////////////////

463
router/java/src/org/cybergarage/upnp/Device.java
View File

@@ -82,26 +82,66 @@
* 04/25/05
* - Thanks for Mikael Hakman <mhakman@dkab.net>
* - Added a new setActionListener() and serQueryListner() to include the sub devices.
* 07/24/05
* - Thanks for Stefano Lenzi <kismet-sl@users.sourceforge.net>
* - Fixed a bug of getParentDevice() to return the parent device normally.
* 02/21/06
* - Changed httpRequestRecieved() not to ignore HEAD requests.
* 04/12/06
* - Added setUserData() and getUserData() to set a user original data object.
* 03/29/08
* - Added isRunning() to know whether the device is running.
*
******************************************************************/
package org.cybergarage.upnp;
import java.net.*;
import java.io.*;
import java.util.*;
import java.io.File;
import java.io.InputStream;
import java.net.InetAddress;
import java.net.URL;
import java.util.Calendar;
import org.cybergarage.net.*;
import org.cybergarage.http.*;
import org.cybergarage.util.*;
import org.cybergarage.xml.*;
import org.cybergarage.soap.*;
import org.cybergarage.upnp.ssdp.*;
import org.cybergarage.upnp.device.*;
import org.cybergarage.upnp.control.*;
import org.cybergarage.upnp.event.*;
import org.cybergarage.upnp.xml.*;
import org.cybergarage.http.HTTP;
import org.cybergarage.http.HTTPRequest;
import org.cybergarage.http.HTTPResponse;
import org.cybergarage.http.HTTPServerList;
import org.cybergarage.http.HTTPStatus;
import org.cybergarage.net.HostInterface;
import org.cybergarage.soap.SOAPResponse;
import org.cybergarage.upnp.control.ActionListener;
import org.cybergarage.upnp.control.ActionRequest;
import org.cybergarage.upnp.control.ActionResponse;
import org.cybergarage.upnp.control.ControlRequest;
import org.cybergarage.upnp.control.ControlResponse;
import org.cybergarage.upnp.control.QueryListener;
import org.cybergarage.upnp.control.QueryRequest;
import org.cybergarage.upnp.device.Advertiser;
import org.cybergarage.upnp.device.Description;
import org.cybergarage.upnp.device.InvalidDescriptionException;
import org.cybergarage.upnp.device.NTS;
import org.cybergarage.upnp.device.ST;
import org.cybergarage.upnp.device.SearchListener;
import org.cybergarage.upnp.device.USN;
import org.cybergarage.upnp.event.Subscriber;
import org.cybergarage.upnp.event.Subscription;
import org.cybergarage.upnp.event.SubscriptionRequest;
import org.cybergarage.upnp.event.SubscriptionResponse;
import org.cybergarage.upnp.ssdp.SSDPNotifyRequest;
import org.cybergarage.upnp.ssdp.SSDPNotifySocket;
import org.cybergarage.upnp.ssdp.SSDPPacket;
import org.cybergarage.upnp.ssdp.SSDPSearchResponse;
import org.cybergarage.upnp.ssdp.SSDPSearchResponseSocket;
import org.cybergarage.upnp.ssdp.SSDPSearchSocketList;
import org.cybergarage.upnp.xml.DeviceData;
import org.cybergarage.util.Debug;
import org.cybergarage.util.FileUtil;
import org.cybergarage.util.Mutex;
import org.cybergarage.util.TimerUtil;
import org.cybergarage.xml.Node;
import org.cybergarage.xml.Parser;
import org.cybergarage.xml.ParserException;
import org.cybergarage.xml.XML;
public class Device implements org.cybergarage.http.HTTPRequestListener, SearchListener
{
@@ -188,6 +228,16 @@ public class Device implements org.cybergarage.http.HTTPRequestListener, SearchL
loadDescription(descriptionFile);
}
/**
* @since 1.8.0
*/
public Device(InputStream input) throws InvalidDescriptionException
{
this(null, null);
loadDescription(input);
}
public Device(String descriptionFileName) throws InvalidDescriptionException
{
this(new File(descriptionFileName));
@@ -209,6 +259,47 @@ public class Device implements org.cybergarage.http.HTTPRequestListener, SearchL
mutex.unlock();
}
////////////////////////////////////////////////
// getAbsoluteURL
////////////////////////////////////////////////
public String getAbsoluteURL(String urlString)
{
try {
URL url = new URL(urlString);
return url.toString();
}
catch (Exception e) {}
Device rootDev = getRootDevice();
String urlBaseStr = rootDev.getURLBase();
// Thanks for Steven Yen (2003/09/03)
if (urlBaseStr == null || urlBaseStr.length() <= 0) {
String location = rootDev.getLocation();
String locationHost = HTTP.getHost(location);
int locationPort = HTTP.getPort(location);
urlBaseStr = HTTP.getRequestHostURL(locationHost, locationPort);
}
urlString = HTTP.toRelativeURL(urlString);
String absUrl = urlBaseStr + urlString;
try {
URL url = new URL(absUrl);
return url.toString();
}
catch (Exception e) {}
absUrl = HTTP.getAbsoluteURL(urlBaseStr, urlString);
try {
URL url = new URL(absUrl);
return url.toString();
}
catch (Exception e) {}
return "";
}
////////////////////////////////////////////////
// NMPR
////////////////////////////////////////////////
@@ -285,13 +376,13 @@ public class Device implements org.cybergarage.http.HTTPRequestListener, SearchL
public Device getRootDevice()
{
Node _rootNode = getRootNode();
if (_rootNode == null)
Node rootNode = getRootNode();
if (rootNode == null)
return null;
Node devNode = _rootNode.getNode(Device.ELEM_NAME);
Node devNode = rootNode.getNode(Device.ELEM_NAME);
if (devNode == null)
return null;
return new Device(_rootNode, devNode);
return new Device(rootNode, devNode);
}
////////////////////////////////////////////////
@@ -300,15 +391,71 @@ public class Device implements org.cybergarage.http.HTTPRequestListener, SearchL
// Thanks for Stefano Lenzi (07/24/04)
public Device getParentDevice()
{
/**
*
* @return A Device that contain this object.<br>
* Return <code>null</code> if this is a root device.
* @author Stefano "Kismet" Lenzi
*/
public Device getParentDevice() {
if(isRootDevice())
return null;
Node devNode = getDeviceNode();
Node aux = null;
//<device><deviceList><device>
devNode = devNode.getParentNode().getParentNode().getNode(Device.ELEM_NAME);
return new Device(devNode);
aux = devNode.getParentNode().getParentNode();
return new Device(aux);
}
/**
* Add a Service to device without checking for duplicate or syntax error
*
* @param s Add Service s to the Device
*/
public void addService(Service s) {
Node serviceListNode = getDeviceNode().getNode(ServiceList.ELEM_NAME);
if (serviceListNode == null) {
serviceListNode = new Node(ServiceList.ELEM_NAME);
getDeviceNode().addNode(serviceListNode);
}
serviceListNode.addNode(s.getServiceNode());
}
/**
* Add a Device to device without checking for duplicate or syntax error.
* This method set or reset the root node of the Device and itself<br>
* <br>
* Note: This method should be used to create a dynamic<br>
* Device withtout writing any XML that describe the device<br>.
*
* @param d Add Device d to the Device
*
* @author Stefano "Kismet" Lenzi - kismet-sl@users.sourceforge.net - 2005
*
*/
public void addDevice(Device d) {
Node deviceListNode = getDeviceNode().getNode(DeviceList.ELEM_NAME);
if (deviceListNode == null) {
//deviceListNode = new Node(ServiceList.ELEM_NAME); twa wrong ELEM_NAME;
deviceListNode = new Node(DeviceList.ELEM_NAME);
getDeviceNode().addNode(deviceListNode);
}
deviceListNode.addNode(d.getDeviceNode());
d.setRootNode(null);
if(getRootNode()==null){
Node root = new Node(RootDescription.ROOT_ELEMENT);
root.setNameSpace("",RootDescription.ROOT_ELEMENT_NAMESPACE);
Node spec = new Node(RootDescription.SPECVERSION_ELEMENT);
Node maj =new Node(RootDescription.MAJOR_ELEMENT);
maj.setValue("1");
Node min =new Node(RootDescription.MINOR_ELEMENT);
min.setValue("0");
spec.addNode(maj);
spec.addNode(min);
root.addNode(spec);
setRootNode(root);
}
}
////////////////////////////////////////////////
// UserData
@@ -365,6 +512,32 @@ public class Device implements org.cybergarage.http.HTTPRequestListener, SearchL
return "";
return descriptionFile.getAbsoluteFile().getParent();
}
/**
* @since 1.8.0
*/
public boolean loadDescription(InputStream input) throws InvalidDescriptionException
{
try {
Parser parser = UPnP.getXMLParser();
rootNode = parser.parse(input);
if (rootNode == null)
throw new InvalidDescriptionException(Description.NOROOT_EXCEPTION);
deviceNode = rootNode.getNode(Device.ELEM_NAME);
if (deviceNode == null)
throw new InvalidDescriptionException(Description.NOROOTDEVICE_EXCEPTION);
}
catch (ParserException e) {
throw new InvalidDescriptionException(e);
}
if (initializeLoadedDescription() == false)
return false;
setDescriptionFile(null);
return true;
}
public boolean loadDescription(String descString) throws InvalidDescriptionException
{
@@ -438,9 +611,8 @@ public class Device implements org.cybergarage.http.HTTPRequestListener, SearchL
// Root Device
////////////////////////////////////////////////
public boolean isRootDevice()
{
return (getRootNode() != null) ? true : false;
public boolean isRootDevice(){
return getRootNode().getNode("device").getNodeValue(UDN).equals(getUDN());
}
////////////////////////////////////////////////
@@ -603,7 +775,7 @@ public class Device implements org.cybergarage.http.HTTPRequestListener, SearchL
// manufacture
////////////////////////////////////////////////
private final static String MANUFACTURE = "manufacture";
private final static String MANUFACTURE = "manufacturer";
public void setManufacture(String value)
{
@@ -619,7 +791,7 @@ public class Device implements org.cybergarage.http.HTTPRequestListener, SearchL
// manufactureURL
////////////////////////////////////////////////
private final static String MANUFACTURE_URL = "manufactureURL";
private final static String MANUFACTURE_URL = "manufacturerURL";
public void setManufactureURL(String value)
{
@@ -1066,6 +1238,24 @@ public class Device implements org.cybergarage.http.HTTPRequestListener, SearchL
return iconList.getIcon(n);
}
public Icon getSmallestIcon()
{
Icon smallestIcon = null;
IconList iconList = getIconList();
int iconCount = iconList.size();
for (int n=0; n < iconCount; n++) {
Icon icon = iconList.getIcon(n);
if (null == smallestIcon) {
smallestIcon = icon;
continue;
}
if (icon.getWidth() < smallestIcon.getWidth())
smallestIcon = icon;
}
return smallestIcon;
}
////////////////////////////////////////////////
// Notify
////////////////////////////////////////////////
@@ -1103,7 +1293,6 @@ public class Device implements org.cybergarage.http.HTTPRequestListener, SearchL
{
TimerUtil.waitRandom(DEFAULT_DISCOVERY_WAIT_TIME);
}
public void announce(String bindAddr)
{
String devLocation = getLocationURL(bindAddr);
@@ -1123,6 +1312,11 @@ public class Device implements org.cybergarage.http.HTTPRequestListener, SearchL
ssdpReq.setNT(devNT);
ssdpReq.setUSN(devUSN);
ssdpSock.post(ssdpReq);
String devUDN = getUDN();
ssdpReq.setNT(devUDN);
ssdpReq.setUSN(devUDN);
ssdpSock.post(ssdpReq);
}
// uuid:device-UUID::urn:schemas-upnp-org:device:deviceType:v
@@ -1150,18 +1344,29 @@ public class Device implements org.cybergarage.http.HTTPRequestListener, SearchL
}
}
public void announce()
{
public void announce(){
notifyWait();
int nHostAddrs = HostInterface.getNHostAddresses();
for (int n=0; n<nHostAddrs; n++) {
String bindAddr = HostInterface.getHostAddress(n);
if (bindAddr == null || bindAddr.length() <= 0)
InetAddress[] binds = getDeviceData().getHTTPBindAddress();
String[] bindAddresses;
if(binds!=null){
bindAddresses = new String[binds.length];
for (int i = 0; i < binds.length; i++) {
bindAddresses[i] = binds[i].getHostAddress();
}
}else{
int nHostAddrs = HostInterface.getNHostAddresses();
bindAddresses = new String[nHostAddrs];
for (int n=0; n<nHostAddrs; n++) {
bindAddresses[n] = HostInterface.getHostAddress(n);
}
}
for (int j = 0; j < bindAddresses.length; j++) {
if(bindAddresses[j] == null || bindAddresses[j].length() == 0)
continue;
int ssdpCount = getSSDPAnnounceCount();
for (int i=0; i<ssdpCount; i++)
announce(bindAddr);
announce(bindAddresses[j]);
}
}
@@ -1206,24 +1411,38 @@ public class Device implements org.cybergarage.http.HTTPRequestListener, SearchL
}
}
public void byebye()
{
int nHostAddrs = HostInterface.getNHostAddresses();
for (int n=0; n<nHostAddrs; n++) {
String bindAddr = HostInterface.getHostAddress(n);
if (bindAddr == null || bindAddr.length() <= 0)
public void byebye(){
InetAddress[] binds = getDeviceData().getHTTPBindAddress();
String[] bindAddresses;
if(binds!=null){
bindAddresses = new String[binds.length];
for (int i = 0; i < binds.length; i++) {
bindAddresses[i] = binds[i].getHostAddress();
}
}else{
int nHostAddrs = HostInterface.getNHostAddresses();
bindAddresses = new String[nHostAddrs];
for (int n=0; n<nHostAddrs; n++) {
bindAddresses[n] = HostInterface.getHostAddress(n);
}
}
for (int j = 0; j < bindAddresses.length; j++) {
if (bindAddresses[j] == null || bindAddresses[j].length() <= 0)
continue;
int ssdpCount = getSSDPAnnounceCount();
for (int i=0; i<ssdpCount; i++)
byebye(bindAddr);
}
byebye(bindAddresses[j]);
}
}
////////////////////////////////////////////////
// Search
////////////////////////////////////////////////
public boolean postSearchResponse(SSDPPacket ssdpPacket, String st, String usn)
private static Calendar cal = Calendar.getInstance();
public boolean postSearchResponse(SSDPPacket ssdpPacket, String st, String usn)
{
String localAddr = ssdpPacket.getLocalAddress();
Device rootDev = getRootDevice();
@@ -1231,7 +1450,7 @@ public class Device implements org.cybergarage.http.HTTPRequestListener, SearchL
SSDPSearchResponse ssdpRes = new SSDPSearchResponse();
ssdpRes.setLeaseTime(getLeaseTime());
ssdpRes.setDate(Calendar.getInstance());
ssdpRes.setDate(cal);
ssdpRes.setST(st);
ssdpRes.setUSN(usn);
ssdpRes.setLocation(rootDevLocation);
@@ -1324,12 +1543,56 @@ public class Device implements org.cybergarage.http.HTTPRequestListener, SearchL
return getDeviceData().getHTTPPort();
}
public void setHTTPBindAddress(InetAddress[] inets){
this.getDeviceData().setHTTPBindAddress(inets);
}
public InetAddress[] getHTTPBindAddress(){
return this.getDeviceData().getHTTPBindAddress();
}
/**
*
* @return
* @since 1.8
*/
public String getSSDPIPv4MulticastAddress(){
return this.getDeviceData().getMulticastIPv4Address();
}
/**
*
* @param ip
* @since 1.8
*/
public void getSSDPIPv4MulticastAddress(String ip){
this.getDeviceData().setMulticastIPv4Address(ip);
}
/**
*
* @return
* @since 1.8
*/
public String getSSDPIPv6MulticastAddress(){
return this.getDeviceData().getMulticastIPv6Address();
}
/**
*
* @param ip
* @since 1.8
*/
public void getSSDPIPv6MulticastAddress(String ip){
this.getDeviceData().setMulticastIPv6Address(ip);
}
public void httpRequestRecieved(HTTPRequest httpReq)
{
if (Debug.isOn() == true)
httpReq.print();
if (httpReq.isGetRequest() == true) {
if (httpReq.isGetRequest() == true || httpReq.isHeadRequest() == true) {
httpGetRequestRecieved(httpReq);
return;
}
@@ -1377,6 +1640,8 @@ public class Device implements org.cybergarage.http.HTTPRequestListener, SearchL
byte fileByte[] = new byte[0];
if (isDescriptionURI(uri) == true) {
String localAddr = httpReq.getLocalAddress();
if ((localAddr == null) || (localAddr.length() <= 0))
localAddr = HostInterface.getInterface();
fileByte = getDescriptionData(localAddr);
}
else if ((embDev = getDeviceByDescriptionURI(uri)) != null) {
@@ -1452,6 +1717,13 @@ public class Device implements org.cybergarage.http.HTTPRequestListener, SearchL
ctlReq.post(actRes);
}
private void invalidArgumentsControlRecieved(ControlRequest ctlReq)
{
ControlResponse actRes = new ActionResponse();
actRes.setFaultResponse(UPnPStatus.INVALID_ARGS);
ctlReq.post(actRes);
}
private void deviceActionControlRecieved(ActionRequest ctlReq, Service service)
{
if (Debug.isOn() == true)
@@ -1465,7 +1737,12 @@ public class Device implements org.cybergarage.http.HTTPRequestListener, SearchL
}
ArgumentList actionArgList = action.getArgumentList();
ArgumentList reqArgList = ctlReq.getArgumentList();
actionArgList.set(reqArgList);
try {
actionArgList.setReqArgs(reqArgList);
} catch (IllegalArgumentException ex){
invalidArgumentsControlRecieved(ctlReq);
return;
}
if (action.performActionListener(ctlReq) == false)
invalidActionControlRecieved(ctlReq);
}
@@ -1615,6 +1892,75 @@ public class Device implements org.cybergarage.http.HTTPRequestListener, SearchL
{
return getDeviceData().getHTTPServerList();
}
/**
*
* @param port The port to use for binding the SSDP service
*/
public void setSSDPPort(int port){
this.getDeviceData().setSSDPPort(port);
}
/**
*
* @return The port to use for binding the SSDP service
*/
public int getSSDPPort(){
return this.getDeviceData().getSSDPPort();
}
/**
*
* @param inets The IP that will be used for binding the SSDP service.
* Use <code>null</code> to get the default beahvior
*/
public void setSSDPBindAddress(InetAddress[] inets){
this.getDeviceData().setSSDPBindAddress(inets);
}
/**
*
* @return inets The IP that will be used for binding the SSDP service.
* null means the default setted by the class UPnP
*/
public InetAddress[] getSSDPBindAddress(){
return this.getDeviceData().getSSDPBindAddress();
}
/**
*
* @param ip The IPv4 address used for Multicast comunication
*/
public void setMulticastIPv4Address(String ip){
this.getDeviceData().setMulticastIPv4Address(ip);
}
/**
*
* @return The IPv4 address used for Multicast comunication
*/
public String getMulticastIPv4Address(){
return this.getDeviceData().getMulticastIPv4Address();
}
/**
*
* @param ip The IPv address used for Multicast comunication
*/
public void setMulticastIPv6Address(String ip){
this.getDeviceData().setMulticastIPv6Address(ip);
}
/**
*
* @return The IPv address used for Multicast comunication
*/
public String getMulticastIPv6Address(){
return this.getDeviceData().getMulticastIPv6Address();
}
private SSDPSearchSocketList getSSDPSearchSocketList()
{
@@ -1708,6 +2054,11 @@ public class Device implements org.cybergarage.http.HTTPRequestListener, SearchL
return stop(true);
}
public boolean isRunning()
{
return (getAdvertiser() != null) ? true : false;
}
////////////////////////////////////////////////
// Interface Address
////////////////////////////////////////////////
@@ -1775,6 +2126,22 @@ public class Device implements org.cybergarage.http.HTTPRequestListener, SearchL
}
}
}
////////////////////////////////////////////////
// userData
////////////////////////////////////////////////
private Object userData = null;
public void setUserData(Object data)
{
userData = data;
}
public Object getUserData()
{
return userData;
}
////////////////////////////////////////////////
// output

87
router/java/src/org/cybergarage/upnp/DeviceList.java
View File

@@ -1,46 +1,45 @@
/******************************************************************
*
* CyberUPnP for Java
*
* Copyright (C) Satoshi Konno 2002
/******************************************************************
*
* File: DeviceList.java
*
* Revision;
*
* 12/04/02
* - first revision.
*
******************************************************************/
* CyberUPnP for Java
*
* Copyright (C) Satoshi Konno 2002
*
* File: DeviceList.java
*
* Revision;
*
* 12/04/02
* - first revision.
*
******************************************************************/
package org.cybergarage.upnp;
import java.util.Vector;
public class DeviceList extends Vector
{
////////////////////////////////////////////////
// Constants
////////////////////////////////////////////////
public final static String ELEM_NAME = "deviceList";
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public DeviceList()
{
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public Device getDevice(int n)
{
return (Device)get(n);
}
}
package org.cybergarage.upnp;
import java.util.*;
public class DeviceList extends Vector
{
////////////////////////////////////////////////
// Constants
////////////////////////////////////////////////
private static final long serialVersionUID = 3773784061607435126L;
public final static String ELEM_NAME = "deviceList";
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public DeviceList()
{
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public Device getDevice(int n)
{
return (Device)get(n);
}
}

56
router/java/src/org/cybergarage/upnp/Icon.java
View File

@@ -10,12 +10,14 @@
*
* 11/28/02
* - first revision.
* 04/12/06
* - Added setUserData() and getUserData() to set a user original data object.
*
******************************************************************/
package org.cybergarage.upnp;
import org.cybergarage.xml.*;
import org.cybergarage.xml.Node;
public class Icon
{
@@ -81,9 +83,21 @@ public class Icon
getIconNode().setNode(WIDTH, value);
}
public String getWidth()
{
return getIconNode().getNodeValue(WIDTH);
public void setWidth(int value)
{
try {
setWidth(Integer.toString(value));
}
catch (Exception e) {};
}
public int getWidth()
{
try {
return Integer.parseInt(getIconNode().getNodeValue(WIDTH));
}
catch (Exception e) {};
return 0;
}
////////////////////////////////////////////////
@@ -97,9 +111,21 @@ public class Icon
getIconNode().setNode(HEIGHT, value);
}
public String getHeight()
public void setHeight(int value)
{
try {
setHeight(Integer.toString(value));
}
catch (Exception e) {};
}
public int getHeight()
{
return getIconNode().getNodeValue(HEIGHT);
try {
return Integer.parseInt(getIconNode().getNodeValue(HEIGHT));
}
catch (Exception e) {};
return 0;
}
////////////////////////////////////////////////
@@ -132,5 +158,21 @@ public class Icon
public String getURL()
{
return getIconNode().getNodeValue(URL);
}
}
////////////////////////////////////////////////
// userData
////////////////////////////////////////////////
private Object userData = null;
public void setUserData(Object data)
{
userData = data;
}
public Object getUserData()
{
return userData;
}
}

3
router/java/src/org/cybergarage/upnp/IconList.java
View File

@@ -15,7 +15,7 @@
package org.cybergarage.upnp;
import java.util.*;
import java.util.Vector;
public class IconList extends Vector
{
@@ -23,7 +23,6 @@ public class IconList extends Vector
// Constants
////////////////////////////////////////////////
private static final long serialVersionUID = -1097238335037012991L;
public final static String ELEM_NAME = "iconList";
////////////////////////////////////////////////

19
router/java/src/org/cybergarage/upnp/RootDescription.java Normal file
View File

@@ -0,0 +1,19 @@
package org.cybergarage.upnp;
/**
* @author Stefano "Kismet" Lenzi - kismet-sl@users.sourceforge.net <br>
* Copyright (c) 2005
*
*/
public interface RootDescription {
public final String ROOT_ELEMENT = "root";
public final String ROOT_ELEMENT_NAMESPACE = "urn:schemas-upnp-org:device-1-0";
public final String SPECVERSION_ELEMENT = "specVersion";
public final String MAJOR_ELEMENT = "major";
public final String MINOR_ELEMENT = "minor";
public final String SERVICE_LIST_ELEMENT = "serviceList";
}

238
router/java/src/org/cybergarage/upnp/Service.java
View File

@@ -60,23 +60,42 @@
* 04/25/05
* - Thanks for Mikael Hakman <mhakman@dkab.net>
* - Changed getSCPDData() to add a XML declaration at first line.
* 06/21/05
* - Changed notify() to continue when the subscriber is null.
* 04/12/06
* - Added setUserData() and getUserData() to set a user original data object.
* 09/18/2010 Robin V. <robinsp@gmail.com>
* - Fixed getSCPDNode() not to occur recursive http get requests.
*
******************************************************************/
package org.cybergarage.upnp;
import java.io.*;
import java.net.*;
import java.io.File;
import java.io.InputStream;
import java.net.URL;
import java.util.Iterator;
import org.cybergarage.http.*;
import org.cybergarage.xml.*;
import org.cybergarage.util.*;
import org.cybergarage.upnp.ssdp.*;
import org.cybergarage.upnp.xml.*;
import org.cybergarage.upnp.device.*;
import org.cybergarage.upnp.control.*;
import org.cybergarage.upnp.event.*;
import org.cybergarage.http.HTTP;
import org.cybergarage.http.HTTPResponse;
import org.cybergarage.upnp.control.ActionListener;
import org.cybergarage.upnp.control.QueryListener;
import org.cybergarage.upnp.device.InvalidDescriptionException;
import org.cybergarage.upnp.device.NTS;
import org.cybergarage.upnp.device.ST;
import org.cybergarage.upnp.event.NotifyRequest;
import org.cybergarage.upnp.event.Subscriber;
import org.cybergarage.upnp.event.SubscriberList;
import org.cybergarage.upnp.ssdp.SSDPNotifyRequest;
import org.cybergarage.upnp.ssdp.SSDPNotifySocket;
import org.cybergarage.upnp.ssdp.SSDPPacket;
import org.cybergarage.upnp.xml.ServiceData;
import org.cybergarage.util.Debug;
import org.cybergarage.util.Mutex;
import org.cybergarage.util.StringUtil;
import org.cybergarage.xml.Node;
import org.cybergarage.xml.Parser;
import org.cybergarage.xml.ParserException;
public class Service
{
@@ -100,6 +119,34 @@ public class Service
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public static final String SCPD_ROOTNODE="scpd";
public static final String SCPD_ROOTNODE_NS="urn:schemas-upnp-org:service-1-0";
public static final String SPEC_VERSION="specVersion";
public static final String MAJOR="major";
public static final String MAJOR_VALUE="1";
public static final String MINOR="minor";
public static final String MINOR_VALUE="0";
public Service(){
this(new Node(ELEM_NAME));
Node sp = new Node(SPEC_VERSION);
Node M =new Node(MAJOR);
M.setValue(MAJOR_VALUE);
sp.addNode(M);
Node m =new Node(MINOR);
m.setValue(MINOR_VALUE);
sp.addNode(m);
//Node scpd = new Node(SCPD_ROOTNODE,SCPD_ROOTNODE_NS); wrong!
Node scpd = new Node(SCPD_ROOTNODE); // better (twa)
scpd.addAttribute("xmlns",SCPD_ROOTNODE_NS); // better (twa)
scpd.addNode(sp);
getServiceData().setSCPDNode(scpd);
}
public Service(Node node)
{
@@ -306,6 +353,32 @@ public class Service
data.setSCPDNode(scpdNode);
return true;
}
/**
* @since 1.8.0
*/
public boolean loadSCPD(InputStream input) throws ParserException
{
Parser parser = UPnP.getXMLParser();
Node scpdNode = parser.parse(input);
if (scpdNode == null)
return false;
ServiceData data = getServiceData();
data.setSCPDNode(scpdNode);
return true;
}
public void setDescriptionURL(String value)
{
getServiceData().setDescriptionURL(value);
}
public String getDescriptionURL()
{
return getServiceData().getDescriptionURL();
}
private Node getSCPDNode(URL scpdUrl) throws ParserException
{
@@ -326,48 +399,53 @@ public class Service
if (scpdNode != null)
return scpdNode;
// Thanks for Jaap (Sep 18, 2010)
Device rootDev = getRootDevice();
if (rootDev == null)
return null;
String scpdURLStr = getSCPDURL();
try {
URL scpdUrl = new URL(scpdURLStr);
scpdNode = getSCPDNode(scpdUrl);
}
catch (Exception e1) {
Device rootDev = getRootDevice();
String urlBaseStr = rootDev.getURLBase();
// Thanks for Steven Yen (2003/09/03)
if (urlBaseStr == null || urlBaseStr.length() <= 0) {
String location = rootDev.getLocation();
String locationHost = HTTP.getHost(location);
int locationPort = HTTP.getPort(location);
urlBaseStr = HTTP.getRequestHostURL(locationHost, locationPort);
}
scpdURLStr = HTTP.toRelativeURL(scpdURLStr);
String newScpdURLStr = urlBaseStr + scpdURLStr;
try {
URL newScpdURL = new URL(newScpdURLStr);
scpdNode = getSCPDNode(newScpdURL);
}
catch (Exception e2) {
newScpdURLStr = HTTP.getAbsoluteURL(urlBaseStr, scpdURLStr);
// Thanks for Robin V. (Sep 18, 2010)
String rootDevPath = rootDev.getDescriptionFilePath();
if(rootDevPath!=null) {
File f;
f = new File(rootDevPath.concat(scpdURLStr));
if(f.exists()) {
try {
URL newScpdURL = new URL(newScpdURLStr);
scpdNode = getSCPDNode(newScpdURL);
scpdNode = getSCPDNode(f);
} catch (ParserException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
catch (Exception e3) {
newScpdURLStr = rootDev.getDescriptionFilePath() + scpdURLStr;
try {
scpdNode = getSCPDNode(new File(newScpdURLStr));
}
catch (Exception e4) {
Debug.warning(e4);
}
if(scpdNode!=null) {
data.setSCPDNode(scpdNode);
return scpdNode;
}
}
}
data.setSCPDNode(scpdNode);
try {
URL scpdUrl = new URL(rootDev.getAbsoluteURL(scpdURLStr));
scpdNode = getSCPDNode(scpdUrl);
if (scpdNode != null) {
data.setSCPDNode(scpdNode);
return scpdNode;
}
}
catch (Exception e) {}
return scpdNode;
String newScpdURLStr = rootDev.getDescriptionFilePath() + HTTP.toRelativeURL(scpdURLStr);
try {
scpdNode = getSCPDNode(new File(newScpdURLStr));
return scpdNode;
}
catch (Exception e) {
Debug.warning(e);
}
return null;
}
public byte[] getSCPDData()
@@ -396,13 +474,12 @@ public class Service
Node actionListNode = scdpNode.getNode(ActionList.ELEM_NAME);
if (actionListNode == null)
return actionList;
Node _serviceNode = getServiceNode();
int nNode = actionListNode.getNNodes();
for (int n=0; n<nNode; n++) {
Node node = actionListNode.getNode(n);
if (Action.isActionNode(node) == false)
continue;
Action action = new Action(_serviceNode, node);
Action action = new Action(serviceNode, node);
actionList.add(action);
}
return actionList;
@@ -423,6 +500,22 @@ public class Service
return null;
}
public void addAction(Action a){
Iterator i = a.getArgumentList().iterator();
while (i.hasNext()) {
Argument arg = (Argument) i.next();
arg.setService(this);
}
Node scdpNode = getSCPDNode();
Node actionListNode = scdpNode.getNode(ActionList.ELEM_NAME);
if (actionListNode == null){
actionListNode = new Node(ActionList.ELEM_NAME);
scdpNode.addNode(actionListNode);
}
actionListNode.addNode(a.getActionNode());
}
////////////////////////////////////////////////
// serviceStateTable
////////////////////////////////////////////////
@@ -433,13 +526,13 @@ public class Service
Node stateTableNode = getSCPDNode().getNode(ServiceStateTable.ELEM_NAME);
if (stateTableNode == null)
return stateTable;
Node _serviceNode = getServiceNode();
Node serviceNode = getServiceNode();
int nNode = stateTableNode.getNNodes();
for (int n=0; n<nNode; n++) {
Node node = stateTableNode.getNode(n);
if (StateVariable.isStateVariableNode(node) == false)
continue;
StateVariable serviceVar = new StateVariable(_serviceNode, node);
StateVariable serviceVar = new StateVariable(serviceNode, node);
stateTable.add(serviceVar);
}
return stateTable;
@@ -657,6 +750,8 @@ public class Service
subs[n] = subList.getSubscriber(n);
for (int n=0; n<subListCnt; n++) {
Subscriber sub = subs[n];
if (sub == null)
continue;
if (sub.isExpired() == true)
removeSubscriber(sub);
}
@@ -668,6 +763,8 @@ public class Service
subs[n] = subList.getSubscriber(n);
for (int n=0; n<subListCnt; n++) {
Subscriber sub = subs[n];
if (sub == null)
continue;
if (notify(sub, stateVar) == false) {
/* Don't remove for NMPR specification.
removeSubscriber(sub);
@@ -744,4 +841,47 @@ public class Service
action.setActionListener(listener);
}
}
/**
* Add the StateVariable to the service.<br>
* <br>
* Note: This method should be used to create a dynamic<br>
* Device withtout writing any XML that describe the device<br>.
* <br>
* Note: that no control for duplicate StateVariable is done.
*
* @param var StateVariable that will be added
*
* @author Stefano "Kismet" Lenzi - kismet-sl@users.sourceforge.net - 2005
*/
public void addStateVariable(StateVariable var) {
//TODO Some test are done not stable
Node stateTableNode = getSCPDNode().getNode(ServiceStateTable.ELEM_NAME);
if (stateTableNode == null){
stateTableNode = new Node(ServiceStateTable.ELEM_NAME);
/*
* Force the node <serviceStateTable> to be the first node inside <scpd>
*/
//getSCPDNode().insertNode(stateTableNode,0);
getSCPDNode().addNode(stateTableNode);
}
var.setServiceNode(getServiceNode());
stateTableNode.addNode(var.getStateVariableNode());
}
////////////////////////////////////////////////
// userData
////////////////////////////////////////////////
private Object userData = null;
public void setUserData(Object data)
{
userData = data;
}
public Object getUserData()
{
return userData;
}
}

9
router/java/src/org/cybergarage/upnp/ServiceList.java
View File

@@ -3,7 +3,7 @@
* CyberUPnP for Java
*
* Copyright (C) Satoshi Konno 2002
*
*
* File: ServiceList.java
*
* Revision;
@@ -14,10 +14,10 @@
* - Added caching a ArrayIndexOfBound exception.
*
******************************************************************/
package org.cybergarage.upnp;
import java.util.*;
import java.util.Vector;
public class ServiceList extends Vector
{
@@ -25,7 +25,6 @@ public class ServiceList extends Vector
// Constants
////////////////////////////////////////////////
private static final long serialVersionUID = 6372904993975135597L;
public final static String ELEM_NAME = "serviceList";
////////////////////////////////////////////////
@@ -46,7 +45,7 @@ public class ServiceList extends Vector
try {
obj = get(n);
}
catch (Exception e) {}
catch (Exception e) {};
return (Service)obj;
}
}

3
router/java/src/org/cybergarage/upnp/ServiceStateTable.java
View File

@@ -15,7 +15,7 @@
package org.cybergarage.upnp;
import java.util.*;
import java.util.Vector;
public class ServiceStateTable extends Vector
{
@@ -23,7 +23,6 @@ public class ServiceStateTable extends Vector
// Constants
////////////////////////////////////////////////
private static final long serialVersionUID = 7626909231678469365L;
public final static String ELEM_NAME = "serviceStateTable";
////////////////////////////////////////////////

129
router/java/src/org/cybergarage/upnp/StateVariable.java
View File

@@ -39,16 +39,21 @@
* - Fixed setValue() to compare only when the current value is not null.
* 02/28/05
* - Changed getAllowedValueList() to use AllowedValue instead of String as the member.
* 04/12/06
* - Added setUserData() and getUserData() to set a user original data object.
*
******************************************************************/
package org.cybergarage.upnp;
import java.util.Iterator;
import org.cybergarage.xml.*;
import org.cybergarage.util.*;
import org.cybergarage.upnp.control.*;
import org.cybergarage.upnp.xml.*;
import org.cybergarage.upnp.control.QueryListener;
import org.cybergarage.upnp.control.QueryRequest;
import org.cybergarage.upnp.control.QueryResponse;
import org.cybergarage.upnp.xml.NodeData;
import org.cybergarage.upnp.xml.StateVariableData;
import org.cybergarage.util.Debug;
import org.cybergarage.xml.Node;
public class StateVariable extends NodeData
{
@@ -69,13 +74,17 @@ public class StateVariable extends NodeData
{
return serviceNode;
}
void setServiceNode(Node n){
serviceNode=n;
}
public Service getService()
{
Node _serviceNode = getServiceNode();
if (_serviceNode == null)
Node serviceNode = getServiceNode();
if (serviceNode == null)
return null;
return new Service(_serviceNode);
return new Service(serviceNode);
}
public Node getStateVariableNode()
@@ -90,7 +99,7 @@ public class StateVariable extends NodeData
public StateVariable()
{
this.serviceNode = null;
this.stateVariableNode = new Node();
this.stateVariableNode = new Node(ELEM_NAME);
}
public StateVariable(Node serviceNode, Node stateVarNode)
@@ -238,7 +247,7 @@ public class StateVariable extends NodeData
AllowedValueList valueList= new AllowedValueList();
Node valueListNode = getStateVariableNode().getNode(AllowedValueList.ELEM_NAME);
if (valueListNode == null)
return valueList;
return null;
int nNode = valueListNode.getNNodes();
for (int n=0; n<nNode; n++) {
Node node = valueListNode.getNode(n);
@@ -250,10 +259,41 @@ public class StateVariable extends NodeData
return valueList;
}
/**
* This method ovverride the value of the AllowedValueList Node<br>
* of this object. <br>
* <br>
* Note: This method should be used to create a dynamic<br>
* Device withtout writing any XML that describe the device<br>.
* <br>
* Note2: The enforce the constraint of the SCPD rule the<br>
* AllowedValueList and AllowedValueRange are mutal exclusive<br>
* the last set will be the only present<br>
*
* @param avl The new AllowedValueList
*
* @author Stefano "Kismet" Lenzi - kismet-sl@users.sourceforge.net - 2005
*/
public void setAllowedValueList(AllowedValueList avl) {
//TODO Some test done not stable
getStateVariableNode().removeNode(AllowedValueList.ELEM_NAME);
getStateVariableNode().removeNode(AllowedValueRange.ELEM_NAME);
Node n = new Node(AllowedValueList.ELEM_NAME);
Iterator i=avl.iterator();
while (i.hasNext()) {
AllowedValue av = (AllowedValue) i.next();
//n.addNode(new Node(AllowedValue.ELEM_NAME,av.getValue())); wrong!
n.addNode(av.getAllowedValueNode()); //better (twa)
}
getStateVariableNode().addNode(n);
}
public boolean hasAllowedValueList()
{
AllowedValueList valueList = getAllowedValueList();
return (0 < valueList.size()) ? true : false;
return (valueList != null) ? true : false;
}
////////////////////////////////////////////////
@@ -267,6 +307,29 @@ public class StateVariable extends NodeData
return null;
return new AllowedValueRange(valueRangeNode);
}
/**
* This method ovverride the value of the AllowedValueRange Node<br>
* of this object. <br>
* <br>
* Note: This method should be used to create a dynamic<br>
* Device withtout writing any XML that describe the device<br>.
* <br>
* Note2: The enforce the constraint of the SCPD rule the<br>
* AllowedValueList and AllowedValueRange are mutal exclusive<br>
* the last set will be the only present<br>
*
* @param avr The new AllowedValueRange
*
* @author Stefano "Kismet" Lenzi - kismet-sl@users.sourceforge.net - 2005
*/
public void setAllowedValueRange(AllowedValueRange avr){
//TODO Some test done not stable
getStateVariableNode().removeNode(AllowedValueList.ELEM_NAME);
getStateVariableNode().removeNode(AllowedValueRange.ELEM_NAME);
getStateVariableNode().addNode(avr.getAllowedValueRangeNode());
}
public boolean hasAllowedValueRange()
{
@@ -301,8 +364,8 @@ public class StateVariable extends NodeData
queryRes.setResponse(retVar);
}
else {
UPnPStatus _upnpStatus = retVar.getStatus();
queryRes.setFaultResponse(_upnpStatus.getCode(), _upnpStatus.getDescription());
UPnPStatus upnpStatus = retVar.getStatus();
queryRes.setFaultResponse(upnpStatus.getCode(), upnpStatus.getDescription());
}
queryReq.post(queryRes);
return true;
@@ -371,4 +434,44 @@ public class StateVariable extends NodeData
{
return upnpStatus;
}
private static final String DEFAULT_VALUE = "defaultValue";
////////////////////////////////////////////////
/**
* Get the value of DefaultValue of this StateVariable
*
* @author Stefano Lenzi kismet-sl@users.sourceforge.net
*/
public String getDefaultValue() {
return getStateVariableNode().getNodeValue(DEFAULT_VALUE);
}
/**
* This method ovverride the value of the DefaultValue of this object. <br>
* <br>
* Note: This method should be used to create a dynamic<br>
* Device withtout writing any XML that describe the device<br>.
*
* @param value The new String value
*
* @author Stefano Lenzi kismet-sl@users.sourceforge.net
*/
public void setDefaultValue(String value){
getStateVariableNode().setNode(DEFAULT_VALUE,value);
}
////////////////////////////////////////////////
// userData
////////////////////////////////////////////////
private Object userData = null;
public void setUserData(Object data)
{
userData = data;
}
public Object getUserData()
{
return userData;
}
}

129
router/java/src/org/cybergarage/upnp/UPnP.java
View File

@@ -5,54 +5,64 @@
* Copyright (C) Satoshi Konno 2002-2003
*
* File: UPnP.java
*
* Revision;
*
* 11/18/02
* - first revision.
*
* Revision;
*
* 11/18/02
* - first revision.
* 05/13/03
* - Added support for IPv6 and loopback address.
* 12/26/03
* - Added support for XML Parser
* 06/18/03
* - Added INMPR03 and INMPR03_VERSION.
* 04/14/06
* - Added some functios about time-to-live, and the default value is 4.
* 05/11/09
* - Changed loadDefaultXMLParser() to load org.cybergarage.xml.parser.XmlPullParser at first.
*
******************************************************************/
package org.cybergarage.upnp;
import org.cybergarage.upnp.ssdp.*;
//import org.cybergarage.util.*;
import org.cybergarage.xml.*;
import org.cybergarage.xml.parser.*;
import org.cybergarage.soap.*;
import org.cybergarage.net.*;
package org.cybergarage.upnp;
public class UPnP
{
////////////////////////////////////////////////
// Constants
////////////////////////////////////////////////
public final static String NAME = "CyberLink";
public final static String VERSION = "1.7";
import org.cybergarage.net.HostInterface;
import org.cybergarage.soap.SOAP;
import org.cybergarage.upnp.ssdp.SSDP;
import org.cybergarage.util.Debug;
import org.cybergarage.xml.Parser;
public class UPnP
{
////////////////////////////////////////////////
// Constants
////////////////////////////////////////////////
/**
* Name of the system properties used to identifies the default XML Parser.<br>
* The value of the properties MUST BE the fully qualified class name of<br>
* XML Parser which CyberLink should use.
*/
public final static String XML_CLASS_PROPERTTY="cyberlink.upnp.xml.parser";
public final static String NAME = "CyberLinkJava";
public final static String VERSION = "1.8";
// I2P was 100
public final static int SERVER_RETRY_COUNT = 4;
public final static int DEFAULT_EXPIRED_DEVICE_EXTRA_TIME = 60;
public final static String getServerName()
public final static String getServerName()
{
String osName = System.getProperty("os.name");
String osVer = System.getProperty("os.version");
return osName + "/" + osVer + " UPnP/1.0 " + NAME + "/" + VERSION;
}
return osName + "/" + osVer + " UPnP/1.0 " + NAME + "/" + VERSION;
}
public final static String INMPR03 = "INMPR03";
public final static String INMPR03_VERSION = "1.0";
public final static int INMPR03_DISCOVERY_OVER_WIRELESS_COUNT = 4;
public final static String XML_DECLARATION = "<?xml version=\"1.0\"?>";
public final static String XML_DECLARATION = "<?xml version=\"1.0\" encoding=\"utf-8\"?>";
////////////////////////////////////////////////
// Enable / Disable
@@ -194,8 +204,67 @@ public class UPnP
public final static Parser getXMLParser()
{
if(xmlParser == null){
xmlParser = loadDefaultXMLParser();
if(xmlParser == null)
throw new RuntimeException("No XML parser defined. And unable to laod any. \n" +
"Try to invoke UPnP.setXMLParser before UPnP.getXMLParser");
SOAP.setXMLParser(xmlParser);
}
return xmlParser;
}
/**
* This method loads the default XML Parser using the following behavior:
* - First if present loads the parsers specified by the system property {@link UPnP#XML_CLASS_PROPERTTY}<br>
* - Second by a fall-back technique, it tries to load the XMLParser from one<br>
* of the following classes: {@link JaxpParser}, {@link kXML2Parser}, {@link XercesParser}
*
* @return {@link Parser} which has been loaded successuflly or null otherwise
*
* @since 1.8.0
*/
private static Parser loadDefaultXMLParser() {
Parser parser = null;
String[] parserClass = new String[]{
System.getProperty(XML_CLASS_PROPERTTY),
"org.cybergarage.xml.parser.XmlPullParser",
"org.cybergarage.xml.parser.JaxpParser",
"org.cybergarage.xml.parser.kXML2Parser",
"org.cybergarage.xml.parser.XercesParser"
};
for (int i = 0; i < parserClass.length; i++) {
if(parserClass[i]==null)
continue;
try {
parser = (Parser) Class.forName(parserClass[i]).newInstance();
return parser;
} catch (Throwable e) {
Debug.warning("Unable to load "+parserClass[i]+" as XMLParser due to "+e);
}
}
return null;
}
////////////////////////////////////////////////
// TTL
////////////////////////////////////////////////
public final static int DEFAULT_TTL = 4;
private static int timeToLive = DEFAULT_TTL;
public final static void setTimeToLive(int value)
{
timeToLive = value;
}
public final static int getTimeToLive()
{
return timeToLive;
}
////////////////////////////////////////////////
// Initialize
@@ -207,16 +276,14 @@ public class UPnP
// Interface Option
////////////////////////////
setXMLParser(new JaxpParser());
//setXMLParser(new kXML2Parser());
////////////////////////////
// Interface Option
// TimeToLive
////////////////////////////
/*
if (HostInterface.hasIPv6Addresses() == true)
setEnable(USE_ONLY_IPV6_ADDR);
*/
setTimeToLive(DEFAULT_TTL);
////////////////////////////
// Debug Option

3
router/java/src/org/cybergarage/upnp/UPnPStatus.java
View File

@@ -16,6 +16,7 @@
******************************************************************/
package org.cybergarage.upnp;
import org.cybergarage.http.HTTPStatus;
public class UPnPStatus
{
@@ -39,8 +40,8 @@ public class UPnPStatus
case INVALID_VAR: return "Invalid Var";
case PRECONDITION_FAILED: return "Precondition Failed";
case ACTION_FAILED: return "Action Failed";
default: return HTTPStatus.code2String(code);
}
return "";
}
////////////////////////////////////////////////

5
router/java/src/org/cybergarage/upnp/control/ControlResponse.java
View File

@@ -102,6 +102,11 @@ public class ControlResponse extends SOAPResponse
return faultNode;
}
private Node createFaultResponseNode(int errCode)
{
return createFaultResponseNode(errCode, UPnPStatus.code2String(errCode));
}
////////////////////////////////////////////////
// UPnP Error
////////////////////////////////////////////////

2
router/java/src/org/cybergarage/upnp/control/QueryRequest.java
View File

@@ -74,6 +74,8 @@ public class QueryRequest extends ControlRequest
{
Service service = stateVar.getService();
String ctrlURL = service.getControlURL();
setRequestHost(service);
setEnvelopeNode(SOAP.createEnvelopeBodyNode());

1
router/java/src/org/cybergarage/upnp/control/RenewSubscriber.java
View File

@@ -51,7 +51,6 @@ public class RenewSubscriber extends ThreadCore
// Thread
////////////////////////////////////////////////
@Override
public void run()
{
ControlPoint ctrlp = getControlPoint();

1
router/java/src/org/cybergarage/upnp/device/Advertiser.java
View File

@@ -51,7 +51,6 @@ public class Advertiser extends ThreadCore
// Thread
////////////////////////////////////////////////
@Override
public void run()
{
Device dev = getDevice();

1
router/java/src/org/cybergarage/upnp/device/Disposer.java
View File

@@ -49,7 +49,6 @@ public class Disposer extends ThreadCore
// Thread
////////////////////////////////////////////////
@Override
public void run()
{
Thread.currentThread().setName("UPnP-Disposer");

2
router/java/src/org/cybergarage/upnp/device/InvalidDescriptionException.java
View File

@@ -19,8 +19,6 @@ import java.io.*;
public class InvalidDescriptionException extends Exception
{
private static final long serialVersionUID = -3144583349586910509L;
public InvalidDescriptionException()
{
super();

14
router/java/src/org/cybergarage/upnp/event/NotifyRequest.java
View File

@@ -115,6 +115,7 @@ public class NotifyRequest extends SOAPRequest
public boolean setRequest(Subscriber sub, String varName, String value)
{
String callback = sub.getDeliveryURL();
String sid = sub.getSID();
long notifyCnt = sub.getNotifyCount();
String host = sub.getDeliveryHost();
@@ -154,6 +155,19 @@ public class NotifyRequest extends SOAPRequest
return propSetNode;
}
private Node getVariableNode()
{
Node rootNode = getEnvelopeNode();
if (rootNode == null)
return null;
if (rootNode.hasNodes() == false)
return null;
Node propNode = rootNode.getNode(0);
if (propNode.hasNodes() == false)
return null;
return propNode.getNode(0);
}
// Thanks for Giordano Sassaroli <sassarol@cefriel.it> (09/08/03)
private Property getProperty(Node varNode)
{

1
router/java/src/org/cybergarage/upnp/event/PropertyList.java
View File

@@ -23,7 +23,6 @@ public class PropertyList extends Vector
// Constants
////////////////////////////////////////////////
private static final long serialVersionUID = 8718064210738306226L;
public final static String ELEM_NAME = "PropertyList";
////////////////////////////////////////////////

2
router/java/src/org/cybergarage/upnp/event/SubscriberList.java
View File

@@ -25,8 +25,6 @@ public class SubscriberList extends Vector
// Constructor
////////////////////////////////////////////////
private static final long serialVersionUID = -648427977601494972L;
public SubscriberList()
{
}

2
router/java/src/org/cybergarage/upnp/event/Subscription.java
View File

@@ -68,6 +68,8 @@ public class Subscription
{
if (headerValue == null)
return "";
if (headerValue.startsWith(Subscription.UUID) == false)
return headerValue;
return headerValue.substring(Subscription.UUID.length(), headerValue.length());
}

8
router/java/src/org/cybergarage/upnp/event/SubscriptionRequest.java
View File

@@ -43,12 +43,12 @@ public class SubscriptionRequest extends HTTPRequest
// Constructor
////////////////////////////////////////////////
public SubscriptionRequest()
{
public SubscriptionRequest(){
setContentLength(0);
}
public SubscriptionRequest(HTTPRequest httpReq)
{
public SubscriptionRequest(HTTPRequest httpReq){
this();
set(httpReq);
}

119
router/java/src/org/cybergarage/upnp/ssdp/HTTPMUSocket.java
View File

@@ -19,16 +19,32 @@
* 11/19/04
* - Theo Beisch <theo.beisch@gmx.de>
* - Changed send() to set the TTL as 4.
* 08/23/07
* - Thanks for Kazuyuki Shudo
* - Changed receive() to throw IOException.
* 01/10/08
* - Changed getLocalAddress() to return a brank string when the ssdpMultiGroup or ssdpMultiIf is null on Android m3-rc37a.
*
******************************************************************/
package org.cybergarage.upnp.ssdp;
import java.net.*;
import java.util.*;
import java.net.DatagramPacket;
import java.net.MulticastSocket;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.NetworkInterface;
import java.util.Enumeration;
import java.io.IOException;
import org.cybergarage.http.*;
import org.cybergarage.util.*;
import org.cybergarage.http.HTTPRequest;
import org.cybergarage.upnp.UPnP;
import org.cybergarage.util.Debug;
// Dummy Class for Android m3-rc37a
// import org.cybergarage.android.MulticastSocket;
public class HTTPMUSocket
{
@@ -39,7 +55,7 @@ public class HTTPMUSocket
private InetSocketAddress ssdpMultiGroup = null;
private MulticastSocket ssdpMultiSock = null;
private NetworkInterface ssdpMultiIf = null;
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
@@ -53,7 +69,6 @@ public class HTTPMUSocket
open(addr, port, bindAddr);
}
@Override
protected void finalize()
{
close();
@@ -65,6 +80,8 @@ public class HTTPMUSocket
public String getLocalAddress()
{
if (ssdpMultiGroup == null || ssdpMultiIf == null)
return "";
InetAddress mcastAddr = ssdpMultiGroup.getAddress();
Enumeration addrs = ssdpMultiIf.getInetAddresses();
while (addrs.hasMoreElements()) {
@@ -77,6 +94,34 @@ public class HTTPMUSocket
return "";
}
/**
*
* @return the destination port for multicast packet
* @since 1.8
*/
public int getMulticastPort(){
return ssdpMultiGroup.getPort();
}
/**
*
* @return the source port for multicast packet
* @since 1.8
*/
public int getLocalPort(){
return ssdpMultiSock.getLocalPort();
}
/**
*
* @return the opened {@link MulticastSocket}
* @since 1.8
*/
public MulticastSocket getSocket(){
return ssdpMultiSock;
}
////////////////////////////////////////////////
// MulticastAddr
////////////////////////////////////////////////
@@ -91,19 +136,20 @@ public class HTTPMUSocket
return getMulticastInetAddress().getHostAddress();
}
////////////////////////////////////////////////
// open/close
////////////////////////////////////////////////
public boolean open(String addr, int port, String bindAddr)
{
/**
* @param addr {@link String} rappresenting the multicast hostname to join into.
* @param port int rappresenting the port to be use poth as source and destination
* @param bindAddr {@link InetAddress} which identify the hostname of the interface
* to use for sending and recieving multicast packet
*/
public boolean open(String addr,int port, InetAddress bindAddr){
try {
ssdpMultiSock = new MulticastSocket(null);
ssdpMultiSock.setReuseAddress(true);
InetSocketAddress bindSockAddr = new InetSocketAddress(port);
ssdpMultiSock.bind(bindSockAddr);
ssdpMultiGroup = new InetSocketAddress(InetAddress.getByName(addr), port);
ssdpMultiIf = NetworkInterface.getByInetAddress(InetAddress.getByName(bindAddr));
ssdpMultiIf = NetworkInterface.getByInetAddress(bindAddr);
ssdpMultiSock.joinGroup(ssdpMultiGroup, ssdpMultiIf);
}
catch (Exception e) {
@@ -111,7 +157,17 @@ public class HTTPMUSocket
return false;
}
return true;
return true;
}
public boolean open(String addr, int port, String bindAddr)
{
try {
return open(addr,port,InetAddress.getByName(bindAddr));
}catch (Exception e) {
Debug.warning(e);
return false;
}
}
public boolean close()
@@ -120,9 +176,8 @@ public class HTTPMUSocket
return true;
try {
// I2P close it instead of leaving group so the thread dies
//ssdpMultiSock.leaveGroup(ssdpMultiGroup, ssdpMultiIf);
ssdpMultiSock.close();
ssdpMultiSock.leaveGroup(ssdpMultiGroup, ssdpMultiIf);
ssdpMultiSock.close();
ssdpMultiSock = null;
}
catch (Exception e) {
@@ -144,12 +199,12 @@ public class HTTPMUSocket
if ((bindAddr) != null && (0 < bindPort)) {
msock = new MulticastSocket(null);
msock.bind(new InetSocketAddress(bindAddr, bindPort));
}
else
}else{
msock = new MulticastSocket();
}
DatagramPacket dgmPacket = new DatagramPacket(msg.getBytes(), msg.length(), ssdpMultiGroup);
// Thnaks for Tho Beisch (11/09/04)
msock.setTimeToLive(4);
// Thnaks for Theo Beisch (11/09/04)
msock.setTimeToLive(UPnP.getTimeToLive());
msock.send(dgmPacket);
msock.close();
}
@@ -183,20 +238,22 @@ public class HTTPMUSocket
// reveive
////////////////////////////////////////////////
public SSDPPacket receive()
public SSDPPacket receive() throws IOException
{
byte ssdvRecvBuf[] = new byte[SSDP.RECV_MESSAGE_BUFSIZE];
SSDPPacket recvPacket = new SSDPPacket(ssdvRecvBuf, ssdvRecvBuf.length);
recvPacket.setLocalAddress(getLocalAddress());
try {
ssdpMultiSock.receive(recvPacket.getDatagramPacket());
recvPacket.setTimeStamp(System.currentTimeMillis());
Debug.message("Received SSDP multicast packet on " + getLocalAddress() + " from " + recvPacket.getRemoteAddress());
}
catch (Exception e) {
//Debug.warning(e);
}
return recvPacket;
// Thanks for Kazuyuki Shudo (08/23/07)
// Thanks for Stephan Mehlhase (2010-10-26)
if (ssdpMultiSock != null)
ssdpMultiSock.receive(recvPacket.getDatagramPacket()); // throws IOException
else
throw new IOException("Multicast socket has already been closed.");
recvPacket.setTimeStamp(System.currentTimeMillis());
return recvPacket;
}
}

212
router/java/src/org/cybergarage/upnp/ssdp/HTTPUSocket.java
View File

@@ -5,11 +5,11 @@
* Copyright (C) Satoshi Konno 2002-2003
*
* File: HTTPMU.java
*
* Revision;
*
* 11/20/02
* - first revision.
*
* Revision;
*
* 11/20/02
* - first revision.
* 12/12/03
* - Inma Mar?n <inma@DIF.UM.ES>
* - Changed open(addr, port) to send IPv6 SSDP packets.
@@ -20,47 +20,49 @@
* - Added to set a current timestamp when the packet are received.
*
******************************************************************/
package org.cybergarage.upnp.ssdp;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.InetSocketAddress;
package org.cybergarage.upnp.ssdp;
import java.net.*;
import org.cybergarage.util.*;
public class HTTPUSocket
{
////////////////////////////////////////////////
// Member
////////////////////////////////////////////////
private DatagramSocket ssdpUniSock = null;
import org.cybergarage.util.Debug;
public class HTTPUSocket
{
////////////////////////////////////////////////
// Member
////////////////////////////////////////////////
private DatagramSocket ssdpUniSock = null;
//private MulticastSocket ssdpUniSock = null;
public DatagramSocket getDatagramSocket()
{
return ssdpUniSock;
}
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public HTTPUSocket()
public DatagramSocket getDatagramSocket()
{
return ssdpUniSock;
}
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public HTTPUSocket()
{
open();
}
public HTTPUSocket(String bindAddr, int bindPort)
}
public HTTPUSocket(String bindAddr, int bindPort)
{
open(bindAddr, bindPort);
}
}
public HTTPUSocket(int bindPort)
{
open(bindPort);
}
@Override
protected void finalize()
{
close();
@@ -76,6 +78,15 @@ public class HTTPUSocket
{
localAddr = addr;
}
/**
*
* @return {@link DatagramSocket} open for receieving packets
* @since 1.8
*/
public DatagramSocket getUDPSocket(){
return ssdpUniSock;
}
public String getLocalAddress()
{
@@ -108,16 +119,29 @@ public class HTTPUSocket
close();
try {
// Bind only using the port without the interface address. (2003/12/12)
InetSocketAddress bindSock = new InetSocketAddress(/*InetAddress.getByName(bindAddr), */ bindPort);
ssdpUniSock = new DatagramSocket(null);
ssdpUniSock.setReuseAddress(true);
ssdpUniSock.bind(bindSock);
// Changed to bind the specified address and port for Android v1.6 (2009/10/07)
InetSocketAddress bindInetAddr = new InetSocketAddress(InetAddress.getByName(bindAddr), bindPort);
ssdpUniSock = new DatagramSocket(bindInetAddr);
}
catch (Exception e) {
Debug.warning(e);
return false;
}
/*
try {
// Bind only using the port without the interface address. (2003/12/12)
InetSocketAddress bindInetAddr = new InetSocketAddress(bindPort);
ssdpUniSock = new DatagramSocket(null);
ssdpUniSock.setReuseAddress(true);
ssdpUniSock.bind(bindInetAddr);
return true;
}
catch (Exception e) {
Debug.warning(e);
return false;
}
*/
setLocalAddress(bindAddr);
@@ -142,67 +166,67 @@ public class HTTPUSocket
return true;
}
////////////////////////////////////////////////
// close
////////////////////////////////////////////////
public boolean close()
{
if (ssdpUniSock == null)
return true;
try {
////////////////////////////////////////////////
// close
////////////////////////////////////////////////
public boolean close()
{
if (ssdpUniSock == null)
return true;
try {
ssdpUniSock.close();
ssdpUniSock = null;
}
catch (Exception e) {
Debug.warning(e);
return false;
}
return true;
}
ssdpUniSock = null;
}
catch (Exception e) {
Debug.warning(e);
return false;
}
return true;
}
////////////////////////////////////////////////
// send
////////////////////////////////////////////////
public boolean post(String addr, int port, String msg)
{
try {
InetAddress inetAddr = InetAddress.getByName(addr);
DatagramPacket dgmPacket = new DatagramPacket(msg.getBytes(), msg.length(), inetAddr, port);
////////////////////////////////////////////////
// send
////////////////////////////////////////////////
public boolean post(String addr, int port, String msg)
{
try {
InetAddress inetAddr = InetAddress.getByName(addr);
DatagramPacket dgmPacket = new DatagramPacket(msg.getBytes(), msg.length(), inetAddr, port);
ssdpUniSock.send(dgmPacket);
}
}
catch (Exception e) {
Debug.warning("addr = " +ssdpUniSock.getLocalAddress().getHostName());
Debug.warning("addr = " +ssdpUniSock.getLocalAddress().getHostName());
Debug.warning("port = " + ssdpUniSock.getLocalPort());
Debug.warning(e);
return false;
}
return true;
}
////////////////////////////////////////////////
// reveive
////////////////////////////////////////////////
public SSDPPacket receive()
{
byte ssdvRecvBuf[] = new byte[SSDP.RECV_MESSAGE_BUFSIZE];
SSDPPacket recvPacket = new SSDPPacket(ssdvRecvBuf, ssdvRecvBuf.length);
Debug.warning(e);
return false;
}
return true;
}
////////////////////////////////////////////////
// reveive
////////////////////////////////////////////////
public SSDPPacket receive()
{
byte ssdvRecvBuf[] = new byte[SSDP.RECV_MESSAGE_BUFSIZE];
SSDPPacket recvPacket = new SSDPPacket(ssdvRecvBuf, ssdvRecvBuf.length);
recvPacket.setLocalAddress(getLocalAddress());
try {
ssdpUniSock.receive(recvPacket.getDatagramPacket());
try {
ssdpUniSock.receive(recvPacket.getDatagramPacket());
recvPacket.setTimeStamp(System.currentTimeMillis());
Debug.message("Received SSDP unicast packet on " + getLocalAddress() + " from " + recvPacket.getRemoteAddress());
}
catch (Exception e) {
}
catch (Exception e) {
//Debug.warning(e);
return null;
}
return recvPacket;
}
return null;
}
return recvPacket;
}
////////////////////////////////////////////////
// join/leave
@@ -237,5 +261,5 @@ public class HTTPUSocket
return true;
}
*/
}
}

98
router/java/src/org/cybergarage/upnp/ssdp/SSDP.java
View File

@@ -5,27 +5,49 @@
* Copyright (C) Satoshi Konno 2002
*
* File: SSDP.java
*
* Revision;
*
* 11/18/02
* - first revision.
*
* Revision;
*
* 11/18/02
* - first revision.
* 05/13/03
* - Added constants for IPv6.
* 08/03/05
* - Thanks for Stefano Lenzi <kismet-sl at users.sourceforge.net>
* and Mikael <mhakman at users.sourceforge.net>
* - Fixed getLeaseTime() to parse normally when the value includes extra strings such as white space.
*
******************************************************************/
package org.cybergarage.upnp.ssdp;
public class SSDP
{
////////////////////////////////////////////////
// Constants
////////////////////////////////////////////////
public static final int PORT = 1900;
public static final String ADDRESS = "239.255.255.250";
package org.cybergarage.upnp.ssdp;
import org.cybergarage.util.Debug;
/**
*
* This class defines constant value related to SSDP.<br>
* All the values defined here are complaint to the UPnP Standard
*
* @author Satoshi "skonno" Konno
* @author Stefano "Kismet" Lenzi
* @version 1.0
*
*/
public class SSDP
{
////////////////////////////////////////////////
// Constants
////////////////////////////////////////////////
/**
* Default destination port for SSDP multicast messages
*/
public static final int PORT = 1900;
/**
* Default IPv4 multicast address for SSDP messages
*/
public static final String ADDRESS = "239.255.255.250";
public static final String IPV6_LINK_LOCAL_ADDRESS = "FF02::C";
public static final String IPV6_SUBNET_ADDRESS = "FF03::C";
@@ -37,7 +59,7 @@ public class SSDP
public static final void setIPv6Address(String addr)
{
IPV6_ADDRESS = addr;
IPV6_ADDRESS = addr;
}
public static final String getIPv6Address()
@@ -45,9 +67,9 @@ public class SSDP
return IPV6_ADDRESS;
}
public static final int DEFAULT_MSEARCH_MX = 3;
public static final int RECV_MESSAGE_BUFSIZE = 1024;
public static final int DEFAULT_MSEARCH_MX = 3;
public static final int RECV_MESSAGE_BUFSIZE = 1024;
////////////////////////////////////////////////
// Initialize
@@ -61,17 +83,27 @@ public class SSDP
////////////////////////////////////////////////
// LeaseTime
////////////////////////////////////////////////
public final static int getLeaseTime(String cacheCont)
{
int equIdx = cacheCont.indexOf('=');
int mx = 0;
try {
String mxStr = new String(cacheCont.getBytes(), equIdx+1, cacheCont.length() - (equIdx+1));
mx = Integer.parseInt(mxStr);
}
catch (Exception e) {}
return mx;
public final static int getLeaseTime(String cacheCont){
/*
* Search for max-age keyword instead of equals sign Found value of
* max-age ends at next comma or end of string
*/
int mx = 0;
int maxAgeIdx = cacheCont.indexOf("max-age");
if (maxAgeIdx >= 0) {
int endIdx = cacheCont.indexOf(',',maxAgeIdx);
if (endIdx < 0)
endIdx = cacheCont.length();
try {
maxAgeIdx = cacheCont.indexOf("=",maxAgeIdx);
String mxStr = cacheCont.substring(maxAgeIdx+1,endIdx).trim();
mx = Integer.parseInt(mxStr);
} catch (Exception e) {
Debug.warning (e);
}
}
return mx;
}
}

2
router/java/src/org/cybergarage/upnp/ssdp/SSDPNotifyRequest.java
View File

@@ -15,7 +15,7 @@
package org.cybergarage.upnp.ssdp;
import org.cybergarage.http.*;
import org.cybergarage.http.HTTP;
public class SSDPNotifyRequest extends SSDPRequest
{

54
router/java/src/org/cybergarage/upnp/ssdp/SSDPNotifySocket.java
View File

@@ -19,18 +19,34 @@
* - Mikael Hakman <mhakman@dkab.net>
* - Handle receive() returning null.
* - Added close() in stop().
* 08/23/07
* - Thanks for Kazuyuki Shudo
* - Changed run() to catch IOException of HTTPMUSocket::receive().
* 01/31/08
* - Changed start() not to abort when the interface infomation is null on Android m3-rc37a.
*
******************************************************************/
package org.cybergarage.upnp.ssdp;
import java.net.*;
import java.io.IOException;
import org.cybergarage.net.*;
import org.cybergarage.util.*;
import org.cybergarage.http.*;
import org.cybergarage.upnp.*;
import org.cybergarage.util.Debug;
/**
*
* This class identifies a SSDP socket only for <b>notifing packet</b>.<br>
*
* @author Satoshi "skonno" Konno
* @author Stefano "Kismet" Lenzi
* @version 1.8
*
*/
public class SSDPNotifySocket extends HTTPMUSocket implements Runnable
{
private boolean useIPv6Address;
@@ -68,10 +84,13 @@ public class SSDPNotifySocket extends HTTPMUSocket implements Runnable
return controlPoint;
}
////////////////////////////////////////////////
// post (SSDPNotifySocket)
////////////////////////////////////////////////
/**
* This method send a {@link SSDPNotifyRequest} over {@link SSDPNotifySocket}
*
* @param req the {@link SSDPNotifyRequest} to send
* @return true if and only if the trasmission succeced<br>
* Because it rely on UDP doesn't mean that it's also recieved
*/
public boolean post(SSDPNotifyRequest req)
{
String ssdpAddr = SSDP.ADDRESS;
@@ -95,7 +114,15 @@ public class SSDPNotifySocket extends HTTPMUSocket implements Runnable
while (deviceNotifyThread == thisThread) {
Thread.yield();
SSDPPacket packet = receive();
// Thanks for Kazuyuki Shudo (08/23/07)
SSDPPacket packet = null;
try {
packet = receive();
}
catch (IOException e) {
break;
}
// Thanks for Mikael Hakman (04/20/05)
if (packet == null)
@@ -109,16 +136,23 @@ public class SSDPNotifySocket extends HTTPMUSocket implements Runnable
//Debug.warning("Invalidate Multicast Recieved : " + maddr + "," + pmaddr);
continue;
}
//TODO Must be performed on a different Thread in order to prevent UDP packet losses.
if (ctrlPoint != null)
ctrlPoint.notifyReceived(packet);
}
}
public void start()
{
deviceNotifyThread = new Thread(this, "UPnP-SSDPNotifySocket");
deviceNotifyThread.setDaemon(true);
public void start(){
StringBuffer name = new StringBuffer("Cyber.SSDPNotifySocket/");
String localAddr = this.getLocalAddress();
// localAddr is null on Android m3-rc37a (01/30/08)
if (localAddr != null && 0 < localAddr.length()) {
name.append(this.getLocalAddress()).append(':');
name.append(this.getLocalPort()).append(" -> ");
name.append(this.getMulticastAddress()).append(':');
name.append(this.getMulticastPort());
}
deviceNotifyThread = new Thread(this,name.toString());
deviceNotifyThread.start();
}

231
router/java/src/org/cybergarage/upnp/ssdp/SSDPNotifySocketList.java
View File

@@ -1,106 +1,129 @@
/******************************************************************
*
* CyberUPnP for Java
*
* Copyright (C) Satoshi Konno 2002-2003
/******************************************************************
*
* File: HTTPServerList.java
*
* Revision;
*
* 05/11/03
* - first revision.
*
******************************************************************/
* CyberUPnP for Java
*
* Copyright (C) Satoshi Konno 2002-2003
*
* File: HTTPServerList.java
*
* Revision;
*
* 05/11/03
* - first revision.
*
******************************************************************/
package org.cybergarage.upnp.ssdp;
import java.net.InetAddress;
import java.util.*;
import org.cybergarage.net.*;
import org.cybergarage.upnp.*;
public class SSDPNotifySocketList extends Vector
{
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
private InetAddress[] binds = null;
public SSDPNotifySocketList() {
}
/**
*
* @param binds The host to bind the service <tt>null</tt> means to bind to default.
* @since 1.8
*/
public SSDPNotifySocketList(InetAddress[] binds){
this.binds=binds;
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public SSDPNotifySocket getSSDPNotifySocket(int n)
{
return (SSDPNotifySocket)get(n);
}
////////////////////////////////////////////////
// ControlPoint
////////////////////////////////////////////////
public void setControlPoint(ControlPoint ctrlPoint)
{
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPNotifySocket sock = getSSDPNotifySocket(n);
sock.setControlPoint(ctrlPoint);
}
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public boolean open(){
InetAddress[] binds=this.binds ;
String[] bindAddresses;
if(binds!=null){
bindAddresses = new String[binds.length];
for (int i = 0; i < binds.length; i++) {
bindAddresses[i] = binds[i].getHostAddress();
}
}else{
int nHostAddrs = HostInterface.getNHostAddresses();
bindAddresses = new String[nHostAddrs];
for (int n=0; n<nHostAddrs; n++) {
bindAddresses[n] = HostInterface.getHostAddress(n);
}
}
for (int i = 0; i < bindAddresses.length; i++) {
if(bindAddresses[i]!=null){
SSDPNotifySocket ssdpNotifySocket = new SSDPNotifySocket(bindAddresses[i]);
add(ssdpNotifySocket);
}
}
return true;
}
public void close()
{
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPNotifySocket sock = getSSDPNotifySocket(n);
sock.close();
}
clear();
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public void start()
{
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPNotifySocket sock = getSSDPNotifySocket(n);
sock.start();
}
}
public void stop()
{
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPNotifySocket sock = getSSDPNotifySocket(n);
sock.stop();
}
}
}
package org.cybergarage.upnp.ssdp;
import java.util.*;
import org.cybergarage.net.*;
import org.cybergarage.upnp.*;
public class SSDPNotifySocketList extends Vector
{
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
private static final long serialVersionUID = -7066290881503106399L;
public SSDPNotifySocketList()
{
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public SSDPNotifySocket getSSDPNotifySocket(int n)
{
return (SSDPNotifySocket)get(n);
}
////////////////////////////////////////////////
// ControlPoint
////////////////////////////////////////////////
public void setControlPoint(ControlPoint ctrlPoint)
{
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPNotifySocket sock = getSSDPNotifySocket(n);
sock.setControlPoint(ctrlPoint);
}
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public boolean open()
{
int nHostAddrs = HostInterface.getNHostAddresses();
for (int n=0; n<nHostAddrs; n++) {
String bindAddr = HostInterface.getHostAddress(n);
SSDPNotifySocket ssdpNotifySocket = new SSDPNotifySocket(bindAddr);
add(ssdpNotifySocket);
}
return true;
}
public void close()
{
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPNotifySocket sock = getSSDPNotifySocket(n);
sock.close();
}
clear();
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public void start()
{
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPNotifySocket sock = getSSDPNotifySocket(n);
sock.start();
}
}
public void stop()
{
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPNotifySocket sock = getSSDPNotifySocket(n);
sock.stop();
}
}
}

301
router/java/src/org/cybergarage/upnp/ssdp/SSDPPacket.java
View File

@@ -5,11 +5,11 @@
* Copyright (C) Satoshi Konno 2002-2003
*
* File: SSDPPacket.java
*
* Revision;
*
* 11/18/02
* - first revision.
*
* Revision;
*
* 11/18/02
* - first revision.
* 05/13/03
* - Added getLocalAddress().
* 11/01/04
@@ -20,25 +20,25 @@
* - Changed getRemoteAddress() to return the adresss instead of the host name.
*
******************************************************************/
package org.cybergarage.upnp.ssdp;
import java.net.*;
package org.cybergarage.upnp.ssdp;
import java.net.*;
import org.cybergarage.http.*;
import org.cybergarage.upnp.device.*;
public class SSDPPacket
{
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public SSDPPacket(byte[] buf, int length)
{
dgmPacket = new DatagramPacket(buf, length);
}
import org.cybergarage.upnp.device.*;
public class SSDPPacket
{
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public SSDPPacket(byte[] buf, int length)
{
dgmPacket = new DatagramPacket(buf, length);
}
////////////////////////////////////////////////
// DatagramPacket
@@ -68,115 +68,115 @@ public class SSDPPacket
}
////////////////////////////////////////////////
// Time
////////////////////////////////////////////////
private long timeStamp;
public void setTimeStamp(long value)
{
timeStamp = value;
}
public long getTimeStamp()
{
return timeStamp;
}
////////////////////////////////////////////////
// Remote host
////////////////////////////////////////////////
////////////////////////////////////////////////
// Time
////////////////////////////////////////////////
private long timeStamp;
public void setTimeStamp(long value)
{
timeStamp = value;
}
public long getTimeStamp()
{
return timeStamp;
}
////////////////////////////////////////////////
// Remote host
////////////////////////////////////////////////
public InetAddress getRemoteInetAddress()
{
return getDatagramPacket().getAddress();
}
public String getRemoteAddress()
{
public String getRemoteAddress()
{
// Thanks for Theo Beisch (11/09/04)
return getDatagramPacket().getAddress().getHostAddress();
}
public int getRemotePort()
{
return getDatagramPacket().getPort();
}
////////////////////////////////////////////////
// Access Methods
////////////////////////////////////////////////
public byte[] packetBytes = null;
public byte[] getData()
{
if (packetBytes != null)
return packetBytes;
DatagramPacket packet = getDatagramPacket();
int packetLen = packet.getLength();
String packetData = new String(packet.getData(), 0, packetLen);
packetBytes = packetData.getBytes();
return packetBytes;
}
////////////////////////////////////////////////
// Access Methods
////////////////////////////////////////////////
public String getHost()
{
return HTTPHeader.getValue(getData(), HTTP.HOST);
}
public String getCacheControl()
{
return HTTPHeader.getValue(getData(), HTTP.CACHE_CONTROL);
}
public String getLocation()
{
return HTTPHeader.getValue(getData(), HTTP.LOCATION);
}
public String getMAN()
{
return HTTPHeader.getValue(getData(), HTTP.MAN);
}
return getDatagramPacket().getAddress().getHostAddress();
}
public int getRemotePort()
{
return getDatagramPacket().getPort();
}
////////////////////////////////////////////////
// Access Methods
////////////////////////////////////////////////
public byte[] packetBytes = null;
public byte[] getData()
{
if (packetBytes != null)
return packetBytes;
DatagramPacket packet = getDatagramPacket();
int packetLen = packet.getLength();
String packetData = new String(packet.getData(), 0, packetLen);
packetBytes = packetData.getBytes();
return packetBytes;
}
////////////////////////////////////////////////
// Access Methods
////////////////////////////////////////////////
public String getHost()
{
return HTTPHeader.getValue(getData(), HTTP.HOST);
}
public String getCacheControl()
{
return HTTPHeader.getValue(getData(), HTTP.CACHE_CONTROL);
}
public String getLocation()
{
return HTTPHeader.getValue(getData(), HTTP.LOCATION);
}
public String getMAN()
{
return HTTPHeader.getValue(getData(), HTTP.MAN);
}
public String getST()
{
return HTTPHeader.getValue(getData(), HTTP.ST);
}
public String getNT()
{
return HTTPHeader.getValue(getData(), HTTP.NT);
}
public String getNTS()
{
return HTTPHeader.getValue(getData(), HTTP.NTS);
}
public String getServer()
{
return HTTPHeader.getValue(getData(), HTTP.SERVER);
}
public String getUSN()
{
return HTTPHeader.getValue(getData(), HTTP.USN);
}
public int getMX()
{
return HTTPHeader.getIntegerValue(getData(), HTTP.MX);
}
public String getNT()
{
return HTTPHeader.getValue(getData(), HTTP.NT);
}
public String getNTS()
{
return HTTPHeader.getValue(getData(), HTTP.NTS);
}
public String getServer()
{
return HTTPHeader.getValue(getData(), HTTP.SERVER);
}
public String getUSN()
{
return HTTPHeader.getValue(getData(), HTTP.USN);
}
public int getMX()
{
return HTTPHeader.getIntegerValue(getData(), HTTP.MX);
}
////////////////////////////////////////////////
// Access Methods
////////////////////////////////////////////////
@@ -197,48 +197,47 @@ public class SSDPPacket
return isockaddr.getAddress();
}
////////////////////////////////////////////////
// Access Methods (Extension)
////////////////////////////////////////////////
public boolean isRootDevice()
{
if (NT.isRootDevice(getNT()) == true)
////////////////////////////////////////////////
// Access Methods (Extension)
////////////////////////////////////////////////
public boolean isRootDevice()
{
if (NT.isRootDevice(getNT()) == true)
return true;
// Thanks for Theo Beisch (11/01/04)
// Thanks for Theo Beisch (11/01/04)
if (ST.isRootDevice(getST()) == true)
return true;
return USN.isRootDevice(getUSN());
}
public boolean isDiscover()
{
return MAN.isDiscover(getMAN());
}
public boolean isAlive()
{
return NTS.isAlive(getNTS());
}
public boolean isByeBye()
{
return NTS.isByeBye(getNTS());
}
public int getLeaseTime()
{
return SSDP.getLeaseTime(getCacheControl());
}
return USN.isRootDevice(getUSN());
}
public boolean isDiscover()
{
return MAN.isDiscover(getMAN());
}
public boolean isAlive()
{
return NTS.isAlive(getNTS());
}
public boolean isByeBye()
{
return NTS.isByeBye(getNTS());
}
public int getLeaseTime()
{
return SSDP.getLeaseTime(getCacheControl());
}
////////////////////////////////////////////////
// toString
////////////////////////////////////////////////
@Override
public String toString()
{
return new String(getData());
}
}

7
router/java/src/org/cybergarage/upnp/ssdp/SSDPRequest.java
View File

@@ -18,6 +18,8 @@
package org.cybergarage.upnp.ssdp;
import java.io.InputStream;
import org.cybergarage.http.*;
public class SSDPRequest extends HTTPRequest
@@ -31,6 +33,11 @@ public class SSDPRequest extends HTTPRequest
setVersion(HTTP.VERSION_11);
}
public SSDPRequest(InputStream in)
{
super(in);
}
////////////////////////////////////////////////
// NT
////////////////////////////////////////////////

10
router/java/src/org/cybergarage/upnp/ssdp/SSDPResponse.java
View File

@@ -24,6 +24,8 @@
package org.cybergarage.upnp.ssdp;
import java.io.InputStream;
import org.cybergarage.http.*;
public class SSDPResponse extends HTTPResponse
@@ -37,6 +39,11 @@ public class SSDPResponse extends HTTPResponse
setVersion(HTTP.VERSION_11);
}
public SSDPResponse(InputStream in)
{
super(in);
}
////////////////////////////////////////////////
// ST (SearchTarget)
////////////////////////////////////////////////
@@ -112,10 +119,9 @@ public class SSDPResponse extends HTTPResponse
// getHeader (Override)
////////////////////////////////////////////////
@Override
public String getHeader()
{
StringBuilder str = new StringBuilder();
StringBuffer str = new StringBuffer();
str.append(getStatusLineString());
str.append(getHeaderString());

118
router/java/src/org/cybergarage/upnp/ssdp/SSDPSearchResponseSocket.java
View File

@@ -5,36 +5,41 @@
* Copyright (C) Satoshi Konno 2002
*
* File: SSDPSearchResponseSocket.java
*
* Revision;
*
* 11/20/02
* - first revision.
*
* Revision;
*
* 11/20/02
* - first revision.
* 05/28/03
* - Added post() to send a SSDPSearchRequest.
* 01/31/08
* - Changed start() not to abort when the interface infomation is null on Android m3-rc37a.
*
******************************************************************/
package org.cybergarage.upnp.ssdp;
package org.cybergarage.upnp.ssdp;
import java.net.DatagramSocket;
import java.net.InetAddress;
import org.cybergarage.upnp.*;
public class SSDPSearchResponseSocket extends HTTPUSocket implements Runnable
{
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public class SSDPSearchResponseSocket extends HTTPUSocket implements Runnable
{
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public SSDPSearchResponseSocket()
{
setControlPoint(null);
}
public SSDPSearchResponseSocket(String bindAddr, int port)
{
public SSDPSearchResponseSocket(String bindAddr, int port)
{
super(bindAddr, port);
setControlPoint(null);
}
}
////////////////////////////////////////////////
// ControlPoint
@@ -51,49 +56,56 @@ public class SSDPSearchResponseSocket extends HTTPUSocket implements Runnable
{
return controlPoint;
}
////////////////////////////////////////////////
// run
////////////////////////////////////////////////
private Thread deviceSearchResponseThread = null;
public void run()
{
////////////////////////////////////////////////
// run
////////////////////////////////////////////////
private Thread deviceSearchResponseThread = null;
public void run()
{
Thread thisThread = Thread.currentThread();
ControlPoint ctrlPoint = getControlPoint();
while (deviceSearchResponseThread == thisThread) {
Thread.yield();
while (deviceSearchResponseThread == thisThread) {
Thread.yield();
SSDPPacket packet = receive();
if (packet == null)
break;
break;
if (ctrlPoint != null)
ctrlPoint.searchResponseReceived(packet);
}
}
public void start()
{
deviceSearchResponseThread = new Thread(this, "UPnP-SSDPSearchResponseSocket");
deviceSearchResponseThread.setDaemon(true);
deviceSearchResponseThread.start();
}
public void stop()
{
deviceSearchResponseThread = null;
}
////////////////////////////////////////////////
// post
////////////////////////////////////////////////
public boolean post(String addr, int port, SSDPSearchResponse res)
{
return post(addr, port, res.getHeader());
}
}
}
public void start() {
StringBuffer name = new StringBuffer("Cyber.SSDPSearchResponseSocket/");
DatagramSocket s = getDatagramSocket();
// localAddr is null on Android m3-rc37a (01/30/08)
InetAddress localAddr = s.getLocalAddress();
if (localAddr != null) {
name.append(s.getLocalAddress()).append(':');
name.append(s.getLocalPort());
}
deviceSearchResponseThread = new Thread(this,name.toString());
deviceSearchResponseThread.start();
}
public void stop()
{
deviceSearchResponseThread = null;
}
////////////////////////////////////////////////
// post
////////////////////////////////////////////////
public boolean post(String addr, int port, SSDPSearchResponse res)
{
return post(addr, port, res.getHeader());
}
////////////////////////////////////////////////
// post
@@ -104,4 +116,4 @@ public class SSDPSearchResponseSocket extends HTTPUSocket implements Runnable
return post(addr, port, req.toString());
}
}

312
router/java/src/org/cybergarage/upnp/ssdp/SSDPSearchResponseSocketList.java
View File

@@ -1,146 +1,166 @@
/******************************************************************
*
* CyberUPnP for Java
*
* Copyright (C) Satoshi Konno 2002-2003
*
* File: SSDPSearchResponseSocketList.java
*
* Revision;
*
* 05/08/03
* - first revision.
* 05/28/03
* - Added post() to send a SSDPSearchRequest.
*
******************************************************************/
package org.cybergarage.upnp.ssdp;
import java.util.*;
import org.cybergarage.net.*;
import org.cybergarage.upnp.*;
import org.cybergarage.util.Debug;
public class SSDPSearchResponseSocketList extends Vector
{
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
private static final long serialVersionUID = 4509857798038125744L;
public SSDPSearchResponseSocketList()
{
}
////////////////////////////////////////////////
// ControlPoint
////////////////////////////////////////////////
public void setControlPoint(ControlPoint ctrlPoint)
{
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPSearchResponseSocket sock = getSSDPSearchResponseSocket(n);
sock.setControlPoint(ctrlPoint);
}
}
////////////////////////////////////////////////
// get
////////////////////////////////////////////////
public SSDPSearchResponseSocket getSSDPSearchResponseSocket(int n)
{
return (SSDPSearchResponseSocket)get(n);
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public boolean open(int port)
{
try {
int nHostAddrs = HostInterface.getNHostAddresses();
for (int n=0; n<nHostAddrs; n++) {
String bindAddr = HostInterface.getHostAddress(n);
SSDPSearchResponseSocket socket = new SSDPSearchResponseSocket(bindAddr, port);
Debug.message("Opened SSDP search response socket at " + bindAddr + ':' + port);
add(socket);
}
}
catch (Exception e) {
stop();
close();
clear();
return false;
}
return true;
}
public boolean open()
{
return open(SSDP.PORT);
}
public void close()
{
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPSearchResponseSocket sock = getSSDPSearchResponseSocket(n);
sock.close();
}
clear();
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public void start()
{
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPSearchResponseSocket sock = getSSDPSearchResponseSocket(n);
sock.start();
}
}
public void stop()
{
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPSearchResponseSocket sock = getSSDPSearchResponseSocket(n);
sock.stop();
}
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public boolean post(SSDPSearchRequest req)
{
boolean ret = true;
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPSearchResponseSocket sock = getSSDPSearchResponseSocket(n);
String bindAddr = sock.getLocalAddress();
req.setLocalAddress(bindAddr);
String ssdpAddr = SSDP.ADDRESS;
if (HostInterface.isIPv6Address(bindAddr) == true)
ssdpAddr = SSDP.getIPv6Address();
//sock.joinGroup(ssdpAddr, SSDP.PORT, bindAddr);
if (sock.post(ssdpAddr, SSDP.PORT, req) == false)
ret = false;
//sock.leaveGroup(ssdpAddr, SSDP.PORT, bindAddr);
}
return ret;
}
}
/******************************************************************
*
* CyberUPnP for Java
*
* Copyright (C) Satoshi Konno 2002-2003
*
* File: SSDPSearchResponseSocketList.java
*
* Revision;
*
* 05/08/03
* - first revision.
* 05/28/03
* - Added post() to send a SSDPSearchRequest.
*
******************************************************************/
package org.cybergarage.upnp.ssdp;
import java.net.InetAddress;
import java.util.*;
import org.cybergarage.net.*;
import org.cybergarage.upnp.*;
public class SSDPSearchResponseSocketList extends Vector
{
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
private InetAddress[] binds = null;
public SSDPSearchResponseSocketList() {
}
/**
*
* @param binds The host to bind.Use <tt>null</tt> for the default behavior
*/
public SSDPSearchResponseSocketList(InetAddress[] binds) {
this.binds = binds;
}
////////////////////////////////////////////////
// ControlPoint
////////////////////////////////////////////////
// ControlPoint
////////////////////////////////////////////////
public void setControlPoint(ControlPoint ctrlPoint)
{
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPSearchResponseSocket sock = getSSDPSearchResponseSocket(n);
sock.setControlPoint(ctrlPoint);
}
}
////////////////////////////////////////////////
// get
////////////////////////////////////////////////
public SSDPSearchResponseSocket getSSDPSearchResponseSocket(int n)
{
return (SSDPSearchResponseSocket)get(n);
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public boolean open(int port){
InetAddress[] binds=this.binds ;
String[] bindAddresses;
if(binds!=null){
bindAddresses = new String[binds.length];
for (int i = 0; i < binds.length; i++) {
bindAddresses[i] = binds[i].getHostAddress();
}
}else{
int nHostAddrs = HostInterface.getNHostAddresses();
bindAddresses = new String[nHostAddrs];
for (int n=0; n<nHostAddrs; n++) {
bindAddresses[n] = HostInterface.getHostAddress(n);
}
}
try {
for (int j = 0; j < bindAddresses.length; j++) {
SSDPSearchResponseSocket socket = new SSDPSearchResponseSocket(bindAddresses[j], port);
add(socket);
}
}catch (Exception e) {
stop();
close();
clear();
return false;
}
return true;
}
public boolean open()
{
return open(SSDP.PORT);
}
public void close()
{
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPSearchResponseSocket sock = getSSDPSearchResponseSocket(n);
sock.close();
}
clear();
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public void start()
{
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPSearchResponseSocket sock = getSSDPSearchResponseSocket(n);
sock.start();
}
}
public void stop()
{
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPSearchResponseSocket sock = getSSDPSearchResponseSocket(n);
sock.stop();
}
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public boolean post(SSDPSearchRequest req)
{
boolean ret = true;
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPSearchResponseSocket sock = getSSDPSearchResponseSocket(n);
String bindAddr = sock.getLocalAddress();
req.setLocalAddress(bindAddr);
String ssdpAddr = SSDP.ADDRESS;
if (HostInterface.isIPv6Address(bindAddr) == true)
ssdpAddr = SSDP.getIPv6Address();
//sock.joinGroup(ssdpAddr, SSDP.PORT, bindAddr);
if (sock.post(ssdpAddr, SSDP.PORT, req) == false)
ret = false;
//sock.leaveGroup(ssdpAddr, SSDP.PORT, bindAddr);
}
return ret;
}
}

223
router/java/src/org/cybergarage/upnp/ssdp/SSDPSearchSocket.java
View File

@@ -5,11 +5,11 @@
* Copyright (C) Satoshi Konno 2002-2003
*
* File: SSDPSearchSocket.java
*
* Revision;
*
* 12/30/02
* - first revision.
*
* Revision;
*
* 12/30/02
* - first revision.
* 05/13/03
* - Added support for IPv6.
* 05/28/03
@@ -18,102 +18,177 @@
* - Mikael Hakman <mhakman@dkab.net>
* - Added close() in stop().
* - Added test for null return from receive() in run().
* 08/23/07
* - Thanks for Kazuyuki Shudo
* - Changed run() to catch IOException of HTTPMUSocket::receive().
* 01/10/08
* - Changed start() not to abort when the interface infomation is null on Android m3-rc37a.
*
******************************************************************/
package org.cybergarage.upnp.ssdp;
package org.cybergarage.upnp.ssdp;
import java.net.Inet4Address;
import java.net.Inet6Address;
import java.net.InetAddress;
import java.io.IOException;
import org.cybergarage.net.*;
import org.cybergarage.util.*;
import org.cybergarage.upnp.device.*;
public class SSDPSearchSocket extends HTTPMUSocket implements Runnable
{
public SSDPSearchSocket()
{
}
import org.cybergarage.upnp.device.*;
public class SSDPSearchSocket extends HTTPMUSocket implements Runnable
{
private boolean useIPv6Address;
public SSDPSearchSocket(String bindAddr)
{
open(bindAddr);
Debug.message("Opened SSDP search socket at " + bindAddr + ':' + SSDP.PORT);
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
/**
*
* @param bindAddr The address to bind the service
* @param port The port used for accepting message
* @param multicast The multicast address to use as destination
* @since 1.8
*/
public SSDPSearchSocket(String bindAddr,int port,String multicast){
open(bindAddr,multicast);
}
/**
*
* @param bindAddr the binding address for senging multicast packet
* @since 1.8
*/
public SSDPSearchSocket(InetAddress bindAddr){
if(bindAddr.getAddress().length!=4){
this.open((Inet6Address)bindAddr);
}else{
this.open((Inet4Address)bindAddr);
}
}
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public boolean open(Inet4Address bindAddr){
useIPv6Address = false;
return open(SSDP.ADDRESS, SSDP.PORT, bindAddr);
}
public boolean open(Inet6Address bindAddr){
useIPv6Address = true;
return open(SSDP.getIPv6Address(), SSDP.PORT, bindAddr);
}
public boolean open(String bind,String multicast){
if ((HostInterface.isIPv6Address(bind) ) && (HostInterface.isIPv6Address(multicast))){
useIPv6Address = true;
}else if(HostInterface.isIPv4Address(bind) && (HostInterface.isIPv4Address(multicast))){
useIPv6Address = false;
}else{
throw new IllegalArgumentException("Cannot open a UDP Socket for IPv6 address on IPv4 interface or viceversa");
}
return open(multicast, SSDP.PORT, bind);
}
/**
*
* @param bindAddr the hostname of the interface to use for senfing multicast packet
* @return true if and only if it open the socket
* @see {@link SSDP} for default multicast and port destination of the packtes
*/
public boolean open(String bindAddr)
{
String addr = SSDP.ADDRESS;
useIPv6Address = false;
if (HostInterface.isIPv6Address(bindAddr) == true) {
addr = SSDP.getIPv6Address();
useIPv6Address = true;
}
return open(addr, SSDP.PORT, bindAddr);
}
////////////////////////////////////////////////
// deviceSearch
////////////////////////////////////////////////
private ListenerList deviceSearchListenerList = new ListenerList();
public void addSearchListener(SearchListener listener)
{
deviceSearchListenerList.add(listener);
}
public void removeSearchListener(SearchListener listener)
{
deviceSearchListenerList.remove(listener);
}
public void performSearchListener(SSDPPacket ssdpPacket)
{
int listenerSize = deviceSearchListenerList.size();
for (int n=0; n<listenerSize; n++) {
SearchListener listener = (SearchListener)deviceSearchListenerList.get(n);
listener.deviceSearchReceived(ssdpPacket);
}
}
////////////////////////////////////////////////
// run
////////////////////////////////////////////////
private Thread deviceSearchThread = null;
public void run()
{
Thread thisThread = Thread.currentThread();
while (deviceSearchThread == thisThread) {
Thread.yield();
SSDPPacket packet = receive();
////////////////////////////////////////////////
// deviceSearch
////////////////////////////////////////////////
private ListenerList deviceSearchListenerList = new ListenerList();
public void addSearchListener(SearchListener listener)
{
deviceSearchListenerList.add(listener);
}
public void removeSearchListener(SearchListener listener)
{
deviceSearchListenerList.remove(listener);
}
public void performSearchListener(SSDPPacket ssdpPacket)
{
int listenerSize = deviceSearchListenerList.size();
for (int n=0; n<listenerSize; n++) {
SearchListener listener = (SearchListener)deviceSearchListenerList.get(n);
listener.deviceSearchReceived(ssdpPacket);
}
}
////////////////////////////////////////////////
// run
////////////////////////////////////////////////
private Thread deviceSearchThread = null;
public void run()
{
Thread thisThread = Thread.currentThread();
while (deviceSearchThread == thisThread) {
Thread.yield();
// Thanks for Kazuyuki Shudo (08/23/07)
SSDPPacket packet = null;
try {
packet = receive();
}
catch (IOException e) {
break;
}
// Thanks for Mikael Hakman (04/20/05)
if (packet == null)
continue;
if (packet.isDiscover() == true)
performSearchListener(packet);
}
}
public void start()
{
deviceSearchThread = new Thread(this,"UPnP-SSDPSearchSocket");
deviceSearchThread.setDaemon(true);
deviceSearchThread.start();
}
public void stop()
//TODO perform delegation with Thread Pooling
if (packet.isDiscover() == true)
performSearchListener(packet);
}
}
public void start() {
StringBuffer name = new StringBuffer("Cyber.SSDPSearchSocket/");
String localAddr = this.getLocalAddress();
// localAddr is null on Android m3-rc37a (01/30/08)
if (localAddr != null && 0 < localAddr.length()) {
name.append(this.getLocalAddress()).append(':');
name.append(this.getLocalPort()).append(" -> ");
name.append(this.getMulticastAddress()).append(':');
name.append(this.getMulticastPort());
}
deviceSearchThread = new Thread(this,name.toString());
deviceSearchThread.start();
}
public void stop()
{
// Thanks for Mikael Hakman (04/20/05)
close();
deviceSearchThread = null;
}
deviceSearchThread = null;
}
}

252
router/java/src/org/cybergarage/upnp/ssdp/SSDPSearchSocketList.java
View File

@@ -1,105 +1,151 @@
/******************************************************************
*
* CyberUPnP for Java
*
* Copyright (C) Satoshi Konno 2002-2003
/******************************************************************
*
* File: SSDPSearchSocketList.java
*
* Revision;
*
* 05/08/03
* - first revision.
* 05/28/03
* - Moved post() for SSDPSearchRequest to SSDPResponseSocket.
* - Removed open(int).
*
******************************************************************/
* CyberUPnP for Java
*
* Copyright (C) Satoshi Konno 2002-2003
*
* File: SSDPSearchSocketList.java
*
* Revision;
*
* 05/08/03
* - first revision.
* 05/28/03
* - Moved post() for SSDPSearchRequest to SSDPResponseSocket.
* - Removed open(int).
*
******************************************************************/
package org.cybergarage.upnp.ssdp;
import java.net.InetAddress;
import java.util.Vector;
import org.cybergarage.net.HostInterface;
import org.cybergarage.upnp.device.SearchListener;
public class SSDPSearchSocketList extends Vector
{
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
private InetAddress[] binds = null;
private String multicastIPv4 = SSDP.ADDRESS;
private String multicastIPv6 = SSDP.getIPv6Address();
private int port = SSDP.PORT;
public SSDPSearchSocketList()
{
}
/**
*
* @param binds The IP address that we will used for bindind the service
*/
public SSDPSearchSocketList(InetAddress[] binds) {
this.binds = binds;
}
/**
*
* @param binds The IP address that we will used for bindind the service
* @param port The port that we will used for bindind the service
* @param multicastIPv4 The IPv4 address that we will used for multicast comunication
* @param multicastIPv6 The IPv6 address that we will used for multicast comunication
* @since 1.8
*/
public SSDPSearchSocketList(InetAddress[] binds,int port, String multicastIPv4, String multicastIPv6) {
this.binds = binds;
this.port = port;
this.multicastIPv4 = multicastIPv4;
this.multicastIPv6 = multicastIPv6;
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public SSDPSearchSocket getSSDPSearchSocket(int n)
{
return (SSDPSearchSocket)get(n);
}
public void addSearchListener(SearchListener listener)
{
int nServers = size();
for (int n=0; n<nServers; n++) {
SSDPSearchSocket sock = getSSDPSearchSocket(n);
sock.addSearchListener(listener);
}
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public boolean open() {
InetAddress[] binds=this.binds;
String[] bindAddresses;
if(binds!=null){
bindAddresses = new String[binds.length];
for (int i = 0; i < binds.length; i++) {
bindAddresses[i] = binds[i].getHostAddress();
}
}else{
int nHostAddrs = HostInterface.getNHostAddresses();
bindAddresses = new String[nHostAddrs];
for (int n=0; n<nHostAddrs; n++) {
bindAddresses[n] = HostInterface.getHostAddress(n);
}
}
for (int i = 0; i < bindAddresses.length; i++) {
if(bindAddresses[i]!=null){
SSDPSearchSocket ssdpSearchSocket;
if(HostInterface.isIPv6Address(bindAddresses[i]))
ssdpSearchSocket = new SSDPSearchSocket(bindAddresses[i],port ,multicastIPv6 );
else
ssdpSearchSocket = new SSDPSearchSocket(bindAddresses[i],port,multicastIPv4 );
add(ssdpSearchSocket);
}
}
return true;
}
public void close()
{
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPSearchSocket sock = getSSDPSearchSocket(n);
sock.close();
}
clear();
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public void start()
{
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPSearchSocket sock = getSSDPSearchSocket(n);
sock.start();
}
}
public void stop()
{
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPSearchSocket sock = getSSDPSearchSocket(n);
sock.stop();
}
}
}
package org.cybergarage.upnp.ssdp;
import java.util.*;
import org.cybergarage.net.*;
import org.cybergarage.upnp.device.*;
public class SSDPSearchSocketList extends Vector
{
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
private static final long serialVersionUID = 4071292828166415028L;
public SSDPSearchSocketList()
{
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public SSDPSearchSocket getSSDPSearchSocket(int n)
{
return (SSDPSearchSocket)get(n);
}
public void addSearchListener(SearchListener listener)
{
int nServers = size();
for (int n=0; n<nServers; n++) {
SSDPSearchSocket sock = getSSDPSearchSocket(n);
sock.addSearchListener(listener);
}
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public boolean open()
{
int nHostAddrs = HostInterface.getNHostAddresses();
for (int n=0; n<nHostAddrs; n++) {
String bindAddr = HostInterface.getHostAddress(n);
SSDPSearchSocket ssdpSearchSocket = new SSDPSearchSocket(bindAddr);
add(ssdpSearchSocket);
}
return true;
}
public void close()
{
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPSearchSocket sock = getSSDPSearchSocket(n);
sock.close();
}
clear();
}
////////////////////////////////////////////////
// Methods
////////////////////////////////////////////////
public void start()
{
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPSearchSocket sock = getSSDPSearchSocket(n);
sock.start();
}
}
public void stop()
{
int nSockets = size();
for (int n=0; n<nSockets; n++) {
SSDPSearchSocket sock = getSSDPSearchSocket(n);
sock.stop();
}
}
}

107
router/java/src/org/cybergarage/upnp/xml/DeviceData.java
View File

@@ -18,6 +18,7 @@
package org.cybergarage.upnp.xml;
import java.io.*;
import java.net.InetAddress;
import org.cybergarage.util.*;
import org.cybergarage.http.*;
@@ -89,10 +90,23 @@ public class DeviceData extends NodeData
// HTTPServer
////////////////////////////////////////////////
private HTTPServerList httpServerList = new HTTPServerList();
private HTTPServerList httpServerList = null;
public HTTPServerList getHTTPServerList() {
return httpServerList;
if(this.httpServerList==null){
this.httpServerList = new HTTPServerList(this.httpBinds,this.httpPort);
}
return this.httpServerList;
}
private InetAddress[] httpBinds = null;
public void setHTTPBindAddress(InetAddress[] inets){
this.httpBinds=inets;
}
public InetAddress[] getHTTPBindAddress(){
return this.httpBinds;
}
////////////////////////////////////////////////
@@ -129,11 +143,98 @@ public class DeviceData extends NodeData
// SSDPSearchSocket
////////////////////////////////////////////////
private SSDPSearchSocketList ssdpSearchSocketList = new SSDPSearchSocketList();
private SSDPSearchSocketList ssdpSearchSocketList = null;
private String ssdpMulticastIPv4 = SSDP.ADDRESS;
private String ssdpMulticastIPv6 = SSDP.getIPv6Address();
private int ssdpPort = SSDP.PORT;
private InetAddress[] ssdpBinds = null;
public SSDPSearchSocketList getSSDPSearchSocketList() {
if(this.ssdpSearchSocketList==null){
this.ssdpSearchSocketList = new SSDPSearchSocketList(this.ssdpBinds,ssdpPort,ssdpMulticastIPv4,ssdpMulticastIPv6);
}
return ssdpSearchSocketList;
}
/**
*
* @param port The port to use for binding the SSDP service.
* The port will be used as source port for all SSDP messages
* @since 1.8
*/
public void setSSDPPort(int port){
this.ssdpPort=port;
}
/**
*
* @return The port used for binding the SSDP service.
* The port will be used as source port for all SSDP messages
*/
public int getSSDPPort(){
return this.ssdpPort;
}
/**
*
* @param inets The <tt>InetAddress</tt> that will be binded for listing this service.
* Use <code>null</code> for the default behaviur.
* @see {@link UPnP}
* @see {@link USSDP}
* @see {@link HostInterface}
* @since 1.8
*/
public void setSSDPBindAddress(InetAddress[] inets){
this.ssdpBinds=inets;
}
/**
*
* @return inets The <tt>InetAddress</tt> that will be binded for this service
* <code>null</code> means that defulat behaviur will be used
* @since 1.8
*/
public InetAddress[] getSSDPBindAddress(){
return this.ssdpBinds;
}
/**
*
* @param ip The IPv4 address used as destination address for Multicast comunication
* @since 1.8
*/
public void setMulticastIPv4Address(String ip){
this.ssdpMulticastIPv4=ip;
}
/**
*
* @return The IPv4 address used for Multicast comunication
*/
public String getMulticastIPv4Address(){
return this.ssdpMulticastIPv4;
}
/**
*
* @param ip The IPv6 address used as destination address for Multicast comunication
* @since 1.8
*/
public void setMulticastIPv6Address(String ip){
this.ssdpMulticastIPv6=ip;
}
/**
*
* @return The IPv6 address used as destination address for Multicast comunication
* @since 1.8
*/
public String getMulticastIPv6Address(){
return this.ssdpMulticastIPv6;
}
////////////////////////////////////////////////
// SSDPPacket

14
router/java/src/org/cybergarage/upnp/xml/ServiceData.java
View File

@@ -68,6 +68,20 @@ public class ServiceData extends NodeData
// SID
////////////////////////////////////////////////
private String descriptionURL = "";
public String getDescriptionURL() {
return descriptionURL;
}
public void setDescriptionURL(String descriptionURL) {
this.descriptionURL = descriptionURL;
}
////////////////////////////////////////////////
// SID
////////////////////////////////////////////////
private String sid = "";
public String getSID() {

4
router/java/src/org/cybergarage/util/FileUtil.java
View File

@@ -15,7 +15,9 @@
package org.cybergarage.util;
import java.io.*;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.util.Locale;
public final class FileUtil

11
router/java/src/org/cybergarage/util/ListenerList.java
View File

@@ -3,7 +3,7 @@
* CyberUtil for Java
*
* Copyright (C) Satoshi Konno 2002
*
*
* File: ListenerList.java
*
* Revision;
@@ -12,16 +12,13 @@
* - first revision.
*
******************************************************************/
package org.cybergarage.util;
import java.util.*;
import java.util.Vector;
public class ListenerList extends Vector
{
private static final long serialVersionUID = 8039231561720446173L;
@Override
public boolean add(Object obj)
{
if (0 <= indexOf(obj))

2
router/java/src/org/cybergarage/util/Mutex.java
View File

@@ -40,7 +40,7 @@ public class Mutex
}
catch (Exception e) {
Debug.warning(e);
}
};
}
syncLock = true;
}

9
router/java/src/org/cybergarage/util/ThreadCore.java
View File

@@ -10,6 +10,9 @@
*
* 01/05/04
* - first revision.
* 08/23/07
* - Thanks for Kazuyuki Shudo
* - Changed stop() to stop more safety using Thread::interrupt().
*
******************************************************************/
@@ -43,7 +46,7 @@ public class ThreadCore implements Runnable
{
java.lang.Thread threadObject = getThreadObject();
if (threadObject == null) {
threadObject = new java.lang.Thread(this);
threadObject = new java.lang.Thread(this,"Cyber.ThreadCore");
setThreadObject(threadObject);
threadObject.start();
}
@@ -64,6 +67,10 @@ public class ThreadCore implements Runnable
if (threadObject != null) {
//threadObject.destroy();
//threadObject.stop();
// Thanks for Kazuyuki Shudo (08/23/07)
threadObject.interrupt();
setThreadObject(null);
// I2P break Disposer out of sleep()
threadObject.interrupt();

4
router/java/src/org/cybergarage/xml/AttributeList.java
View File

@@ -15,12 +15,10 @@
package org.cybergarage.xml;
import java.util.*;
import java.util.Vector;
public class AttributeList extends Vector
{
private static final long serialVersionUID = -5516389508555401104L;
public AttributeList()
{
}

883
router/java/src/org/cybergarage/xml/Node.java
View File

@@ -1,415 +1,468 @@
/******************************************************************
*
* CyberXML for Java
*
* Copyright (C) Satoshi Konno 2002
*
* File: Element.java
*
* Revision;
*
* 11/27/02
* - first revision.
* 11/01/03
* - Terje Bakken
* - fixed missing escaping of reserved XML characters
* 11/19/04
* - Theo Beisch <theo.beisch@gmx.de>
* - Added "&" and "\"" "\\" to toXMLString().
* 11/19/04
* - Theo Beisch <theo.beisch@gmx.de>
* - Changed XML::output() to use short notation when the tag value is null.
* 12/02/04
* - Brian Owens <brian@b-owens.com>
* - Fixed toXMLString() to convert from "'" to "&apos;" instead of "\".
*
******************************************************************/
package org.cybergarage.xml;
import java.io.ByteArrayOutputStream;
import java.io.PrintWriter;
public class Node
{
public Node()
{
setUserData(null);
setParentNode(null);
}
public Node(String name)
{
this();
setName(name);
}
public Node(String ns, String name)
{
this();
setName(ns, name);
}
////////////////////////////////////////////////
// parent node
////////////////////////////////////////////////
private Node parentNode = null;
public void setParentNode(Node node)
{
parentNode = node;
}
public Node getParentNode()
{
return parentNode;
}
////////////////////////////////////////////////
// root node
////////////////////////////////////////////////
public Node getRootNode()
{
Node rootNode = null;
Node _parentNode = getParentNode();
while (_parentNode != null) {
rootNode = _parentNode;
_parentNode = rootNode.getParentNode();
}
return rootNode;
}
////////////////////////////////////////////////
// name
////////////////////////////////////////////////
private String name = new String();
public void setName(String name)
{
this.name = name;
}
public void setName(String ns, String name)
{
this.name = ns + ":" + name;
}
public String getName()
{
return name;
}
public boolean isName(String value)
{
return name.equals(value);
}
////////////////////////////////////////////////
// value
////////////////////////////////////////////////
private String value = "";
public void setValue(String value)
{
this.value = value;
}
public void setValue(int value)
{
setValue(Integer.toString(value));
}
public String getValue()
{
return value;
}
////////////////////////////////////////////////
// Attribute (Basic)
////////////////////////////////////////////////
private AttributeList attrList = new AttributeList();
public int getNAttributes() {
return attrList.size();
}
public Attribute getAttribute(int index) {
return attrList.getAttribute(index);
}
public Attribute getAttribute(String name)
{
return attrList.getAttribute(name);
}
public void addAttribute(Attribute attr) {
attrList.add(attr);
}
public void insertAttributeAt(Attribute attr, int index) {
attrList.insertElementAt(attr, index);
}
public void addAttribute(String name, String value) {
Attribute attr = new Attribute(name, value);
addAttribute(attr);
}
public boolean removeAttribute(Attribute attr) {
return attrList.remove(attr);
}
public boolean removeAttribute(String name) {
return removeAttribute(getAttribute(name));
}
public boolean hasAttributes()
{
if (0 < getNAttributes())
return true;
return false;
}
////////////////////////////////////////////////
// Attribute (Extention)
////////////////////////////////////////////////
public void setAttribute(String name, String value) {
Attribute attr = getAttribute(name);
if (attr != null) {
attr.setValue(value);
return;
}
attr = new Attribute(name, value);
addAttribute(attr);
}
public void setAttribute(String name, int value) {
setAttribute(name, Integer.toString(value));
}
public String getAttributeValue(String name) {
Attribute attr = getAttribute(name);
if (attr != null)
return attr.getValue();
return "";
}
public int getAttributeIntegerValue(String name) {
String val = getAttributeValue(name);
try {
return Integer.parseInt(val);
}
catch (Exception e) {}
return 0;
}
////////////////////////////////////////////////
// Attribute (xmlns)
////////////////////////////////////////////////
public void setNameSpace(String ns, String value)
{
setAttribute("xmlns:" + ns, value);
}
////////////////////////////////////////////////
// Child node
////////////////////////////////////////////////
private NodeList nodeList = new NodeList();
public int getNNodes() {
return nodeList.size();
}
public Node getNode(int index) {
return nodeList.getNode(index);
}
public Node getNode(String name)
{
return nodeList.getNode(name);
}
public Node getNodeEndsWith(String name)
{
return nodeList.getEndsWith(name);
}
public void addNode(Node node) {
node.setParentNode(this);
nodeList.add(node);
}
public void insertNode(Node node, int index) {
node.setParentNode(this);
nodeList.insertElementAt(node, index);
}
public boolean removeNode(Node node) {
node.setParentNode(null);
return nodeList.remove(node);
}
public boolean removeNode(String name) {
return nodeList.remove(getNode(name));
}
public void removeAllNodes()
{
nodeList.clear();
}
public boolean hasNodes()
{
if (0 < getNNodes())
return true;
return false;
}
////////////////////////////////////////////////
// Element (Child Node)
////////////////////////////////////////////////
public void setNode(String name, String value) {
Node node = getNode(name);
if (node != null) {
node.setValue(value);
return;
}
node = new Node(name);
node.setValue(value);
addNode(node);
}
public String getNodeValue(String name) {
Node node = getNode(name);
if (node != null)
return node.getValue();
return "";
}
////////////////////////////////////////////////
// userData
////////////////////////////////////////////////
private Object userData = null;
public void setUserData(Object data)
{
userData = data;
}
public Object getUserData()
{
return userData;
}
////////////////////////////////////////////////
// toString
////////////////////////////////////////////////
public String getIndentLevelString(int nIndentLevel)
{
char indentString[] = new char[nIndentLevel];
for (int n=0; n<nIndentLevel; n++)
indentString[n] = '\t' ;
return new String(indentString);
}
public void outputAttributes(PrintWriter ps)
{
int nAttributes = getNAttributes();
for (int n=0; n<nAttributes; n++) {
Attribute attr = getAttribute(n);
ps.print(" " + attr.getName() + "=\"" + XML.escapeXMLChars(attr.getValue()) + "\"");
}
}
public void output(PrintWriter ps, int indentLevel, boolean hasChildNode)
{
String indentString = getIndentLevelString(indentLevel);
String _name = getName();
String _value = getValue();
if (hasNodes() == false || hasChildNode == false) {
ps.print(indentString + "<" + _name);
outputAttributes(ps);
// Thnaks for Tho Beisch (11/09/04)
if (_value == null || _value.length() == 0) {
// No value, so use short notation <node />
ps.println(" />");
} else {
ps.println(">" + XML.escapeXMLChars(_value) + "</" + _name + ">");
}
return;
}
ps.print(indentString + "<" + _name);
outputAttributes(ps);
ps.println(">");
int nChildNodes = getNNodes();
for (int n=0; n<nChildNodes; n++) {
Node cnode = getNode(n);
cnode.output(ps, indentLevel+1, true);
}
ps.println(indentString +"</" + _name + ">");
}
public String toString(boolean hasChildNode)
{
ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
PrintWriter pr = new PrintWriter(byteOut);
output(pr, 0, hasChildNode);
pr.flush();
return byteOut.toString();
}
@Override
public String toString()
{
return toString(true);
}
public String toXMLString(boolean hasChildNode)
{
String xmlStr = toString();
xmlStr = xmlStr.replaceAll("<", "&lt;");
xmlStr = xmlStr.replaceAll(">", "&gt;");
// Thanks for Theo Beisch (11/09/04)
xmlStr = xmlStr.replaceAll("&", "&amp;");
xmlStr = xmlStr.replaceAll("\"", "&quot;");
// Thanks for Brian Owens (12/02/04)
xmlStr = xmlStr.replaceAll("'", "&apos;");
return xmlStr;
}
public String toXMLString()
{
return toXMLString(true);
}
public void print(boolean hasChildNode)
{
PrintWriter pr = new PrintWriter(System.out);
output(pr, 0, hasChildNode);
pr.flush();
}
public void print()
{
print(true);
}
}
/******************************************************************
*
* CyberXML for Java
*
* Copyright (C) Satoshi Konno 2002
*
* File: Element.java
*
* Revision;
*
* 11/27/02
* - first revision.
* 11/01/03
* - Terje Bakken
* - fixed missing escaping of reserved XML characters
* 11/19/04
* - Theo Beisch <theo.beisch@gmx.de>
* - Added "&" and "\"" "\\" to toXMLString().
* 11/19/04
* - Theo Beisch <theo.beisch@gmx.de>
* - Changed XML::output() to use short notation when the tag value is null.
* 12/02/04
* - Brian Owens <brian@b-owens.com>
* - Fixed toXMLString() to convert from "'" to "&apos;" instead of "\".
* 11/07/05
* - Changed toString() to return as utf-8 string.
* 02/08/08
* - Added addValue().
*
******************************************************************/
package org.cybergarage.xml;
import java.io.ByteArrayOutputStream;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.util.Iterator;
public class Node
{
/**
* Create a Node with empty UserData and no Parent Node
*
*/
public Node()
{
setUserData(null);
setParentNode(null);
}
public Node(String name)
{
this();
setName(name);
}
public Node(String ns, String name)
{
this();
setName(ns, name);
}
////////////////////////////////////////////////
// parent node
////////////////////////////////////////////////
private Node parentNode = null;
public void setParentNode(Node node)
{
parentNode = node;
}
public Node getParentNode()
{
return parentNode;
}
////////////////////////////////////////////////
// root node
////////////////////////////////////////////////
public Node getRootNode()
{
Node rootNode = null;
Node parentNode = getParentNode();
while (parentNode != null) {
rootNode = parentNode;
parentNode = rootNode.getParentNode();
}
return rootNode;
}
////////////////////////////////////////////////
// name
////////////////////////////////////////////////
private String name = new String();
public void setName(String name)
{
this.name = name;
}
public void setName(String ns, String name)
{
this.name = ns + ":" + name;
}
public String getName()
{
return name;
}
public boolean isName(String value)
{
return name.equals(value);
}
////////////////////////////////////////////////
// value
////////////////////////////////////////////////
private String value = new String();
public void setValue(String value)
{
this.value = value;
}
public void setValue(int value)
{
setValue(Integer.toString(value));
}
public void addValue(String value)
{
if (this.value == null) {
this.value = value;
return;
}
if (value != null)
this.value += value;
}
public String getValue()
{
return value;
}
////////////////////////////////////////////////
// Attribute (Basic)
////////////////////////////////////////////////
private AttributeList attrList = new AttributeList();
public int getNAttributes() {
return attrList.size();
}
public Attribute getAttribute(int index) {
return attrList.getAttribute(index);
}
public Attribute getAttribute(String name)
{
return attrList.getAttribute(name);
}
public void addAttribute(Attribute attr) {
attrList.add(attr);
}
public void insertAttributeAt(Attribute attr, int index) {
attrList.insertElementAt(attr, index);
}
public void addAttribute(String name, String value) {
Attribute attr = new Attribute(name, value);
addAttribute(attr);
}
public boolean removeAttribute(Attribute attr) {
return attrList.remove(attr);
}
public boolean removeAttribute(String name) {
return removeAttribute(getAttribute(name));
}
public boolean hasAttributes()
{
if (0 < getNAttributes())
return true;
return false;
}
////////////////////////////////////////////////
// Attribute (Extention)
////////////////////////////////////////////////
public void setAttribute(String name, String value) {
Attribute attr = getAttribute(name);
if (attr != null) {
attr.setValue(value);
return;
}
attr = new Attribute(name, value);
addAttribute(attr);
}
public void setAttribute(String name, int value) {
setAttribute(name, Integer.toString(value));
}
public String getAttributeValue(String name) {
Attribute attr = getAttribute(name);
if (attr != null)
return attr.getValue();
return "";
}
public int getAttributeIntegerValue(String name) {
String val = getAttributeValue(name);
try {
return Integer.parseInt(val);
}
catch (Exception e) {}
return 0;
}
////////////////////////////////////////////////
// Attribute (xmlns)
////////////////////////////////////////////////
public void setNameSpace(String ns, String value)
{
setAttribute("xmlns:" + ns, value);
}
////////////////////////////////////////////////
// Child node
////////////////////////////////////////////////
private NodeList nodeList = new NodeList();
public int getNNodes() {
return nodeList.size();
}
public Node getNode(int index) {
return nodeList.getNode(index);
}
public Node getNode(String name)
{
return nodeList.getNode(name);
}
public Node getNodeEndsWith(String name)
{
return nodeList.getEndsWith(name);
}
public void addNode(Node node) {
node.setParentNode(this);
nodeList.add(node);
}
public void insertNode(Node node, int index) {
node.setParentNode(this);
nodeList.insertElementAt(node, index);
}
public int getIndex(String name){
int index = -1;
for (Iterator i = nodeList.iterator(); i.hasNext();) {
index++;
Node n = (Node) i.next();
if(n.getName().equals(name))
return index;
}
return index;
}
public boolean removeNode(Node node) {
node.setParentNode(null);
return nodeList.remove(node);
}
public boolean removeNode(String name) {
return nodeList.remove(getNode(name));
}
public void removeAllNodes()
{
nodeList.clear();
}
public boolean hasNodes()
{
if (0 < getNNodes())
return true;
return false;
}
////////////////////////////////////////////////
// Element (Child Node)
////////////////////////////////////////////////
public void setNode(String name, String value) {
Node node = getNode(name);
if (node != null) {
node.setValue(value);
return;
}
node = new Node(name);
node.setValue(value);
addNode(node);
}
public String getNodeValue(String name) {
Node node = getNode(name);
if (node != null)
return node.getValue();
return "";
}
////////////////////////////////////////////////
// userData
////////////////////////////////////////////////
private Object userData = null;
public void setUserData(Object data)
{
userData = data;
}
public Object getUserData()
{
return userData;
}
////////////////////////////////////////////////
// toString
////////////////////////////////////////////////
/**
* Inovoke {@link #getIndentLevelString(int, String)} with <code>" "</code> as String
*
* @see #getIndentLevelString(int, String)
*/
public String getIndentLevelString(int nIndentLevel)
{
return getIndentLevelString(nIndentLevel," ");
}
/**
*
* @param nIndentLevel the level of indentation to produce
* @param space the String to use for the intendation
* @since 1.8.0
* @return an indentation String
*/
public String getIndentLevelString(int nIndentLevel,String space)
{
StringBuffer indentString = new StringBuffer(nIndentLevel*space.length());
for (int n=0; n<nIndentLevel; n++){
indentString.append(space);
}
return indentString.toString();
}
public void outputAttributes(PrintWriter ps)
{
int nAttributes = getNAttributes();
for (int n=0; n<nAttributes; n++) {
Attribute attr = getAttribute(n);
ps.print(" " + attr.getName() + "=\"" + XML.escapeXMLChars(attr.getValue()) + "\"");
}
}
public void output(PrintWriter ps, int indentLevel, boolean hasChildNode)
{
String indentString = getIndentLevelString(indentLevel);
String name = getName();
String value = getValue();
if (hasNodes() == false || hasChildNode == false) {
ps.print(indentString + "<" + name);
outputAttributes(ps);
// Thnaks for Tho Beisch (11/09/04)
if (value == null || value.length() == 0) {
// Not using the short notation <node /> because it cause compatibility trouble
ps.println("></" + name + ">");
} else {
ps.println(">" + XML.escapeXMLChars(value) + "</" + name + ">");
}
return;
}
ps.print(indentString + "<" + name);
outputAttributes(ps);
ps.println(">");
int nChildNodes = getNNodes();
for (int n=0; n<nChildNodes; n++) {
Node cnode = getNode(n);
cnode.output(ps, indentLevel+1, true);
}
ps.println(indentString +"</" + name + ">");
}
public String toString(String enc, boolean hasChildNode)
{
ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
PrintWriter pr = new PrintWriter(byteOut);
output(pr, 0, hasChildNode);
pr.flush();
try {
if (enc != null && 0 < enc.length())
return byteOut.toString(enc);
}
catch (UnsupportedEncodingException e) {
}
return byteOut.toString();
}
public String toString()
{
return toString(XML.CHARSET_UTF8, true);
}
public String toXMLString(boolean hasChildNode)
{
String xmlStr = toString();
xmlStr = xmlStr.replaceAll("<", "&lt;");
xmlStr = xmlStr.replaceAll(">", "&gt;");
// Thanks for Theo Beisch (11/09/04)
xmlStr = xmlStr.replaceAll("&", "&amp;");
xmlStr = xmlStr.replaceAll("\"", "&quot;");
// Thanks for Brian Owens (12/02/04)
xmlStr = xmlStr.replaceAll("'", "&apos;");
return xmlStr;
}
public String toXMLString()
{
return toXMLString(true);
}
public void print(boolean hasChildNode)
{
PrintWriter pr = new PrintWriter(System.out);
output(pr, 0, hasChildNode);
pr.flush();
}
public void print()
{
print(true);
}
}

4
router/java/src/org/cybergarage/xml/NodeList.java
View File

@@ -15,12 +15,10 @@
package org.cybergarage.xml;
import java.util.*;
import java.util.Vector;
public class NodeList extends Vector
{
private static final long serialVersionUID = 1528884682346143213L;
public NodeList()
{
}

245
router/java/src/org/cybergarage/xml/Parser.java
View File

@@ -1,117 +1,128 @@
/******************************************************************
*
* CyberXML for Java
*
* Copyright (C) Satoshi Konno 2002
*
* File: Parser.java
*
* Revision;
*
* 11/26/03
* - first revision.
* 03/30/05
* - Change parse(String) to use StringBufferInputStream instead of URL.
*
******************************************************************/
package org.cybergarage.xml;
import java.net.*;
import java.io.*;
public abstract class Parser
{
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public Parser()
{
}
////////////////////////////////////////////////
// parse
////////////////////////////////////////////////
public abstract Node parse(InputStream inStream) throws ParserException;
////////////////////////////////////////////////
// parse (URL)
////////////////////////////////////////////////
public Node parse(URL locationURL) throws ParserException
{
try {
HttpURLConnection urlCon = (HttpURLConnection)locationURL.openConnection();
// I2P mods to prevent hangs (see HTTPRequest for more info)
// this seems to work, getInputStream actually does the connect(),
// (as shown by a thread dump)
// so we can set these after openConnection()
// Alternative would be foo = new HttpURLConnection(locationURL); foo.set timeouts; foo.connect()
urlCon.setConnectTimeout(2*1000);
urlCon.setReadTimeout(1000);
urlCon.setRequestMethod("GET");
InputStream urlIn = urlCon.getInputStream();
Node rootElem = parse(urlIn);
urlIn.close();
urlCon.disconnect();
return rootElem;
} catch (Exception e) {
throw new ParserException(e);
}
/*
String host = locationURL.getHost();
int port = locationURL.getPort();
String uri = locationURL.getPath();
HTTPRequest httpReq = new HTTPRequest();
httpReq.setMethod(HTTP.GET);
httpReq.setURI(uri);
HTTPResponse httpRes = httpReq.post(host, port);
if (httpRes.isSuccessful() == false)
throw new ParserException(locationURL.toString());
String content = new String(httpRes.getContent());
StringBufferInputStream strBuf = new StringBufferInputStream(content);
return parse(strBuf);
*/
}
////////////////////////////////////////////////
// parse (File)
////////////////////////////////////////////////
public Node parse(File descriptionFile) throws ParserException
{
try {
InputStream fileIn = new FileInputStream(descriptionFile);
Node root = parse(fileIn);
fileIn.close();
return root;
} catch (Exception e) {
throw new ParserException(e);
}
}
////////////////////////////////////////////////
// parse (Memory)
////////////////////////////////////////////////
public Node parse(String descr) throws ParserException
{
try {
InputStream decrIn = new ByteArrayInputStream(descr.getBytes());
Node root = parse(decrIn);
return root;
} catch (Exception e) {
throw new ParserException(e);
}
}
}
/******************************************************************
*
* CyberXML for Java
*
* Copyright (C) Satoshi Konno 2002
*
* File: Parser.java
*
* Revision;
*
* 11/26/2003
* - first revision.
* 03/30/2005
* - Change parse(String) to use StringBufferInputStream instead of URL.
* 11/11/2009
* - Changed Parser::parser() to use ByteArrayInputStream instead of StringBufferInputStream because of bugs in Android v1.6.
*
******************************************************************/
package org.cybergarage.xml;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.ByteArrayInputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import org.cybergarage.http.HTTP;
import org.cybergarage.http.HTTPRequest;
import org.cybergarage.http.HTTPResponse;
public abstract class Parser
{
////////////////////////////////////////////////
// Constructor
////////////////////////////////////////////////
public Parser()
{
}
////////////////////////////////////////////////
// parse
////////////////////////////////////////////////
public abstract Node parse(InputStream inStream) throws ParserException;
////////////////////////////////////////////////
// parse (URL)
////////////////////////////////////////////////
public Node parse(URL locationURL) throws ParserException
{
String host = locationURL.getHost();
int port = locationURL.getPort();
// Thanks for Hao Hu
if (port == -1)
port = 80;
String uri = locationURL.getPath();
try {
HttpURLConnection urlCon = (HttpURLConnection)locationURL.openConnection();
urlCon.setRequestMethod("GET");
urlCon.setRequestProperty(HTTP.CONTENT_LENGTH,"0");
if (host != null)
urlCon.setRequestProperty(HTTP.HOST, host);
InputStream urlIn = urlCon.getInputStream();
Node rootElem = parse(urlIn);
urlIn.close();
urlCon.disconnect();
return rootElem;
} catch (Exception e) {
//throw new ParserException(e);
}
HTTPRequest httpReq = new HTTPRequest();
httpReq.setMethod(HTTP.GET);
httpReq.setURI(uri);
HTTPResponse httpRes = httpReq.post(host, port);
if (httpRes.isSuccessful() == false)
throw new ParserException("HTTP comunication failed: no answer from peer." +
"Unable to retrive resoure -> "+locationURL.toString());
String content = new String(httpRes.getContent());
ByteArrayInputStream strBuf = new ByteArrayInputStream(content.getBytes());
return parse(strBuf);
}
////////////////////////////////////////////////
// parse (File)
////////////////////////////////////////////////
public Node parse(File descriptionFile) throws ParserException
{
try {
InputStream fileIn = new FileInputStream(descriptionFile);
Node root = parse(fileIn);
fileIn.close();
return root;
} catch (Exception e) {
throw new ParserException(e);
}
}
////////////////////////////////////////////////
// parse (Memory)
////////////////////////////////////////////////
public Node parse(String descr) throws ParserException
{
try {
InputStream decrIn = new ByteArrayInputStream(descr.getBytes());
Node root = parse(decrIn);
return root;
} catch (Exception e) {
throw new ParserException(e);
}
}
}

2
router/java/src/org/cybergarage/xml/ParserException.java
View File

@@ -19,8 +19,6 @@ package org.cybergarage.xml;
public class ParserException extends Exception
{
private static final long serialVersionUID = 7443033796560597360L;
public ParserException(Exception e)
{
super(e);

23
router/java/src/org/cybergarage/xml/XML.java
View File

@@ -21,6 +21,7 @@ package org.cybergarage.xml;
public class XML
{
public final static String CONTENT_TYPE = "text/xml; charset=\"utf-8\"";
public final static String CHARSET_UTF8 = "utf-8";
////////////////////////////////////////////////
// escapeXMLChars
@@ -28,9 +29,9 @@ public class XML
private final static String escapeXMLChars(String input, boolean quote)
{
StringBuilder out = new StringBuilder();
if (input == null)
return null;
StringBuffer out = new StringBuffer();
int oldsize=input.length();
char[] old=new char[oldsize];
input.getChars(0,oldsize,old,0);
@@ -61,5 +62,25 @@ public class XML
{
return escapeXMLChars(input, true);
}
////////////////////////////////////////////////
// unescapeXMLChars
////////////////////////////////////////////////
public final static String unescapeXMLChars(String input)
{
if (input == null)
return null;
String outStr;
outStr = input.replace("&amp;", "&");
outStr = outStr.replace("&lt;", "<");
outStr = outStr.replace("&gt;", ">");
outStr = outStr.replace("&apos;", "\'");
outStr = outStr.replace("&quot;", "\"");
return outStr;
}
}

34
router/java/src/org/cybergarage/xml/parser/JaxpParser.java
View File

@@ -12,6 +12,10 @@
*
* 06/15/04
* - first revision.
* 01/08/08
* - Fixed parse() not to occur null exception when the NamedNodeMap is null on Android.
* 02/08/08
* - Change parse() to use Node::addValue() instead of the setValue().
*
******************************************************************/
@@ -52,11 +56,15 @@ public class JaxpParser extends Parser
String domNodeName = domNode.getNodeName();
String domNodeValue = domNode.getNodeValue();
NamedNodeMap attrs = domNode.getAttributes();
int arrrsLen = (attrs != null) ? attrs.getLength() : 0;
// Debug.message("[" + rank + "] ELEM : " + domNodeName + ", " + domNodeValue + ", type = " + domNodeType + ", attrs = " + arrrsLen);
if (domNodeType == org.w3c.dom.Node.TEXT_NODE) {
parentNode.setValue(domNodeValue);
// Change to use Node::addValue() instead of the setValue(). (2008/02/07)
//parentNode.setValue(domNodeValue);
parentNode.addValue(domNodeValue);
return parentNode;
}
@@ -71,20 +79,26 @@ public class JaxpParser extends Parser
parentNode.addNode(node);
NamedNodeMap attrMap = domNode.getAttributes();
int attrLen = attrMap.getLength();
//Debug.message("attrLen = " + attrLen);
for (int n = 0; n<attrLen; n++) {
org.w3c.dom.Node attr = attrMap.item(n);
String attrName = attr.getNodeName();
String attrValue = attr.getNodeValue();
node.setAttribute(attrName, attrValue);
if (attrMap != null) {
int attrLen = attrMap.getLength();
//Debug.message("attrLen = " + attrLen);
for (int n = 0; n<attrLen; n++) {
org.w3c.dom.Node attr = attrMap.item(n);
String attrName = attr.getNodeName();
String attrValue = attr.getNodeValue();
node.setAttribute(attrName, attrValue);
}
}
org.w3c.dom.Node child = domNode.getFirstChild();
while (child != null) {
if(child==null){
node.setValue("");
return node;
}
do{
parse(node, child, rank+1);
child = child.getNextSibling();
}
}while (child != null);
return node;
}