You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
376 lines
9.1 KiB
376 lines
9.1 KiB
//
|
|
//
|
|
//
|
|
|
|
#include "SSDPDevice.h"
|
|
#include "lwip/igmp.h"
|
|
|
|
SSDPDeviceClass::SSDPDeviceClass() :
|
|
m_server(0),
|
|
m_port(80),
|
|
m_ttl(SSDP_MULTICAST_TTL)
|
|
{
|
|
m_uuid[0] = '\0';
|
|
m_modelNumber[0] = '\0';
|
|
sprintf(m_deviceType, "urn:schemas-upnp-org:device:Basic:1");
|
|
m_friendlyName[0] = '\0';
|
|
m_presentationURL[0] = '\0';
|
|
m_serialNumber[0] = '\0';
|
|
m_modelName[0] = '\0';
|
|
m_modelURL[0] = '\0';
|
|
m_manufacturer[0] = '\0';
|
|
m_manufacturerURL[0] = '\0';
|
|
sprintf(m_schemaURL, "ssdp/schema.xml");
|
|
|
|
uint32_t chipId = ESP.getChipId();
|
|
|
|
sprintf(m_uuid, "38323636-4558-4dda-9188-cda0e6%02x%02x%02x",
|
|
(uint16_t)((chipId >> 16) & 0xff),
|
|
(uint16_t)((chipId >> 8) & 0xff),
|
|
(uint16_t)chipId & 0xff);
|
|
|
|
for (int i = 0; i < SSDP_QUEUE_SIZE; i++) {
|
|
m_queue[i].time = 0;
|
|
}
|
|
}
|
|
|
|
void SSDPDeviceClass::update() {
|
|
postNotifyUpdate();
|
|
}
|
|
|
|
bool SSDPDeviceClass::readLine(String &value) {
|
|
char buffer[65];
|
|
int bufferPos = 0;
|
|
|
|
while (1) {
|
|
int c = m_server->read();
|
|
|
|
if (c < 0) {
|
|
buffer[bufferPos] = '\0';
|
|
|
|
break;
|
|
}
|
|
if (c == '\r' && m_server->peek() == '\n') {
|
|
m_server->read();
|
|
|
|
buffer[bufferPos] = '\0';
|
|
|
|
break;
|
|
}
|
|
if (bufferPos < 64) {
|
|
buffer[bufferPos++] = c;
|
|
}
|
|
}
|
|
|
|
value = String(buffer);
|
|
|
|
return bufferPos > 0;
|
|
}
|
|
|
|
bool SSDPDeviceClass::readKeyValue(String &key, String &value) {
|
|
char buffer[65];
|
|
int bufferPos = 0;
|
|
|
|
while (1) {
|
|
int c = m_server->read();
|
|
|
|
if (c < 0) {
|
|
if (bufferPos == 0) return false;
|
|
|
|
buffer[bufferPos] = '\0';
|
|
|
|
break;
|
|
}
|
|
if (c == ':') {
|
|
buffer[bufferPos] = '\0';
|
|
|
|
while (m_server->peek() == ' ') m_server->read();
|
|
|
|
break;
|
|
}
|
|
else if (c == '\r' && m_server->peek() == '\n') {
|
|
m_server->read();
|
|
|
|
if (bufferPos == 0) return false;
|
|
|
|
buffer[bufferPos] = '\0';
|
|
|
|
key = String();
|
|
value = String(buffer);
|
|
|
|
return true;
|
|
}
|
|
if (bufferPos < 64) {
|
|
buffer[bufferPos++] = c;
|
|
}
|
|
}
|
|
|
|
key = String(buffer);
|
|
|
|
readLine(value);
|
|
|
|
return true;
|
|
}
|
|
|
|
void SSDPDeviceClass::postNotifyALive() {
|
|
unsigned long time = millis();
|
|
|
|
post(NOTIFY_ALIVE_INIT, ROOT_FOR_ALL, SSDP_MULTICAST_ADDR, SSDP_PORT, time + 10);
|
|
post(NOTIFY_ALIVE_INIT, ROOT_BY_UUID, SSDP_MULTICAST_ADDR, SSDP_PORT, time + 55);
|
|
post(NOTIFY_ALIVE_INIT, ROOT_BY_TYPE, SSDP_MULTICAST_ADDR, SSDP_PORT, time + 80);
|
|
|
|
post(NOTIFY_ALIVE_INIT, ROOT_FOR_ALL, SSDP_MULTICAST_ADDR, SSDP_PORT, time + 210);
|
|
post(NOTIFY_ALIVE_INIT, ROOT_BY_UUID, SSDP_MULTICAST_ADDR, SSDP_PORT, time + 255);
|
|
post(NOTIFY_ALIVE_INIT, ROOT_BY_TYPE, SSDP_MULTICAST_ADDR, SSDP_PORT, time + 280);
|
|
|
|
post(NOTIFY_ALIVE, ROOT_FOR_ALL, SSDP_MULTICAST_ADDR, SSDP_PORT, time + 610);
|
|
post(NOTIFY_ALIVE, ROOT_BY_UUID, SSDP_MULTICAST_ADDR, SSDP_PORT, time + 655);
|
|
post(NOTIFY_ALIVE, ROOT_BY_TYPE, SSDP_MULTICAST_ADDR, SSDP_PORT, time + 680);
|
|
}
|
|
|
|
void SSDPDeviceClass::postNotifyUpdate() {
|
|
unsigned long time = millis();
|
|
|
|
post(NOTIFY_UPDATE, ROOT_FOR_ALL, SSDP_MULTICAST_ADDR, SSDP_PORT, time + 10);
|
|
post(NOTIFY_UPDATE, ROOT_BY_UUID, SSDP_MULTICAST_ADDR, SSDP_PORT, time + 55);
|
|
post(NOTIFY_UPDATE, ROOT_BY_TYPE, SSDP_MULTICAST_ADDR, SSDP_PORT, time + 80);
|
|
}
|
|
|
|
void SSDPDeviceClass::postResponse(long mx) {
|
|
unsigned long time = millis();
|
|
unsigned long delay = random(0, mx) * 900L; // 1000 ms - 100 ms
|
|
|
|
IPAddress address = m_server->remoteIP();
|
|
uint16_t port = m_server->remotePort();
|
|
|
|
post(RESPONSE, ROOT_FOR_ALL, address, port, time + delay / 3);
|
|
post(RESPONSE, ROOT_BY_UUID, address, port, time + delay / 3 * 2);
|
|
post(RESPONSE, ROOT_BY_TYPE, address, port, time + delay);
|
|
}
|
|
|
|
void SSDPDeviceClass::postResponse(ssdp_udn_t udn, long mx) {
|
|
post(RESPONSE, udn, m_server->remoteIP(), m_server->remotePort(), millis() + random(0, mx) * 900L); // 1000 ms - 100 ms
|
|
}
|
|
|
|
void SSDPDeviceClass::post(ssdp_message_t type, ssdp_udn_t udn, IPAddress address, uint16_t port, unsigned long time) {
|
|
for (int i = 0; i < SSDP_QUEUE_SIZE; i++) {
|
|
if (m_queue[i].time == 0) {
|
|
m_queue[i].type = type;
|
|
m_queue[i].udn = udn;
|
|
m_queue[i].address = address;
|
|
m_queue[i].port = port;
|
|
m_queue[i].time = time;
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void SSDPDeviceClass::send(ssdp_send_parameters_t *parameters) {
|
|
char buffer[1460];
|
|
unsigned int ip = WiFi.localIP();
|
|
|
|
const char *typeTemplate;
|
|
const char *uri, *usn1, *usn2, *usn3;
|
|
|
|
switch (parameters->type) {
|
|
case NOTIFY_ALIVE_INIT:
|
|
case NOTIFY_ALIVE:
|
|
typeTemplate = SSDP_NOTIFY_ALIVE_TEMPLATE;
|
|
break;
|
|
case NOTIFY_UPDATE:
|
|
typeTemplate = SSDP_NOTIFY_UPDATE_TEMPLATE;
|
|
break;
|
|
default: // RESPONSE
|
|
typeTemplate = SSDP_RESPONSE_TEMPLATE;
|
|
break;
|
|
}
|
|
|
|
String uuid = "uuid:" + String(m_uuid);
|
|
|
|
switch (parameters->udn) {
|
|
case ROOT_FOR_ALL:
|
|
uri = "upnp:rootdevice";
|
|
usn1 = uuid.c_str();
|
|
usn2 = "::";
|
|
usn3 = "upnp:rootdevice";
|
|
break;
|
|
case ROOT_BY_UUID:
|
|
uri = uuid.c_str();
|
|
usn1 = uuid.c_str();
|
|
usn2 = "";
|
|
usn3 = "";
|
|
break;
|
|
case ROOT_BY_TYPE:
|
|
uri = m_deviceType;
|
|
usn1 = uuid.c_str();
|
|
usn2 = "::";
|
|
usn3 = m_deviceType;
|
|
break;
|
|
}
|
|
|
|
int len = snprintf_P(buffer, sizeof(buffer),
|
|
SSDP_PACKET_TEMPLATE, typeTemplate,
|
|
SSDP_INTERVAL, m_modelName, m_modelNumber, usn1, usn2, usn3, parameters->type == RESPONSE ? "ST" : "NT", uri,
|
|
IP2STR(&ip), m_port, m_schemaURL
|
|
);
|
|
|
|
if (parameters->address == SSDP_MULTICAST_ADDR) {
|
|
m_server->beginPacketMulticast(parameters->address, parameters->port, m_ttl);
|
|
}
|
|
else {
|
|
m_server->beginPacket(parameters->address, parameters->port);
|
|
}
|
|
|
|
m_server->write(buffer, len);
|
|
m_server->endPacket();
|
|
|
|
parameters->time = parameters->type == NOTIFY_ALIVE ? parameters->time + SSDP_INTERVAL * 900L : 0; // 1000 ms - 100 ms
|
|
}
|
|
|
|
String SSDPDeviceClass::schema() {
|
|
char buffer[1024];
|
|
uint32_t ip = WiFi.localIP();
|
|
snprintf(buffer, sizeof(buffer), SSDP_SCHEMA_TEMPLATE,
|
|
IP2STR(&ip), m_port, m_schemaURL,
|
|
m_deviceType,
|
|
m_friendlyName,
|
|
m_presentationURL,
|
|
m_serialNumber,
|
|
m_modelName,
|
|
m_modelNumber,
|
|
m_modelURL,
|
|
m_manufacturer,
|
|
m_manufacturerURL,
|
|
m_uuid
|
|
);
|
|
return String(buffer);
|
|
}
|
|
|
|
void SSDPDeviceClass::handleClient() {
|
|
IPAddress current = WiFi.localIP();
|
|
|
|
if (m_last != current) {
|
|
m_last = current;
|
|
|
|
for (int i = 0; i < SSDP_QUEUE_SIZE; i++) {
|
|
m_queue[i].time = 0;
|
|
}
|
|
|
|
if (current != INADDR_NONE) {
|
|
if (!m_server) m_server = new WiFiUDP();
|
|
|
|
m_server->beginMulticast(current, SSDP_MULTICAST_ADDR, SSDP_PORT);
|
|
|
|
postNotifyALive();
|
|
}
|
|
else if (m_server) {
|
|
m_server->stop();
|
|
}
|
|
}
|
|
|
|
if (m_server && m_server->parsePacket()) {
|
|
String value;
|
|
|
|
if (readLine(value) && value.equalsIgnoreCase("M-SEARCH * HTTP/1.1")) {
|
|
String key, st;
|
|
bool host = false, man = false;
|
|
long mx = 0;
|
|
|
|
while (readKeyValue(key, value)) {
|
|
if (key.equalsIgnoreCase("HOST") && value.equals("239.255.255.250:1900")) {
|
|
host = true;
|
|
}
|
|
else if (key.equalsIgnoreCase("MAN") && value.equals("\"ssdp:discover\"")) {
|
|
man = true;
|
|
}
|
|
else if (key.equalsIgnoreCase("ST")) {
|
|
st = value;
|
|
}
|
|
else if (key.equalsIgnoreCase("MX")) {
|
|
mx = value.toInt();
|
|
}
|
|
}
|
|
|
|
if (host && man && mx > 0) {
|
|
if (st.equals("ssdp:all")) {
|
|
postResponse(mx);
|
|
}
|
|
else if (st.equals("upnp:rootdevice")) {
|
|
postResponse(ROOT_FOR_ALL, mx);
|
|
}
|
|
else if (st.equals("uuid:" + String(m_uuid))) {
|
|
postResponse(ROOT_BY_UUID, mx);
|
|
}
|
|
else if (st.equals(m_deviceType)) {
|
|
postResponse(ROOT_BY_TYPE, mx);
|
|
}
|
|
}
|
|
}
|
|
|
|
m_server->flush();
|
|
}
|
|
else {
|
|
unsigned long time = millis();
|
|
|
|
for (int i = 0; i < SSDP_QUEUE_SIZE; i++) {
|
|
if (m_queue[i].time > 0 && m_queue[i].time < time) {
|
|
send(&m_queue[i]);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void SSDPDeviceClass::setSchemaURL(const char *url) {
|
|
strlcpy(m_schemaURL, url, sizeof(m_schemaURL));
|
|
}
|
|
|
|
void SSDPDeviceClass::setHTTPPort(uint16_t port) {
|
|
m_port = port;
|
|
}
|
|
|
|
void SSDPDeviceClass::setDeviceType(const char *deviceType) {
|
|
strlcpy(m_deviceType, deviceType, sizeof(m_deviceType));
|
|
}
|
|
|
|
void SSDPDeviceClass::setName(const char *name) {
|
|
strlcpy(m_friendlyName, name, sizeof(m_friendlyName));
|
|
}
|
|
|
|
void SSDPDeviceClass::setURL(const char *url) {
|
|
strlcpy(m_presentationURL, url, sizeof(m_presentationURL));
|
|
}
|
|
|
|
void SSDPDeviceClass::setSerialNumber(const char *serialNumber) {
|
|
strlcpy(m_serialNumber, serialNumber, sizeof(m_serialNumber));
|
|
}
|
|
|
|
void SSDPDeviceClass::setSerialNumber(const uint32_t serialNumber) {
|
|
snprintf(m_serialNumber, sizeof(uint32_t) * 2 + 1, "%08X", serialNumber);
|
|
}
|
|
|
|
void SSDPDeviceClass::setModelName(const char *name) {
|
|
strlcpy(m_modelName, name, sizeof(m_modelName));
|
|
}
|
|
|
|
void SSDPDeviceClass::setModelNumber(const char *num) {
|
|
strlcpy(m_modelNumber, num, sizeof(m_modelNumber));
|
|
}
|
|
|
|
void SSDPDeviceClass::setModelURL(const char *url) {
|
|
strlcpy(m_modelURL, url, sizeof(m_modelURL));
|
|
}
|
|
|
|
void SSDPDeviceClass::setManufacturer(const char *name) {
|
|
strlcpy(m_manufacturer, name, sizeof(m_manufacturer));
|
|
}
|
|
|
|
void SSDPDeviceClass::setManufacturerURL(const char *url) {
|
|
strlcpy(m_manufacturerURL, url, sizeof(m_manufacturerURL));
|
|
}
|
|
|
|
void SSDPDeviceClass::setTTL(const uint8_t ttl) {
|
|
m_ttl = ttl;
|
|
}
|
|
|
|
SSDPDeviceClass SSDPDevice;
|