282 lines
9.3 KiB
Java
Executable file
282 lines
9.3 KiB
Java
Executable file
/*
|
|
* The MIT License (MIT)
|
|
*
|
|
* Copyright (c) 2015 Ziver Koc
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
|
|
package zutil.net.ssdp;
|
|
|
|
import zutil.log.LogUtil;
|
|
import zutil.net.http.HttpHeader;
|
|
import zutil.net.http.HttpHeaderParser;
|
|
import zutil.net.http.HttpPrintStream;
|
|
import zutil.net.threaded.ThreadedUDPNetwork;
|
|
import zutil.net.threaded.ThreadedUDPNetworkThread;
|
|
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.IOException;
|
|
import java.net.DatagramPacket;
|
|
import java.net.InetAddress;
|
|
import java.util.HashMap;
|
|
import java.util.LinkedList;
|
|
import java.util.logging.Level;
|
|
import java.util.logging.Logger;
|
|
|
|
import static zutil.net.ssdp.SSDPServer.SSDP_MULTICAST_ADDR;
|
|
import static zutil.net.ssdp.SSDPServer.SSDP_PORT;
|
|
|
|
/**
|
|
* An SSDP client class that will request
|
|
* service information.
|
|
*
|
|
* @author Ziver
|
|
*/
|
|
public class SSDPClient extends ThreadedUDPNetwork implements ThreadedUDPNetworkThread{
|
|
private static final Logger logger = LogUtil.getLogger();
|
|
public static final String USER_AGENT = "Zutil SSDP Client";
|
|
/** Mapping of search targets and list of associated services **/
|
|
private HashMap<String, LinkedList<StandardSSDPInfo>> services_st;
|
|
/** Map of all unique services received **/
|
|
private HashMap<String, StandardSSDPInfo> services_usn;
|
|
|
|
private SSDPServiceListener listener;
|
|
|
|
|
|
/**
|
|
* Creates new instance of this class. An UDP
|
|
* listening socket at the SSDP port.
|
|
*
|
|
* @throws IOException
|
|
*/
|
|
public SSDPClient() throws IOException{
|
|
super( SSDP_MULTICAST_ADDR, SSDP_PORT );
|
|
super.setThread(this);
|
|
|
|
services_st = new HashMap<>();
|
|
services_usn = new HashMap<>();
|
|
}
|
|
|
|
/**
|
|
* Sends an request for an service
|
|
*
|
|
* @param searchTarget is the SearchTarget of the service
|
|
*
|
|
* ***** REQUEST:
|
|
* M-SEARCH * HTTP/1.1
|
|
* Host: 239.255.255.250:reservedSSDPport
|
|
* Man: "ssdp:discover"
|
|
* ST: ge:fridge
|
|
* MX: 3
|
|
*
|
|
*/
|
|
public void requestService(String searchTarget){
|
|
requestService(searchTarget, null);
|
|
}
|
|
public void requestService(String searchTarget, HashMap<String,String> headers){
|
|
try {
|
|
// Generate an SSDP discover message
|
|
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
|
|
HttpPrintStream http = new HttpPrintStream( buffer, HttpPrintStream.HttpMessageType.REQUEST );
|
|
http.setRequestType("M-SEARCH");
|
|
http.setRequestURL("*");
|
|
http.setHeader("Host", SSDP_MULTICAST_ADDR +":"+ SSDP_PORT );
|
|
http.setHeader("ST", searchTarget );
|
|
http.setHeader("Man", "\"ssdp:discover\"" );
|
|
http.setHeader("MX", "3" );
|
|
http.setHeader("USER-AGENT", USER_AGENT );
|
|
if(headers != null) {
|
|
for (String key : headers.keySet()) {
|
|
http.setHeader(key, headers.get(key));
|
|
}
|
|
}
|
|
logger.log(Level.FINEST, "Sending Multicast: "+ http);
|
|
http.flush();
|
|
|
|
byte[] data = buffer.toByteArray();
|
|
//System.out.println(new String(data)+"****************");
|
|
DatagramPacket packet = new DatagramPacket(
|
|
data, data.length,
|
|
InetAddress.getByName( SSDP_MULTICAST_ADDR ),
|
|
SSDP_PORT );
|
|
super.send( packet );
|
|
http.close();
|
|
} catch (Exception e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Set a listener that will be notified when new services are detected
|
|
*/
|
|
public void setListener(SSDPServiceListener listener){
|
|
this.listener = listener;
|
|
}
|
|
|
|
/**
|
|
* Returns a list of received services by
|
|
* the given search target.
|
|
*
|
|
* @param searchTarget is the search target
|
|
* @return a list of received services
|
|
*/
|
|
public LinkedList<StandardSSDPInfo> getServices(String searchTarget){
|
|
if(services_st.get(searchTarget) == null)
|
|
return new LinkedList<>();
|
|
return services_st.get(searchTarget);
|
|
}
|
|
|
|
/**
|
|
* Returns the amount of services in the search target
|
|
*
|
|
* @param searchTarget is the search target
|
|
* @return the amount of services cached
|
|
*/
|
|
public int getServicesCount(String searchTarget){
|
|
if(services_st.containsKey(searchTarget)){
|
|
return services_st.get(searchTarget).size();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Returns a service with the given USN.
|
|
*
|
|
* @param usn is the unique identifier for a service
|
|
* @return an service, null if there is no such service
|
|
*/
|
|
public StandardSSDPInfo getService(String usn){
|
|
return services_usn.get( usn );
|
|
}
|
|
|
|
/**
|
|
* Clears all the received information of the services
|
|
*/
|
|
public void clearServices(){
|
|
services_usn.clear();
|
|
services_st.clear();
|
|
}
|
|
/**
|
|
* Clears all services matching the search target
|
|
*/
|
|
public void clearServices(String st){
|
|
if(services_st.get(st) != null) {
|
|
for (StandardSSDPInfo service : services_st.get(st)) {
|
|
services_usn.remove(service.getUSN());
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Waits for responses
|
|
*
|
|
* ***** RESPONSE;
|
|
* HTTP/1.1 200 OK
|
|
* Ext:
|
|
* Cache-Control: no-cache="Ext", max-age = 5000
|
|
* ST: ge:fridge
|
|
* USN: uuid:abcdefgh-7dec-11d0-a765-00a0c91e6bf6
|
|
* Location: http://localhost:80
|
|
*/
|
|
public void receivedPacket(DatagramPacket packet, ThreadedUDPNetwork network) {
|
|
try {
|
|
String msg = new String(packet.getData(), packet.getOffset(), packet.getLength());
|
|
HttpHeaderParser headerParser = new HttpHeaderParser(msg);
|
|
HttpHeader header = headerParser.read();
|
|
|
|
String usn = header.getHeader("USN");
|
|
String st = header.getHeader("ST");
|
|
StandardSSDPInfo service = null;
|
|
// Get existing service
|
|
if (services_usn.containsKey(usn)) {
|
|
service = services_usn.get(usn);
|
|
}
|
|
|
|
// Remove service
|
|
if ("NOTIFY".equals(header.getRequestType()) && "ssdp:byebye".equalsIgnoreCase(header.getHeader("NTS"))){
|
|
logger.log(Level.FINER, "Received NOTIFY:byebye (from: " + packet.getAddress() + "): " + header);
|
|
if (service != null) {
|
|
services_usn.remove(usn);
|
|
if (services_st.containsKey(st))
|
|
services_st.get(st).remove(service);
|
|
if (listener != null)
|
|
listener.serviceLost(service);
|
|
}
|
|
}
|
|
// Existing or new service update
|
|
else if (header.isResponse() || "NOTIFY".equals(header.getRequestType())) {
|
|
logger.log(Level.FINER, "Received service update (from: " + packet.getAddress() + "): " + header);
|
|
boolean newService = false;
|
|
|
|
// Add new service
|
|
if (service == null){
|
|
newService = true;
|
|
service = new StandardSSDPInfo();
|
|
services_usn.put(usn, service);
|
|
if (!services_st.containsKey(st))
|
|
services_st.put(st, new LinkedList<StandardSSDPInfo>());
|
|
services_st.get(header.getHeader("ST")).add(service);
|
|
}
|
|
|
|
service.setLocation(header.getHeader("LOCATION"));
|
|
service.setST(st);
|
|
service.setUSN(usn);
|
|
service.setInetAddress(packet.getAddress());
|
|
if (header.getHeader("Cache-Control") != null) {
|
|
service.setExpirationTime(
|
|
System.currentTimeMillis() + 1000 * getCacheTime(header.getHeader("Cache-Control")));
|
|
}
|
|
service.readHeaders(header);
|
|
|
|
if (listener != null && newService)
|
|
listener.serviceDiscovered(service);
|
|
}
|
|
else {
|
|
logger.log(Level.FINEST, "Ignored (from: " + packet.getAddress() + "): " + header);
|
|
}
|
|
} catch (IOException e){
|
|
logger.log(Level.SEVERE, null, e);
|
|
}
|
|
}
|
|
|
|
private long getCacheTime(String cache_control){
|
|
long ret = 0;
|
|
String[] tmp = cache_control.split(",");
|
|
for( String element : tmp ){
|
|
element = element.replaceAll("\\s", "").toLowerCase();
|
|
if( element.startsWith("max-age=") ){
|
|
ret = Long.parseLong( element.substring( "max-age=".length() ) );
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
public interface SSDPServiceListener{
|
|
/**
|
|
* Is called when a new service is discovered. Will only be called once per service.
|
|
*/
|
|
void serviceDiscovered(StandardSSDPInfo service);
|
|
|
|
/**
|
|
* Is called when a service goes down and is not available anymore.
|
|
*/
|
|
void serviceLost(StandardSSDPInfo service);
|
|
}
|
|
}
|