arduino/esp8266
1
0
Fork 0
mirror of https://github.com/esp8266/Arduino.git synced 2025-04-19 23:22:16 +03:00
Code

Use static allocation, add convenience overloads which take String

Browse Source
This commit is contained in:
Ivan Grokhotkov 2015-07-07 14:42:20 +03:00
parent 49dc457fe5
commit 7fbb4831da
2 changed files with 69 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

93
libraries/ESP8266SSDP/ESP8266SSDP.cpp
View File

@ -25,14 +25,14 @@ License (MIT license):
THE SOFTWARE. THE SOFTWARE.
*/ */
#define LWIP_OPEN_SRC
#include "ESP8266SSDP.h" #include "ESP8266SSDP.h"
extern "C" { extern "C" {
#include "ip_addr.h"
#include "user_interface.h" #include "user_interface.h"
#include "mem.h" #include "mem.h"
} }
#include "lwip/ip_addr.h"
#include "lwip/igmp.h" #include "lwip/igmp.h"
//#define DEBUG_SSDP Serial //#define DEBUG_SSDP Serial
@ -43,31 +43,20 @@ extern "C" {
#define SSDP_URI_SIZE 2 #define SSDP_URI_SIZE 2
#define SSDP_BUFFER_SIZE 64 #define SSDP_BUFFER_SIZE 64
#define SSDP_UUID_SIZE 37
#define SSDP_SCHEMA_URL_SIZE 64
#define SSDP_FRIENDLY_NAME_SIZE 64
#define SSDP_SERIAL_NUMBER_SIZE 32
#define SSDP_PRESENTATION_URL_SIZE 128
#define SSDP_MODEL_NAME_SIZE 64
#define SSDP_MODEL_URL_SIZE 128
#define SSDP_MODEL_VERSION_SIZE 32
#define SSDP_MANUFACTURER_SIZE 64
#define SSDP_MANUFACTURER_URL_SIZE 128
static const IPAddress SSDP_MULTICAST_ADDR(239, 255, 255, 250); static const IPAddress SSDP_MULTICAST_ADDR(239, 255, 255, 250);
const char* _ssdp_response_template = static const char* _ssdp_response_template =
"HTTP/1.1 200 OK\r\n" "HTTP/1.1 200 OK\r\n"
"EXT:\r\n" "EXT:\r\n"
"ST: upnp:rootdevice\r\n"; "ST: upnp:rootdevice\r\n";
const char* _ssdp_notify_template = static const char* _ssdp_notify_template =
"NOTIFY * HTTP/1.1\r\n" "NOTIFY * HTTP/1.1\r\n"
"HOST: 239.255.255.250:1900\r\n" "HOST: 239.255.255.250:1900\r\n"
"NT: upnp:rootdevice\r\n" "NT: upnp:rootdevice\r\n"
"NTS: ssdp:alive\r\n"; "NTS: ssdp:alive\r\n";
const char* _ssdp_packet_template = static const char* _ssdp_packet_template =
"%s" // _ssdp_response_template / _ssdp_notify_template "%s" // _ssdp_response_template / _ssdp_notify_template
"CACHE-CONTROL: max-age=%u\r\n" // SSDP_INTERVAL "CACHE-CONTROL: max-age=%u\r\n" // SSDP_INTERVAL
"SERVER: Arduino/1.0 UPNP/1.1 %s/%s\r\n" // _modelName, _modelNumber "SERVER: Arduino/1.0 UPNP/1.1 %s/%s\r\n" // _modelName, _modelNumber
@ -75,7 +64,7 @@ const char* _ssdp_packet_template =
"LOCATION: http://%u.%u.%u.%u:%u/%s\r\n" // WiFi.localIP(), _port, _schemaURL "LOCATION: http://%u.%u.%u.%u:%u/%s\r\n" // WiFi.localIP(), _port, _schemaURL
"\r\n"; "\r\n";
const char* _ssdp_schema_template = static const char* _ssdp_schema_template =
"HTTP/1.1 200 OK\r\n" "HTTP/1.1 200 OK\r\n"
"Content-Type: text/xml\r\n" "Content-Type: text/xml\r\n"
"Connection: close\r\n" "Connection: close\r\n"
@ -120,17 +109,6 @@ const char* _ssdp_schema_template =
"\r\n"; "\r\n";
SSDPClass::SSDPClass(){ SSDPClass::SSDPClass(){
_uuid = (char*)os_malloc(SSDP_UUID_SIZE);
_schemaURL = (char*)os_malloc(SSDP_SCHEMA_URL_SIZE);
_friendlyName = (char*)os_malloc(SSDP_FRIENDLY_NAME_SIZE);
_presentationURL = (char*)os_malloc(SSDP_PRESENTATION_URL_SIZE);
_serialNumber = (char*)os_malloc(SSDP_SERIAL_NUMBER_SIZE);
_modelName = (char*)os_malloc(SSDP_MODEL_NAME_SIZE);
_modelNumber = (char*)os_malloc(SSDP_MODEL_VERSION_SIZE);
_modelURL = (char*)os_malloc(SSDP_MODEL_URL_SIZE);
_manufacturer = (char*)os_malloc(SSDP_MANUFACTURER_SIZE);
_manufacturerURL = (char*)os_malloc(SSDP_MANUFACTURER_URL_SIZE);
_uuid[0] = '\0'; _uuid[0] = '\0';
_modelNumber[0] = '\0'; _modelNumber[0] = '\0';
_friendlyName[0] = '\0'; _friendlyName[0] = '\0';
@ -146,17 +124,6 @@ SSDPClass::SSDPClass(){
} }
SSDPClass::~SSDPClass(){ SSDPClass::~SSDPClass(){
os_free(_uuid);
os_free(_schemaURL);
os_free(_friendlyName);
os_free(_presentationURL);
os_free(_serialNumber);
os_free(_modelName);
os_free(_modelNumber);
os_free(_modelURL);
os_free(_manufacturer);
os_free(_manufacturerURL);
_pending = false;
} }
void SSDPClass::begin(){ void SSDPClass::begin(){
@ -207,7 +174,7 @@ void SSDPClass::_send(ssdp_method_t method){
SSDP_INTERVAL, SSDP_INTERVAL,
_modelName, _modelNumber, _modelName, _modelNumber,
_uuid, _uuid,
(uint8_t)(ip & 0xFF), (uint8_t)((ip >> 8) & 0xFF), (uint8_t)((ip >> 16) & 0xFF), (uint8_t)((ip >> 24) & 0xFF), _port, _schemaURL IP2STR(&ip), _port, _schemaURL
); );
_server.endPacket(); _server.endPacket();
@ -216,7 +183,7 @@ void SSDPClass::_send(ssdp_method_t method){
void SSDPClass::schema(WiFiClient client){ void SSDPClass::schema(WiFiClient client){
uint32_t ip = WiFi.localIP(); uint32_t ip = WiFi.localIP();
client.printf(_ssdp_schema_template, client.printf(_ssdp_schema_template,
(uint8_t)(ip & 0xFF), (uint8_t)((ip >> 8) & 0xFF), (uint8_t)((ip >> 16) & 0xFF), (uint8_t)((ip >> 24) & 0xFF), _port, IP2STR(&ip), _port,
_friendlyName, _friendlyName,
_presentationURL, _presentationURL,
_serialNumber, _serialNumber,
@ -259,14 +226,14 @@ uint8_t SSDPClass::update(){
else state = URI; else state = URI;
cursor = 0; cursor = 0;
}else if(cursor < SSDP_METHOD_SIZE - 1){ buffer[cursor++] = c; buffer[cursor] = '\0'; } } else if(cursor < SSDP_METHOD_SIZE - 1){ buffer[cursor++] = c; buffer[cursor] = '\0'; }
break; break;
case URI: case URI:
if(c == ' '){ if(c == ' '){
if(strcmp(buffer, "*")) state = ABORT; if(strcmp(buffer, "*")) state = ABORT;
else state = PROTO; else state = PROTO;
cursor = 0; cursor = 0;
}else if(cursor < SSDP_URI_SIZE - 1){ buffer[cursor++] = c; buffer[cursor] = '\0'; } } else if(cursor < SSDP_URI_SIZE - 1){ buffer[cursor++] = c; buffer[cursor] = '\0'; }
break; break;
case PROTO: case PROTO:
if(cr == 2){ state = KEY; cursor = 0; } if(cr == 2){ state = KEY; cursor = 0; }
@ -298,7 +265,7 @@ uint8_t SSDPClass::update(){
} }
if(state != ABORT){ state = KEY; header = START; cursor = 0; } if(state != ABORT){ state = KEY; header = START; cursor = 0; }
}else if(c != '\r' && c != '\n'){ } else if(c != '\r' && c != '\n'){
if(header == START){ if(header == START){
if(strncmp(buffer, "MA", 2) == 0) header = MAN; if(strncmp(buffer, "MA", 2) == 0) header = MAN;
else if(strcmp(buffer, "ST") == 0) header = ST; else if(strcmp(buffer, "ST") == 0) header = ST;
@ -320,50 +287,50 @@ uint8_t SSDPClass::update(){
if(_pending && (millis() - _process_time) > _delay){ if(_pending && (millis() - _process_time) > _delay){
_pending = false; _delay = 0; _pending = false; _delay = 0;
_send(NONE); _send(NONE);
}else if(_notify_time == 0 || (millis() - _notify_time) > (SSDP_INTERVAL * 1000L)){ } else if(_notify_time == 0 || (millis() - _notify_time) > (SSDP_INTERVAL * 1000L)){
_notify_time = millis(); _notify_time = millis();
_send(NOTIFY); _send(NOTIFY);
} }
} }
void SSDPClass::setSchemaURL(char *url){ void SSDPClass::setSchemaURL(const char *url){
strcpy(_schemaURL, url); strlcpy(_schemaURL, url, sizeof(_schemaURL));
} }
void SSDPClass::setHTTPPort(uint16_t port){ void SSDPClass::setHTTPPort(uint16_t port){
_port = port; _port = port;
} }
void SSDPClass::setName(char *name){ void SSDPClass::setName(const char *name){
strcpy(_friendlyName, name); strlcpy(_friendlyName, name, sizeof(_friendlyName));
} }
void SSDPClass::setURL(char *url){ void SSDPClass::setURL(const char *url){
strcpy(_presentationURL, url); strlcpy(_presentationURL, url, sizeof(_presentationURL));
} }
void SSDPClass::setSerialNumber(char *serialNumber){ void SSDPClass::setSerialNumber(const char *serialNumber){
strcpy(_serialNumber, serialNumber); strlcpy(_serialNumber, serialNumber, sizeof(_serialNumber));
} }
void SSDPClass::setModelName(char *name){ void SSDPClass::setModelName(const char *name){
strcpy(_modelName, name); strlcpy(_modelName, name, sizeof(_modelName));
} }
void SSDPClass::setModelNumber(char *num){ void SSDPClass::setModelNumber(const char *num){
strcpy(_modelNumber, num); strlcpy(_modelNumber, num, sizeof(_modelNumber));
} }
void SSDPClass::setModelURL(char *url){ void SSDPClass::setModelURL(const char *url){
strcpy(_modelURL, url); strlcpy(_modelURL, url, sizeof(_modelURL));
} }
void SSDPClass::setManufacturer(char *name){ void SSDPClass::setManufacturer(const char *name){
strcpy(_manufacturer, name); strlcpy(_manufacturer, name, sizeof(_manufacturer));
} }
void SSDPClass::setManufacturerURL(char *url){ void SSDPClass::setManufacturerURL(const char *url){
strcpy(_manufacturerURL, url); strlcpy(_manufacturerURL, url, sizeof(_manufacturerURL));
} }
SSDPClass SSDP; SSDPClass SSDP;

58
libraries/ESP8266SSDP/ESP8266SSDP.h
View File

@ -33,6 +33,17 @@ License (MIT license):
#include <ESP8266WiFi.h> #include <ESP8266WiFi.h>
#include <WiFiUdp.h> #include <WiFiUdp.h>
#define SSDP_UUID_SIZE 37
#define SSDP_SCHEMA_URL_SIZE 64
#define SSDP_FRIENDLY_NAME_SIZE 64
#define SSDP_SERIAL_NUMBER_SIZE 32
#define SSDP_PRESENTATION_URL_SIZE 128
#define SSDP_MODEL_NAME_SIZE 64
#define SSDP_MODEL_URL_SIZE 128
#define SSDP_MODEL_VERSION_SIZE 32
#define SSDP_MANUFACTURER_SIZE 64
#define SSDP_MANUFACTURER_URL_SIZE 128
typedef enum { typedef enum {
NONE, NONE,
SEARCH, SEARCH,
@ -48,16 +59,25 @@ class SSDPClass{
uint8_t update(); uint8_t update();
void schema(WiFiClient client); void schema(WiFiClient client);
void setName(char *name); void setName(const String& name) { setName(name.c_str()); }
void setURL(char *url); void setName(const char *name);
void setSchemaURL(char *url); void setURL(const String& url) { setURL(url.c_str()); }
void setURL(const char *url);
void setSchemaURL(const String& url) { setSchemaURL(url.c_str()); }
void setSchemaURL(const char *url);
void setSerialNumber(const String& serialNumber) { setSerialNumber(serialNumber.c_str()); }
void setSerialNumber(const char *serialNumber);
void setModelName(const String& name) { setModelName(name.c_str()); }
void setModelName(const char *name);
void setModelNumber(const String& num) { setModelNumber(num.c_str()); }
void setModelNumber(const char *num);
void setModelURL(const String& url) { setModelURL(url.c_str()); }
void setModelURL(const char *url);
void setManufacturer(const String& name) { setManufacturer(name.c_str()); }
void setManufacturer(const char *name);
void setManufacturerURL(const String& url) { setManufacturerURL(url.c_str()); }
void setManufacturerURL(const char *url);
void setHTTPPort(uint16_t port); void setHTTPPort(uint16_t port);
void setSerialNumber(char *serialNumber);
void setModelName(char *name);
void setModelNumber(char *num);
void setModelURL(char *url);
void setManufacturer(char *name);
void setManufacturerURL(char *url);
private: private:
WiFiUDP _server; WiFiUDP _server;
@ -67,16 +87,16 @@ class SSDPClass{
unsigned long _notify_time; unsigned long _notify_time;
uint16_t _port; uint16_t _port;
char *_schemaURL; char _schemaURL[SSDP_SCHEMA_URL_SIZE];
char *_uuid; char _uuid[SSDP_UUID_SIZE];
char *_friendlyName; char _friendlyName[SSDP_FRIENDLY_NAME_SIZE];
char *_serialNumber; char _serialNumber[SSDP_SERIAL_NUMBER_SIZE];
char *_presentationURL; char _presentationURL[SSDP_PRESENTATION_URL_SIZE];
char *_manufacturer; char _manufacturer[SSDP_MANUFACTURER_SIZE];
char *_manufacturerURL; char _manufacturerURL[SSDP_MANUFACTURER_URL_SIZE];
char *_modelName; char _modelName[SSDP_MODEL_NAME_SIZE];
char *_modelURL; char _modelURL[SSDP_MODEL_URL_SIZE];
char *_modelNumber; char _modelNumber[SSDP_MODEL_VERSION_SIZE];
void _send(ssdp_method_t method); void _send(ssdp_method_t method);
}; };