David Smart / SW_HTTPServer

A simple web server that can be bound to either the EthernetInterface or the WiflyInterface.

Dependents:   Smart-WiFly-WebServer WattEye X10Svr SSDP_Server

SW_HTTPServer.cpp@58:5303e962f711, 2018-11-18 (annotated)

Committer:
WiredHome
Date:
Sun Nov 18 04:04:16 2018 +0000
Revision:
58:5303e962f711
Parent:
57:fb81057b4d77
Child:
59:9a71ac02c782
Use secure versions of strcpy, strcat.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
WiredHome 0:729320f63c5c 1 //
WiredHome 44:71f09e4255f4 2 // @note Copyright © 2014-2016 by Smartware Computing, all rights reserved.
WiredHome 0:729320f63c5c 3 // Individuals may use this application for evaluation or non-commercial
WiredHome 0:729320f63c5c 4 // purposes. Within this restriction, changes may be made to this application
WiredHome 0:729320f63c5c 5 // as long as this copyright notice is retained. The user shall make
WiredHome 0:729320f63c5c 6 // clear that their work is a derived work, and not the original.
WiredHome 0:729320f63c5c 7 // Users of this application and sources accept this application "as is" and
WiredHome 0:729320f63c5c 8 // shall hold harmless Smartware Computing, for any undesired results while
WiredHome 0:729320f63c5c 9 // using this application - whether real or imagined.
WiredHome 0:729320f63c5c 10 //
WiredHome 0:729320f63c5c 11 // author David Smart, Smartware Computing
WiredHome 0:729320f63c5c 12 //
WiredHome 0:729320f63c5c 13 #include "mbed.h"
WiredHome 58:5303e962f711 14 #include "SW_String.h" // Secure methods and others that were missing
WiredHome 29:00116fc9da74 15
WiredHome 58:5303e962f711 16 #define DEBUG "HTTP"
WiredHome 38:c8fa31e6fe02 17 #include <cstdio>
WiredHome 38:c8fa31e6fe02 18 #if (defined(DEBUG) && !defined(TARGET_LPC11U24))
WiredHome 58:5303e962f711 19 #define DBG(x, ...) std::printf("[DBG %s %4d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome 58:5303e962f711 20 #define WARN(x, ...) std::printf("[WRN %s %4d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome 58:5303e962f711 21 #define ERR(x, ...) std::printf("[ERR %s %4d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome 58:5303e962f711 22 #define INFO(x, ...) std::printf("[INF %s %4d] "x"\r\n", DEBUG, __LINE__, ##__VA_ARGS__);
WiredHome 38:c8fa31e6fe02 23 #else
WiredHome 38:c8fa31e6fe02 24 #define DBG(x, ...)
WiredHome 38:c8fa31e6fe02 25 #define WARN(x, ...)
WiredHome 38:c8fa31e6fe02 26 #define ERR(x, ...)
WiredHome 38:c8fa31e6fe02 27 #define INFO(x, ...)
WiredHome 38:c8fa31e6fe02 28 #endif
WiredHome 38:c8fa31e6fe02 29
WiredHome 58:5303e962f711 30 extern void ShowSignOfLife(int which);
WiredHome 33:ef165a67ab22 31
WiredHome 31:8f72be717a3c 32 #include "SW_HTTPServer.h" // define DEBUG before this
WiredHome 27:90a1f5a5392f 33
WiredHome 33:ef165a67ab22 34 #define CHUNK_SIZE 1500 // max size of a single chunk (probably limited by Ethernet to 1500)
WiredHome 33:ef165a67ab22 35 #define HANG_TIMEOUT_MS 250 // If we're waiting on the host, which may never respond, this is the timeout
WiredHome 0:729320f63c5c 36
WiredHome 0:729320f63c5c 37 const char * DEFAULT_FILENAME = "index.htm";
WiredHome 0:729320f63c5c 38
WiredHome 8:262583f054f6 39 // Header information to always send (must be \r\n terminated)
WiredHome 44:71f09e4255f4 40 static const char hdr_httpver[] = "HTTP/1.1"; // supported HTTP/1.1 protocol (sort of)
WiredHome 44:71f09e4255f4 41 static const char nl[] = "\r\n"; // final \r\n for the termination of the header
WiredHome 0:729320f63c5c 42
WiredHome 44:71f09e4255f4 43 // Header items that are sent if the user does not provide their own options.
WiredHome 44:71f09e4255f4 44 static const char hdr_age[] = "Max-age: 0\r\n"; // expires right away
WiredHome 44:71f09e4255f4 45 static const char hdr_server[] = "Server: Smart_Server v0.2\r\n"; // Server
WiredHome 44:71f09e4255f4 46 static const char hdr_close[] = "Connection: close\r\n"; // tell the client the server closes the connection immediately
WiredHome 14:19c5f6151319 47
WiredHome 0:729320f63c5c 48 static const struct {
WiredHome 0:729320f63c5c 49 char *ext;
WiredHome 0:729320f63c5c 50 char *filetype;
WiredHome 0:729320f63c5c 51 } extensions [] = {
WiredHome 3:17928786bdb5 52 {".gif", "Content-Type: image/gif\r\n" },
WiredHome 3:17928786bdb5 53 {".jpg", "Content-Type: image/jpeg\r\n" },
WiredHome 3:17928786bdb5 54 {".jpeg","Content-Type: image/jpeg\r\n" },
WiredHome 3:17928786bdb5 55 {".ico", "Content-Type: image/x-icon\r\n" },
WiredHome 33:ef165a67ab22 56 {".bmp", "Content-Type: image/bmp\r\n" },
WiredHome 3:17928786bdb5 57 {".png", "Content-Type: image/png\r\n" },
WiredHome 3:17928786bdb5 58 {".zip", "Content-Type: image/zip\r\n" },
WiredHome 3:17928786bdb5 59 {".gz", "Content-Type: image/gz\r\n" },
WiredHome 3:17928786bdb5 60 {".tar", "Content-Type: image/tar\r\n" },
WiredHome 3:17928786bdb5 61 {".txt", "Content-Type: plain/text\r\n" },
WiredHome 3:17928786bdb5 62 {".pdf", "Content-Type: application/pdf\r\n" },
WiredHome 3:17928786bdb5 63 {".htm", "Content-Type: text/html\r\n" },
WiredHome 3:17928786bdb5 64 {".html","Content-Type: text/html\r\n" },
WiredHome 44:71f09e4255f4 65 {".xml", "Content-Type: text/xml\r\n" },
WiredHome 47:4c29c8f0cff2 66 {".js", "Content-Type: text/javascript\r\n" },
WiredHome 0:729320f63c5c 67 {0,0}
WiredHome 0:729320f63c5c 68 };
WiredHome 0:729320f63c5c 69
WiredHome 44:71f09e4255f4 70 typedef struct {
WiredHome 44:71f09e4255f4 71 char * queryType;
WiredHome 44:71f09e4255f4 72 int notused;
WiredHome 44:71f09e4255f4 73 } QueryMethod;
WiredHome 44:71f09e4255f4 74
WiredHome 44:71f09e4255f4 75 // Be sure to include a trailing space.
WiredHome 44:71f09e4255f4 76 static const QueryMethod QueryMethodList[] = {
WiredHome 44:71f09e4255f4 77 {"GET ", 0},
WiredHome 44:71f09e4255f4 78 {"POST ", 0},
WiredHome 44:71f09e4255f4 79 {"HEAD ", 0},
WiredHome 44:71f09e4255f4 80 {"PUT ", 0},
WiredHome 44:71f09e4255f4 81 {"OPTION ", 0},
WiredHome 44:71f09e4255f4 82 {"DELETE ", 0},
WiredHome 44:71f09e4255f4 83 {"TRACE ", 0},
WiredHome 44:71f09e4255f4 84 {"CONNECT ", 0},
WiredHome 44:71f09e4255f4 85 {NULL, 0}
WiredHome 44:71f09e4255f4 86 };
WiredHome 44:71f09e4255f4 87
WiredHome 30:864843965b40 88 #if 0 && defined(DEBUG)
WiredHome 30:864843965b40 89 // Haven't learned anything from this in a long time, so disabled.
WiredHome 12:109bf1558300 90 // This uses standard library dynamic memory management, but for an
WiredHome 9:2ea342765c9d 91 // embedded system there are alternates that may make better sense -
WiredHome 9:2ea342765c9d 92 // search the web for embedded system malloc alternates.
WiredHome 29:00116fc9da74 93 void * HTTPServer::MyMalloc(int x, int y)
WiredHome 8:262583f054f6 94 {
WiredHome 29:00116fc9da74 95 pc->printf("[INF HTTP%4d] malloc(%d)\r\n", y, x);
WiredHome 8:262583f054f6 96 return malloc(x);
WiredHome 8:262583f054f6 97 }
WiredHome 29:00116fc9da74 98 char HTTPServer::toP(void * x)
WiredHome 11:17d84c41a7b3 99 {
WiredHome 11:17d84c41a7b3 100 char * c = (char *) x;
WiredHome 30:864843965b40 101 if (*c >= ' ' && *c < 0x7F) // isprint()
WiredHome 11:17d84c41a7b3 102 return *c;
WiredHome 11:17d84c41a7b3 103 else
WiredHome 11:17d84c41a7b3 104 return '.';
WiredHome 11:17d84c41a7b3 105 }
WiredHome 8:262583f054f6 106 #define mymalloc(x) MyMalloc(x, __LINE__)
WiredHome 8:262583f054f6 107 #define myfree(x) \
WiredHome 25:f7d6df7a700a 108 pc->printf("[INF HTTP%4d] free(%02x %02x %02x %02x %02x ... %c%c%c%c%c)\r\n", __LINE__, \
WiredHome 11:17d84c41a7b3 109 *x, *(x+1), *(x+2), *(x+3), *(x+4), \
WiredHome 11:17d84c41a7b3 110 toP(x), toP(x+1), toP(x+2), toP(x+3), toP(x+4) ); \
WiredHome 8:262583f054f6 111 free(x);
WiredHome 8:262583f054f6 112 #else
WiredHome 8:262583f054f6 113 #define mymalloc(x) malloc(x)
WiredHome 8:262583f054f6 114 #define myfree(x) free(x)
WiredHome 8:262583f054f6 115 #endif
WiredHome 8:262583f054f6 116
WiredHome 58:5303e962f711 117
WiredHome 58:5303e962f711 118
WiredHome 3:17928786bdb5 119 HTTPServer::HTTPServer(
WiredHome 7:99ad7a67f05e 120 int port,
WiredHome 7:99ad7a67f05e 121 const char * _webroot,
WiredHome 43:3fc773c2986e 122 int _maxheaderParams,
WiredHome 13:8975d7928678 123 int _maxqueryParams,
WiredHome 7:99ad7a67f05e 124 int _maxdynamicpages,
WiredHome 49:cd391662f254 125 int blockingtime,
WiredHome 7:99ad7a67f05e 126 PC * _pc,
WiredHome 7:99ad7a67f05e 127 int _allocforheader,
WiredHome 49:cd391662f254 128 int _allocforfile
WiredHome 49:cd391662f254 129 )
WiredHome 0:729320f63c5c 130 {
WiredHome 58:5303e962f711 131 int wrSize = strlen(_webroot)+1;
WiredHome 58:5303e962f711 132
WiredHome 58:5303e962f711 133 webroot = (char *)malloc(wrSize);
WiredHome 58:5303e962f711 134 strcpy_s(webroot, wrSize, _webroot);
WiredHome 27:90a1f5a5392f 135 if (strlen(webroot)>1 && webroot[strlen(webroot)-1] == '/') // remove trailing '/'
WiredHome 27:90a1f5a5392f 136 webroot[strlen(webroot)-1] = '\0';
WiredHome 44:71f09e4255f4 137 filenameAliasList = NULL;
WiredHome 43:3fc773c2986e 138 maxheaderParams = _maxheaderParams;
WiredHome 13:8975d7928678 139 headerParams = (namevalue *)malloc(maxheaderParams * sizeof(namevalue));
WiredHome 39:0427544a5c08 140
WiredHome 39:0427544a5c08 141 maxqueryParams = _maxqueryParams;
WiredHome 13:8975d7928678 142 queryParams = (namevalue *)malloc(maxqueryParams * sizeof(namevalue));
WiredHome 39:0427544a5c08 143 queryParamCount = 0;
WiredHome 39:0427544a5c08 144
WiredHome 39:0427544a5c08 145 maxPostParams = _maxqueryParams; // Same as Query params, but for post method
WiredHome 39:0427544a5c08 146 postParams = (namevalue *)malloc(maxPostParams * sizeof(namevalue));
WiredHome 39:0427544a5c08 147 postParamCount = 0;
WiredHome 43:3fc773c2986e 148 maxdynamicpages = _maxdynamicpages;
WiredHome 0:729320f63c5c 149 handlers = (handler *)malloc(maxdynamicpages * sizeof(handler));
WiredHome 3:17928786bdb5 150 headerbuffersize = _allocforheader;
WiredHome 3:17928786bdb5 151 headerbuffer = (char *)malloc(headerbuffersize);
WiredHome 0:729320f63c5c 152 pc = _pc;
WiredHome 3:17928786bdb5 153 queryType = NULL;
WiredHome 3:17928786bdb5 154 queryString = NULL;
WiredHome 3:17928786bdb5 155 postQueryString = NULL;
WiredHome 0:729320f63c5c 156 handlercount = 0;
WiredHome 3:17928786bdb5 157 maxheaderbytes = 0;
WiredHome 0:729320f63c5c 158 server = new TCPSocketServer();
WiredHome 0:729320f63c5c 159 server->bind(port);
WiredHome 51:758601b9bacd 160 server->listen(5);
WiredHome 57:fb81057b4d77 161 server->set_blocking(false, blockingtime);
WiredHome 56:df915cb8ba9a 162 client.set_blocking(true, blockingtime); //@TODO client is separate from server. any way to combine?
WiredHome 3:17928786bdb5 163 ResetPerformanceData();
WiredHome 10:9c8d2c6a3469 164 PerformanceTimer.start();
WiredHome 0:729320f63c5c 165 }
WiredHome 0:729320f63c5c 166
WiredHome 0:729320f63c5c 167 HTTPServer::~HTTPServer()
WiredHome 0:729320f63c5c 168 {
WiredHome 8:262583f054f6 169 int i;
WiredHome 8:262583f054f6 170
WiredHome 8:262583f054f6 171 for (i=0; i<handlercount; i++)
WiredHome 8:262583f054f6 172 myfree(handlers[i].path);
WiredHome 8:262583f054f6 173 myfree(headerbuffer);
WiredHome 8:262583f054f6 174 myfree(handlers);
WiredHome 13:8975d7928678 175 myfree(queryParams);
WiredHome 8:262583f054f6 176 myfree(webroot);
WiredHome 0:729320f63c5c 177 webroot = NULL;
WiredHome 0:729320f63c5c 178 }
WiredHome 0:729320f63c5c 179
WiredHome 44:71f09e4255f4 180 void HTTPServer::RegisterFilenameAliasList(const namevalue * namevaluelist)
WiredHome 44:71f09e4255f4 181 {
WiredHome 44:71f09e4255f4 182 filenameAliasList = namevaluelist;
WiredHome 44:71f09e4255f4 183 }
WiredHome 44:71f09e4255f4 184
WiredHome 3:17928786bdb5 185 int HTTPServer::GetMaxHeaderSize()
WiredHome 3:17928786bdb5 186 {
WiredHome 3:17928786bdb5 187 return maxheaderbytes;
WiredHome 3:17928786bdb5 188 }
WiredHome 3:17928786bdb5 189
WiredHome 0:729320f63c5c 190 bool HTTPServer::RegisterHandler(const char * path, Handler callback)
WiredHome 0:729320f63c5c 191 {
WiredHome 0:729320f63c5c 192 if (handlercount < maxdynamicpages && path && callback) {
WiredHome 8:262583f054f6 193 handlers[handlercount].path = (char *)mymalloc(strlen(path)+1);
WiredHome 0:729320f63c5c 194 memcpy(handlers[handlercount].path, path, strlen(path)+1);
WiredHome 0:729320f63c5c 195 handlers[handlercount].callback = callback;
WiredHome 0:729320f63c5c 196 handlercount++;
WiredHome 0:729320f63c5c 197 return true;
WiredHome 0:729320f63c5c 198 } else {
WiredHome 0:729320f63c5c 199 return false;
WiredHome 0:729320f63c5c 200 }
WiredHome 0:729320f63c5c 201 }
WiredHome 0:729320f63c5c 202
WiredHome 2:a29c32190037 203 // Poll()
WiredHome 0:729320f63c5c 204 //
WiredHome 0:729320f63c5c 205 // *OPEN*GET /x=1 HTTP/1.1
WiredHome 0:729320f63c5c 206 // Host: 192.168.1.140
WiredHome 0:729320f63c5c 207 // Connection: keep-alive
WiredHome 0:729320f63c5c 208 // Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
WiredHome 0:729320f63c5c 209 // User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/27.0.1453.94 Safari/537.36
WiredHome 0:729320f63c5c 210 // Accept-Encoding: gzip,deflate,sdch
WiredHome 0:729320f63c5c 211 // Accept-Language: en-US,en;q=0.8
WiredHome 0:729320f63c5c 212 //
WiredHome 2:a29c32190037 213 void HTTPServer::Poll()
WiredHome 0:729320f63c5c 214 {
WiredHome 3:17928786bdb5 215 typedef enum {
WiredHome 3:17928786bdb5 216 Idle, // waiting for a connection
WiredHome 29:00116fc9da74 217 ReceivingHeader, // receiving header
WiredHome 29:00116fc9da74 218 ReceivingPayload, // receiving a section after the Header
WiredHome 3:17928786bdb5 219 Sending, // send the response
WiredHome 7:99ad7a67f05e 220 WaitingToClose, // small timeout to close
WiredHome 7:99ad7a67f05e 221 Reset
WiredHome 3:17928786bdb5 222 } state;
WiredHome 0:729320f63c5c 223 static state op = Idle;
WiredHome 3:17928786bdb5 224 static char * bPtr = headerbuffer;
WiredHome 0:729320f63c5c 225 int n;
WiredHome 16:6ebacf2946d8 226 static unsigned int t_ref; // reference point for the PerformanceTimer
WiredHome 0:729320f63c5c 227
WiredHome 20:786aa5749007 228 #if defined(DEBUG)
WiredHome 8:262583f054f6 229 static state lastOp = Reset;
WiredHome 7:99ad7a67f05e 230 if (lastOp != op) {
WiredHome 29:00116fc9da74 231 const char *states[] = {"Idle", "ReceivingHeader", "ReceivingPayload", "Sending", "WaitingToClose", "Reset"};
WiredHome 58:5303e962f711 232 INFO("Poll: %-30s ######## %8u us", states[op], (unsigned int)PerformanceTimer.read_us()-t_ref);
WiredHome 7:99ad7a67f05e 233 lastOp = op;
WiredHome 7:99ad7a67f05e 234 }
WiredHome 8:262583f054f6 235 #endif
WiredHome 0:729320f63c5c 236 switch(op) {
WiredHome 3:17928786bdb5 237 default: // not expected to arrive here
WiredHome 3:17928786bdb5 238 op = Idle;
WiredHome 3:17928786bdb5 239 break;
WiredHome 8:262583f054f6 240
WiredHome 3:17928786bdb5 241 case Idle:
WiredHome 58:5303e962f711 242 ShowSignOfLife(3);
WiredHome 10:9c8d2c6a3469 243 PerformanceTimer.reset();
WiredHome 17:69ff00ce39f4 244 t_ref = (unsigned int)PerformanceTimer.read_us();
WiredHome 3:17928786bdb5 245 bPtr = headerbuffer;
WiredHome 11:17d84c41a7b3 246 if (0 == server->accept(client)) {
WiredHome 29:00116fc9da74 247 op = ReceivingHeader;
WiredHome 17:69ff00ce39f4 248 t_ref = RecordPerformanceData(&perfData.ConnectionAccepted, t_ref);
WiredHome 58:5303e962f711 249 INFO("Accepted at %8u us",
WiredHome 58:5303e962f711 250 (unsigned int)PerformanceTimer.read_us()-t_ref);
WiredHome 48:078adbe279ac 251 } else {
WiredHome 49:cd391662f254 252 //INFO("Timeout waiting for accept()");
WiredHome 3:17928786bdb5 253 }
WiredHome 0:729320f63c5c 254 break;
WiredHome 8:262583f054f6 255
WiredHome 29:00116fc9da74 256 case ReceivingHeader:
WiredHome 3:17928786bdb5 257 n = client.receive(bPtr, headerbuffersize - (bPtr - headerbuffer));
WiredHome 58:5303e962f711 258 INFO("client.receive() returned %d, from %s", n, client.get_address());
WiredHome 55:238dd90b6fb3 259 if (n == -2) {
WiredHome 55:238dd90b6fb3 260 // was hang here waiting ... op = Sending; which causes misses
WiredHome 58:5303e962f711 261 op = WaitingToClose;
WiredHome 55:238dd90b6fb3 262 } else if (n < 0) {
WiredHome 58:5303e962f711 263 op = WaitingToClose; // bail out...
WiredHome 3:17928786bdb5 264 } else if (n) {
WiredHome 3:17928786bdb5 265 bPtr[n] = '\0';
WiredHome 29:00116fc9da74 266 switch (ParseHeader(headerbuffer)) {
WiredHome 29:00116fc9da74 267 case ACCEPT_ERROR:
WiredHome 29:00116fc9da74 268 break;
WiredHome 29:00116fc9da74 269 case ACCEPT_COMPLETE:
WiredHome 29:00116fc9da74 270 op = Sending;
WiredHome 29:00116fc9da74 271 t_ref = RecordPerformanceData(&perfData.HeaderParsed, t_ref);
WiredHome 58:5303e962f711 272 INFO("Header Parsed at %8u us",
WiredHome 58:5303e962f711 273 (unsigned int)PerformanceTimer.read_us()-t_ref);
WiredHome 29:00116fc9da74 274 break;
WiredHome 29:00116fc9da74 275 case ACCEPT_CONTINUE:
WiredHome 29:00116fc9da74 276 op = ReceivingPayload;
WiredHome 29:00116fc9da74 277 break;
WiredHome 3:17928786bdb5 278 }
WiredHome 3:17928786bdb5 279 bPtr += n;
WiredHome 0:729320f63c5c 280 }
WiredHome 0:729320f63c5c 281 break;
WiredHome 8:262583f054f6 282
WiredHome 29:00116fc9da74 283 case ReceivingPayload:
WiredHome 29:00116fc9da74 284 // After the header, there is a payload that will be handled
WiredHome 33:ef165a67ab22 285 #if 1
WiredHome 58:5303e962f711 286 INFO("ReceivingPayload %8u us",
WiredHome 58:5303e962f711 287 (unsigned int)PerformanceTimer.read_us()-t_ref);
WiredHome 33:ef165a67ab22 288 n = client.receive(bPtr, headerbuffersize - (bPtr - headerbuffer));
WiredHome 33:ef165a67ab22 289 if (n < 0) {
WiredHome 33:ef165a67ab22 290 op = Sending;
WiredHome 33:ef165a67ab22 291 INFO("*** client.receive() => %d", n);
WiredHome 33:ef165a67ab22 292 } else if (n) {
WiredHome 33:ef165a67ab22 293 bPtr[n] = '\0';
WiredHome 33:ef165a67ab22 294 INFO("*** payload size %d", n);
WiredHome 33:ef165a67ab22 295 }
WiredHome 33:ef165a67ab22 296 #else
WiredHome 29:00116fc9da74 297 op = Sending;
WiredHome 33:ef165a67ab22 298 #endif
WiredHome 29:00116fc9da74 299 break;
WiredHome 29:00116fc9da74 300
WiredHome 0:729320f63c5c 301 case Sending:
WiredHome 58:5303e962f711 302 INFO("SendResponse at %8u us",
WiredHome 58:5303e962f711 303 (unsigned int)PerformanceTimer.read_us()-t_ref);
WiredHome 3:17928786bdb5 304 SendResponse();
WiredHome 0:729320f63c5c 305 op = WaitingToClose;
WiredHome 17:69ff00ce39f4 306 t_ref = RecordPerformanceData(&perfData.ResponseSent, t_ref);
WiredHome 58:5303e962f711 307 INFO("Response Sent at %8u us",
WiredHome 58:5303e962f711 308 (unsigned int)PerformanceTimer.read_us()-t_ref);
WiredHome 0:729320f63c5c 309 break;
WiredHome 9:2ea342765c9d 310
WiredHome 0:729320f63c5c 311 case WaitingToClose:
WiredHome 58:5303e962f711 312 INFO("close_connection %8u us",
WiredHome 58:5303e962f711 313 (unsigned int)PerformanceTimer.read_us()-t_ref);
WiredHome 3:17928786bdb5 314 close_connection();
WiredHome 0:729320f63c5c 315 op = Idle;
WiredHome 17:69ff00ce39f4 316 RecordPerformanceData(&perfData.ConnectionClosed, t_ref);
WiredHome 58:5303e962f711 317 INFO("Connection closed exit: %8u us\r\n\r\n",
WiredHome 58:5303e962f711 318 (unsigned int)PerformanceTimer.read_us()-t_ref);
WiredHome 0:729320f63c5c 319 break;
WiredHome 0:729320f63c5c 320 }
WiredHome 0:729320f63c5c 321 }
WiredHome 0:729320f63c5c 322
WiredHome 0:729320f63c5c 323
WiredHome 0:729320f63c5c 324 const char * HTTPServer::GetSupportedType(const char * filename)
WiredHome 0:729320f63c5c 325 {
WiredHome 0:729320f63c5c 326 int i;
WiredHome 0:729320f63c5c 327 int buflen = strlen(filename);
WiredHome 0:729320f63c5c 328 int extlen;
WiredHome 0:729320f63c5c 329
WiredHome 0:729320f63c5c 330 for (i=0; extensions[i].ext != 0; i++) {
WiredHome 0:729320f63c5c 331 extlen = strlen(extensions[i].ext);
WiredHome 0:729320f63c5c 332 if ( !strncmp(&filename[buflen-extlen], extensions[i].ext, extlen)) {
WiredHome 0:729320f63c5c 333 return extensions[i].filetype;
WiredHome 0:729320f63c5c 334 }
WiredHome 0:729320f63c5c 335 }
WiredHome 0:729320f63c5c 336 return NULL;
WiredHome 0:729320f63c5c 337 }
WiredHome 0:729320f63c5c 338
WiredHome 3:17928786bdb5 339
WiredHome 53:e5d96abe5e9b 340 int HTTPServer::send(const char * msg, int bytes)
WiredHome 0:729320f63c5c 341 {
WiredHome 0:729320f63c5c 342 if (bytes == -1)
WiredHome 0:729320f63c5c 343 bytes = strlen(msg);
WiredHome 44:71f09e4255f4 344 INFO("Sending %d bytes", bytes);
WiredHome 44:71f09e4255f4 345 //INFO("send:\r\n%s", msg);
WiredHome 58:5303e962f711 346 int r = client.send_all((char *)msg, bytes);
WiredHome 44:71f09e4255f4 347 INFO("client.send returned: %d", r);
WiredHome 53:e5d96abe5e9b 348 return r;
WiredHome 0:729320f63c5c 349 }
WiredHome 0:729320f63c5c 350
WiredHome 44:71f09e4255f4 351 const char * HTTPServer::FindAlias(const HTTPServer::namevalue * haystack, const char * needle)
WiredHome 44:71f09e4255f4 352 {
WiredHome 44:71f09e4255f4 353 while (haystack && haystack->name) {
WiredHome 44:71f09e4255f4 354 if (strcmp(haystack->name,needle) == 0)
WiredHome 44:71f09e4255f4 355 return haystack->value;
WiredHome 44:71f09e4255f4 356 haystack++;
WiredHome 44:71f09e4255f4 357 }
WiredHome 44:71f09e4255f4 358 return needle;
WiredHome 44:71f09e4255f4 359 }
WiredHome 44:71f09e4255f4 360
WiredHome 44:71f09e4255f4 361 uint32_t HTTPServer::FileSize(const char * filename)
WiredHome 44:71f09e4255f4 362 {
WiredHome 44:71f09e4255f4 363 uint32_t size = 0;
WiredHome 44:71f09e4255f4 364 FILE * fh;
WiredHome 44:71f09e4255f4 365
WiredHome 44:71f09e4255f4 366 filename = FindAlias(filenameAliasList, filename);
WiredHome 44:71f09e4255f4 367 fh = fopen(filename, "r");
WiredHome 44:71f09e4255f4 368 if (fh) {
WiredHome 44:71f09e4255f4 369 fseek(fh, 0, SEEK_END); // seek to end of file
WiredHome 44:71f09e4255f4 370 size = ftell(fh); // get current file pointer
WiredHome 44:71f09e4255f4 371 fclose(fh);
WiredHome 44:71f09e4255f4 372 }
WiredHome 44:71f09e4255f4 373 return size;
WiredHome 44:71f09e4255f4 374 }
WiredHome 3:17928786bdb5 375
WiredHome 0:729320f63c5c 376 bool HTTPServer::SendFile(const char * filename, const char * filetype)
WiredHome 0:729320f63c5c 377 {
WiredHome 0:729320f63c5c 378 FILE * fp;
WiredHome 3:17928786bdb5 379
WiredHome 44:71f09e4255f4 380 INFO("SendFile(%s,...)", filename);
WiredHome 44:71f09e4255f4 381 filename = FindAlias(filenameAliasList, filename);
WiredHome 44:71f09e4255f4 382 INFO(" Alias(%s,...)", filename);
WiredHome 0:729320f63c5c 383 fp = fopen(filename,"rb");
WiredHome 0:729320f63c5c 384 if (fp) { // can open it
WiredHome 8:262583f054f6 385 char *fbuffer = (char *)mymalloc(FILESEND_BUF_SIZE);
WiredHome 0:729320f63c5c 386 int bytes;
WiredHome 0:729320f63c5c 387
WiredHome 3:17928786bdb5 388 if (fbuffer) {
WiredHome 44:71f09e4255f4 389 char ContentLen[30];
WiredHome 44:71f09e4255f4 390 snprintf(ContentLen, sizeof(ContentLen), "Content-Length: %u\r\n", FileSize(filename));
WiredHome 44:71f09e4255f4 391 header(OK, "OK", filetype, ContentLen);
WiredHome 44:71f09e4255f4 392 header("");
WiredHome 58:5303e962f711 393 bytes = fread(fbuffer,sizeof(char),FILESEND_BUF_SIZE-1,fp);
WiredHome 53:e5d96abe5e9b 394 INFO("Start with %d bytes", bytes);
WiredHome 58:5303e962f711 395 int retryCount = 2;
WiredHome 3:17928786bdb5 396 while (bytes > 0) {
WiredHome 53:e5d96abe5e9b 397 int r = send(fbuffer, bytes);
WiredHome 53:e5d96abe5e9b 398 if (r >= 0) {
WiredHome 58:5303e962f711 399 bytes = fread(fbuffer,sizeof(char),FILESEND_BUF_SIZE-1,fp);
WiredHome 53:e5d96abe5e9b 400 INFO(" Next %d bytes", bytes);
WiredHome 53:e5d96abe5e9b 401 //INFO("::%s", fbuffer);
WiredHome 58:5303e962f711 402 } else if (r == -2) {
WiredHome 58:5303e962f711 403 if (retryCount-- == 0) {
WiredHome 58:5303e962f711 404 ERR("send failed with %d [retries] - terminating SendFile().", r);
WiredHome 58:5303e962f711 405 break;
WiredHome 58:5303e962f711 406 }
WiredHome 58:5303e962f711 407 INFO("send failed with %d (timeout), hopefully it will recover.", r);
WiredHome 58:5303e962f711 408 } else {
WiredHome 58:5303e962f711 409 ERR("send failed with %d, but why? - terminating SendFile().", r);
WiredHome 58:5303e962f711 410 break;
WiredHome 53:e5d96abe5e9b 411 }
WiredHome 3:17928786bdb5 412 }
WiredHome 8:262583f054f6 413 myfree(fbuffer);
WiredHome 3:17928786bdb5 414 } else {
WiredHome 44:71f09e4255f4 415 header(Server_Error, "Server Error", NULL, "Pragma: err - insufficient memory\r\n");
WiredHome 44:71f09e4255f4 416 header("");
WiredHome 0:729320f63c5c 417 }
WiredHome 0:729320f63c5c 418 fclose(fp);
WiredHome 0:729320f63c5c 419 return true;
WiredHome 0:729320f63c5c 420 } else {
WiredHome 44:71f09e4255f4 421 header(Not_Found, "Not Found", NULL, "Pragma: err - Can't open file\r\n");
WiredHome 44:71f09e4255f4 422 header("");
WiredHome 0:729320f63c5c 423 return false;
WiredHome 0:729320f63c5c 424 }
WiredHome 0:729320f63c5c 425 }
WiredHome 0:729320f63c5c 426
WiredHome 0:729320f63c5c 427 int HTTPServer::HexCharToInt(char c)
WiredHome 0:729320f63c5c 428 {
WiredHome 0:729320f63c5c 429 if (c >= 'a' && c <= 'f')
WiredHome 0:729320f63c5c 430 return (c - 'a' + 10);
WiredHome 0:729320f63c5c 431 else if (c >= 'A' && c <= 'F')
WiredHome 0:729320f63c5c 432 return (c - 'A' + 10);
WiredHome 0:729320f63c5c 433 else if (c >= '0' && c <= '9')
WiredHome 0:729320f63c5c 434 return c - '0';
WiredHome 0:729320f63c5c 435 else
WiredHome 0:729320f63c5c 436 return 0;
WiredHome 0:729320f63c5c 437 }
WiredHome 0:729320f63c5c 438
WiredHome 0:729320f63c5c 439 char HTTPServer::HexPairToChar(char * p)
WiredHome 0:729320f63c5c 440 {
WiredHome 0:729320f63c5c 441 return 16 * HexCharToInt(*p) + HexCharToInt(*(p+1));
WiredHome 0:729320f63c5c 442 }
WiredHome 0:729320f63c5c 443
WiredHome 39:0427544a5c08 444 // modifies in-place
WiredHome 0:729320f63c5c 445 void HTTPServer::UnescapeString(char * encoded)
WiredHome 0:729320f63c5c 446 {
WiredHome 0:729320f63c5c 447 char *p;
WiredHome 0:729320f63c5c 448
WiredHome 0:729320f63c5c 449 // first convert '+' to ' '
WiredHome 0:729320f63c5c 450 p = strchr(encoded, '+');
WiredHome 0:729320f63c5c 451 while (p) {
WiredHome 0:729320f63c5c 452 *p = ' ';
WiredHome 0:729320f63c5c 453 p = strchr(encoded, '+');
WiredHome 0:729320f63c5c 454 }
WiredHome 0:729320f63c5c 455 // then convert hex '%xx' to char 'x'
WiredHome 0:729320f63c5c 456 p = strchr(encoded, '%');
WiredHome 0:729320f63c5c 457 while (p) {
WiredHome 0:729320f63c5c 458 if (strchr("0123456789ABCDEFabcdef", *(p+1))
WiredHome 0:729320f63c5c 459 && strchr("0123456789ABCDEFabcdef", *(p+2)) ) {
WiredHome 0:729320f63c5c 460 *p = HexPairToChar(p+1);
WiredHome 0:729320f63c5c 461 p++; // advance past the %
WiredHome 0:729320f63c5c 462 char * a = p;
WiredHome 0:729320f63c5c 463 char * b = p + 2;
WiredHome 0:729320f63c5c 464 do {
WiredHome 0:729320f63c5c 465 *a++ = *b++;
WiredHome 0:729320f63c5c 466 } while (*b);
WiredHome 0:729320f63c5c 467 *a = '\0';
WiredHome 0:729320f63c5c 468 }
WiredHome 0:729320f63c5c 469 p = strchr(p, '%');
WiredHome 0:729320f63c5c 470 }
WiredHome 0:729320f63c5c 471 }
WiredHome 0:729320f63c5c 472
WiredHome 0:729320f63c5c 473 const char * HTTPServer::GetParameter(const char * name)
WiredHome 0:729320f63c5c 474 {
WiredHome 37:0cb2774e2410 475 INFO("GetParameter(%s)", name);
WiredHome 13:8975d7928678 476 for (int i=0; i<queryParamCount; i++) {
WiredHome 37:0cb2774e2410 477 INFO(" %d: %s = %s", i, queryParams[i].name, queryParams[i].value);
WiredHome 13:8975d7928678 478 if (strcmp(queryParams[i].name, name) == 0) {
WiredHome 37:0cb2774e2410 479 INFO(" value {%s}", queryParams[i].value);
WiredHome 13:8975d7928678 480 return queryParams[i].value;
WiredHome 0:729320f63c5c 481 }
WiredHome 0:729320f63c5c 482 }
WiredHome 0:729320f63c5c 483 return NULL;
WiredHome 0:729320f63c5c 484 }
WiredHome 0:729320f63c5c 485
WiredHome 44:71f09e4255f4 486 const HTTPServer::namevalue * HTTPServer::GetParameter(int index)
WiredHome 39:0427544a5c08 487 {
WiredHome 39:0427544a5c08 488 if (index < queryParamCount)
WiredHome 39:0427544a5c08 489 return &queryParams[index];
WiredHome 39:0427544a5c08 490 else
WiredHome 39:0427544a5c08 491 return NULL;
WiredHome 39:0427544a5c08 492 }
WiredHome 39:0427544a5c08 493
WiredHome 39:0427544a5c08 494 const char * HTTPServer::GetPostParameter(const char * name)
WiredHome 39:0427544a5c08 495 {
WiredHome 39:0427544a5c08 496 INFO("GetPostParameter(%s)", name);
WiredHome 39:0427544a5c08 497 for (int i=0; i<postParamCount; i++) {
WiredHome 39:0427544a5c08 498 INFO(" %d: %s = %s", i, postParams[i].name, postParams[i].value);
WiredHome 39:0427544a5c08 499 if (strcmp(postParams[i].name, name) == 0) {
WiredHome 39:0427544a5c08 500 INFO(" value {%s}", postParams[i].value);
WiredHome 39:0427544a5c08 501 return postParams[i].value;
WiredHome 39:0427544a5c08 502 }
WiredHome 39:0427544a5c08 503 }
WiredHome 39:0427544a5c08 504 return NULL;
WiredHome 39:0427544a5c08 505 }
WiredHome 39:0427544a5c08 506
WiredHome 39:0427544a5c08 507 HTTPServer::namevalue * HTTPServer::GetPostParameter(int index)
WiredHome 39:0427544a5c08 508 {
WiredHome 39:0427544a5c08 509 if (index < postParamCount)
WiredHome 39:0427544a5c08 510 return &postParams[index];
WiredHome 39:0427544a5c08 511 else
WiredHome 39:0427544a5c08 512 return NULL;
WiredHome 39:0427544a5c08 513 }
WiredHome 37:0cb2774e2410 514
WiredHome 0:729320f63c5c 515 // this=that&who=what&more=stuff...
WiredHome 0:729320f63c5c 516 // ^ ^ ^
WiredHome 39:0427544a5c08 517 int HTTPServer::ParseParameters(namevalue * qP, int * qpCount, int maxP, char * pName)
WiredHome 0:729320f63c5c 518 {
WiredHome 0:729320f63c5c 519 char * pVal;
WiredHome 0:729320f63c5c 520 char * pNextName;
WiredHome 0:729320f63c5c 521
WiredHome 13:8975d7928678 522 // Parse queryParams
WiredHome 0:729320f63c5c 523 pVal = strchr(pName, '#'); // If there is a '#fragment_id', we can ignore it
WiredHome 0:729320f63c5c 524 if (pVal)
WiredHome 3:17928786bdb5 525 *pVal = '\0';
WiredHome 0:729320f63c5c 526 do {
Sissors 42:0d5b682bb17a 527 INFO("ParseParameters(%s), qpCount: %d", pName, *qpCount);
WiredHome 39:0427544a5c08 528 qP->name = pName;
WiredHome 0:729320f63c5c 529 pVal = strchr(pName, '=');
WiredHome 0:729320f63c5c 530 pNextName = strchr(pName,'&');
WiredHome 0:729320f63c5c 531 if (pVal) {
WiredHome 0:729320f63c5c 532 if (pNextName == NULL || (pNextName && pNextName > pVal)) {
WiredHome 0:729320f63c5c 533 *pVal++ = '\0';
WiredHome 39:0427544a5c08 534 qP->value = pVal;
WiredHome 0:729320f63c5c 535 pName = pVal;
WiredHome 0:729320f63c5c 536 }
WiredHome 0:729320f63c5c 537 }
WiredHome 0:729320f63c5c 538 if (pNextName) {
WiredHome 0:729320f63c5c 539 pName = pNextName;
WiredHome 0:729320f63c5c 540 *pName++ = '\0';
WiredHome 0:729320f63c5c 541 } else {
WiredHome 0:729320f63c5c 542 pName = NULL;
WiredHome 0:729320f63c5c 543 }
WiredHome 39:0427544a5c08 544 INFO(" param{%s}={%s}", qP->name, qP->value);
WiredHome 39:0427544a5c08 545 *qpCount += 1;
WiredHome 39:0427544a5c08 546 qP++;
WiredHome 39:0427544a5c08 547 } while (pName && *qpCount < maxP);
WiredHome 39:0427544a5c08 548 INFO(" count %d", *qpCount);
WiredHome 39:0427544a5c08 549 return *qpCount;
WiredHome 0:729320f63c5c 550 }
WiredHome 0:729320f63c5c 551
WiredHome 0:729320f63c5c 552
WiredHome 44:71f09e4255f4 553 void HTTPServer::header(HTTPServer::HeaderCodes code, const char * code_text, const char * content_type, const char * optional_text)
WiredHome 0:729320f63c5c 554 {
WiredHome 0:729320f63c5c 555 char http[100];
WiredHome 0:729320f63c5c 556
WiredHome 50:10db483f5154 557 if (optional_text == NULL)
WiredHome 50:10db483f5154 558 optional_text = "";
WiredHome 53:e5d96abe5e9b 559 INFO("header(%d, %s, %s, %s)", code, code_text, content_type, optional_text);
WiredHome 44:71f09e4255f4 560 snprintf(http, sizeof(http), "%s %i %s\r\n", hdr_httpver, code, code_text);
WiredHome 0:729320f63c5c 561 send(http);
WiredHome 0:729320f63c5c 562 if (content_type) {
WiredHome 0:729320f63c5c 563 send(content_type);
WiredHome 0:729320f63c5c 564 }
WiredHome 50:10db483f5154 565 if (*optional_text != '\0') {
WiredHome 50:10db483f5154 566 send(optional_text);
WiredHome 44:71f09e4255f4 567 } else {
WiredHome 50:10db483f5154 568 if (strlen(hdr_age) + strlen(hdr_server) + strlen(hdr_close) + strlen(nl) < sizeof(http)) {
WiredHome 58:5303e962f711 569 strcpy_s(http, 100, hdr_age);
WiredHome 58:5303e962f711 570 strcat_s(http, 100, hdr_server);
WiredHome 58:5303e962f711 571 strcat_s(http, 100, hdr_close);
WiredHome 58:5303e962f711 572 strcat_s(http, 100, nl);
WiredHome 50:10db483f5154 573 send(http);
WiredHome 50:10db483f5154 574 } else {
WiredHome 50:10db483f5154 575 send(hdr_age);
WiredHome 50:10db483f5154 576 send(hdr_server);
WiredHome 50:10db483f5154 577 send(hdr_close);
WiredHome 50:10db483f5154 578 send(nl);
WiredHome 50:10db483f5154 579 }
WiredHome 0:729320f63c5c 580 }
WiredHome 0:729320f63c5c 581 }
WiredHome 0:729320f63c5c 582
WiredHome 44:71f09e4255f4 583 void HTTPServer::header(const char * partialheader)
WiredHome 44:71f09e4255f4 584 {
WiredHome 44:71f09e4255f4 585 if (!partialheader || *partialheader == '\0')
WiredHome 44:71f09e4255f4 586 send(nl);
WiredHome 44:71f09e4255f4 587 else
WiredHome 44:71f09e4255f4 588 send(partialheader);
WiredHome 44:71f09e4255f4 589 }
WiredHome 14:19c5f6151319 590
WiredHome 7:99ad7a67f05e 591 bool HTTPServer::close_connection()
WiredHome 0:729320f63c5c 592 {
WiredHome 7:99ad7a67f05e 593 bool res;
WiredHome 7:99ad7a67f05e 594
Sissors 41:6f2f1fb96742 595 res = client.close();
WiredHome 27:90a1f5a5392f 596 INFO("close connection returned %d", res);
WiredHome 7:99ad7a67f05e 597 return res;
WiredHome 0:729320f63c5c 598 }
WiredHome 0:729320f63c5c 599
WiredHome 14:19c5f6151319 600
WiredHome 0:729320f63c5c 601 bool HTTPServer::Extract(char * haystack, char * needle, char ** string)
WiredHome 0:729320f63c5c 602 {
WiredHome 0:729320f63c5c 603 bool ret = false; // assume failure until proven otherwise
WiredHome 0:729320f63c5c 604 char * qs = NULL;
WiredHome 0:729320f63c5c 605 char * eqs = NULL;
WiredHome 0:729320f63c5c 606 char * container = NULL;
WiredHome 0:729320f63c5c 607 char * get = strstr(haystack, needle); // what if not at the front?
WiredHome 44:71f09e4255f4 608
WiredHome 0:729320f63c5c 609 if (get) {
WiredHome 44:71f09e4255f4 610 // Seems to be a valid "GET /QueryString HTTP/1.1"
WiredHome 44:71f09e4255f4 611 // or "POST /upnp/control/metainfo1 HTTP/1.0"
WiredHome 8:262583f054f6 612 // or "...<needle>param..."
WiredHome 0:729320f63c5c 613 qs = get + strlen(needle); // in case the needle didn't have space delimiters
WiredHome 0:729320f63c5c 614 while (*qs == ' ')
WiredHome 0:729320f63c5c 615 qs++;
WiredHome 0:729320f63c5c 616 // /QueryString\0HTTP/1.1\0\0
WiredHome 0:729320f63c5c 617 if (*string) // recycle old string when working a new one
WiredHome 8:262583f054f6 618 myfree(*string);
WiredHome 58:5303e962f711 619 int ctSize = strlen(qs);
WiredHome 58:5303e962f711 620 container = (char *)mymalloc(ctSize);
WiredHome 0:729320f63c5c 621 if (container) {
WiredHome 58:5303e962f711 622 strcpy_s(container, ctSize, qs);
WiredHome 0:729320f63c5c 623 eqs = strchr(container, ' ');
WiredHome 0:729320f63c5c 624 if (eqs)
WiredHome 0:729320f63c5c 625 *eqs = '\0';
WiredHome 0:729320f63c5c 626 *string = container;
WiredHome 27:90a1f5a5392f 627 INFO("Extract(%s) = %s", needle, container);
WiredHome 0:729320f63c5c 628 ret = true;
WiredHome 0:729320f63c5c 629 } else {
WiredHome 0:729320f63c5c 630 *string = NULL; // something bad happened... no memory
WiredHome 0:729320f63c5c 631 }
WiredHome 0:729320f63c5c 632 }
WiredHome 0:729320f63c5c 633 return ret;
WiredHome 0:729320f63c5c 634 }
WiredHome 0:729320f63c5c 635
WiredHome 14:19c5f6151319 636
WiredHome 0:729320f63c5c 637 char * HTTPServer::rewriteWithDefaultFile(char * queryString)
WiredHome 0:729320f63c5c 638 {
WiredHome 58:5303e962f711 639 int tSize = strlen(queryString) + strlen(DEFAULT_FILENAME) + 1;
WiredHome 58:5303e962f711 640 char * temp = (char *)mymalloc(tSize);
WiredHome 0:729320f63c5c 641
WiredHome 0:729320f63c5c 642 if (temp) {
WiredHome 0:729320f63c5c 643 *temp = '\0';
WiredHome 58:5303e962f711 644 strcpy_s(temp, tSize, queryString);
WiredHome 58:5303e962f711 645 strcat_s(temp, tSize, DEFAULT_FILENAME);
WiredHome 8:262583f054f6 646 myfree(queryString);
WiredHome 0:729320f63c5c 647 return temp;
WiredHome 0:729320f63c5c 648 } else {
WiredHome 0:729320f63c5c 649 return queryString;
WiredHome 0:729320f63c5c 650 }
WiredHome 0:729320f63c5c 651 }
WiredHome 0:729320f63c5c 652
WiredHome 14:19c5f6151319 653
WiredHome 0:729320f63c5c 654 char * HTTPServer::rewritePrependWebroot(char * queryString)
WiredHome 0:729320f63c5c 655 {
WiredHome 58:5303e962f711 656 int tSize = strlen(webroot) + strlen(queryString) + 2;
WiredHome 58:5303e962f711 657 char * temp = (char *)mymalloc(tSize); // save room for '/'
WiredHome 0:729320f63c5c 658
WiredHome 0:729320f63c5c 659 if (temp) {
WiredHome 24:062431453abb 660 char *lastC;
WiredHome 0:729320f63c5c 661 *temp = '\0';
WiredHome 58:5303e962f711 662 strcpy_s(temp, tSize, webroot);
WiredHome 24:062431453abb 663 lastC = &temp[strlen(temp)-1];
WiredHome 24:062431453abb 664 if (*lastC == '/' && *queryString == '/')
WiredHome 24:062431453abb 665 queryString++; // don't create two '/'
WiredHome 24:062431453abb 666 else if (*lastC != '/' && *queryString != '/')
WiredHome 58:5303e962f711 667 strcat_s(temp, tSize, "/");
WiredHome 58:5303e962f711 668 strcat_s(temp, tSize, queryString);
WiredHome 8:262583f054f6 669 myfree(queryString);
WiredHome 0:729320f63c5c 670 return temp;
WiredHome 0:729320f63c5c 671 } else {
WiredHome 0:729320f63c5c 672 return queryString;
WiredHome 0:729320f63c5c 673 }
WiredHome 0:729320f63c5c 674 }
WiredHome 0:729320f63c5c 675
WiredHome 14:19c5f6151319 676
WiredHome 3:17928786bdb5 677 bool HTTPServer::CheckDynamicHandlers()
WiredHome 3:17928786bdb5 678 {
WiredHome 3:17928786bdb5 679 bool regHandled = false;
WiredHome 0:729320f63c5c 680
WiredHome 3:17928786bdb5 681 // If this queryString is in the list of registered handlers, call that
WiredHome 3:17928786bdb5 682 for (int i=0; i<handlercount; i++) {
WiredHome 3:17928786bdb5 683 if (strcmp(handlers[i].path, queryString) == 0) {
WiredHome 53:e5d96abe5e9b 684 INFO("CheckDynamicHandlers - SEND_PAGE %s", handlers[i].path);
WiredHome 13:8975d7928678 685 (*handlers[i].callback)(this, SEND_PAGE, queryString, queryParams, queryParamCount);
WiredHome 3:17928786bdb5 686 regHandled = true;
WiredHome 3:17928786bdb5 687 break; // we only execute the first one
WiredHome 3:17928786bdb5 688 }
WiredHome 3:17928786bdb5 689 }
WiredHome 3:17928786bdb5 690 return regHandled;
WiredHome 3:17928786bdb5 691 }
WiredHome 3:17928786bdb5 692
WiredHome 14:19c5f6151319 693
WiredHome 3:17928786bdb5 694 void HTTPServer::SendResponse()
WiredHome 3:17928786bdb5 695 {
WiredHome 58:5303e962f711 696 INFO("SendResponse(%5s) at %8u us",
WiredHome 58:5303e962f711 697 queryType, (unsigned int)PerformanceTimer.read_us());
WiredHome 44:71f09e4255f4 698 if (strcmp(queryType, "GET ") == 0 || strcmp(queryType, "POST ") == 0) {
WiredHome 3:17928786bdb5 699 if (!(queryString[0] == '.' && queryString[1] == '.')) {
WiredHome 3:17928786bdb5 700 const char * fType;
WiredHome 3:17928786bdb5 701
WiredHome 3:17928786bdb5 702 if (!CheckDynamicHandlers()) {
WiredHome 3:17928786bdb5 703 // Otherwise, this queryString must be trying to reference a static file
WiredHome 3:17928786bdb5 704 if (queryString[strlen(queryString)-1] == '/') {
WiredHome 3:17928786bdb5 705 queryString = rewriteWithDefaultFile(queryString);
WiredHome 3:17928786bdb5 706 }
WiredHome 44:71f09e4255f4 707 INFO(" queryString: %s", queryString);
WiredHome 3:17928786bdb5 708 // see if we support this file type
WiredHome 3:17928786bdb5 709 fType = GetSupportedType(queryString);
WiredHome 3:17928786bdb5 710 if (fType) {
WiredHome 3:17928786bdb5 711 queryString = rewritePrependWebroot(queryString);
WiredHome 44:71f09e4255f4 712 INFO(" SendFile(%s,%s)", queryString, fType);
WiredHome 3:17928786bdb5 713 SendFile(queryString, fType);
WiredHome 3:17928786bdb5 714 } else {
WiredHome 44:71f09e4255f4 715 header(Not_Found, "Not Found", NULL, "Pragma: err - Unsupported type\r\n");
WiredHome 44:71f09e4255f4 716 header("");
WiredHome 3:17928786bdb5 717 }
WiredHome 3:17928786bdb5 718 }
WiredHome 3:17928786bdb5 719 } else {
WiredHome 44:71f09e4255f4 720 header(Bad_Request, "Bad Request", NULL, "Pragma: err - Unsupported path\r\n");
WiredHome 44:71f09e4255f4 721 header("");
WiredHome 3:17928786bdb5 722 }
WiredHome 3:17928786bdb5 723 } else {
WiredHome 44:71f09e4255f4 724 header(Bad_Request, "Bad Request", NULL, "Pragma: err - Unsupported query type\r\n");
WiredHome 44:71f09e4255f4 725 header("");
WiredHome 3:17928786bdb5 726 }
WiredHome 58:5303e962f711 727 INFO(" SendResponse complete at %8u us",
WiredHome 58:5303e962f711 728 (unsigned int)PerformanceTimer.read_us());
WiredHome 17:69ff00ce39f4 729
WiredHome 3:17928786bdb5 730 if (queryType) {
WiredHome 8:262583f054f6 731 myfree(queryType);
WiredHome 3:17928786bdb5 732 queryType = NULL;
WiredHome 3:17928786bdb5 733 }
WiredHome 3:17928786bdb5 734 if (queryString) {
WiredHome 8:262583f054f6 735 myfree(queryString);
WiredHome 3:17928786bdb5 736 queryString = NULL;
WiredHome 3:17928786bdb5 737 }
WiredHome 3:17928786bdb5 738 if (postQueryString) {
WiredHome 8:262583f054f6 739 myfree(postQueryString);
WiredHome 3:17928786bdb5 740 postQueryString = NULL;
WiredHome 3:17928786bdb5 741 }
WiredHome 58:5303e962f711 742 INFO(" SendResponse free at %8u us",
WiredHome 58:5303e962f711 743 (unsigned int)PerformanceTimer.read_us());
WiredHome 3:17928786bdb5 744 }
WiredHome 3:17928786bdb5 745
WiredHome 14:19c5f6151319 746
WiredHome 29:00116fc9da74 747 HTTPServer::CallBackResults HTTPServer::ParseHeader(char * buffer)
WiredHome 3:17928786bdb5 748 {
WiredHome 3:17928786bdb5 749 char * dblCR;
WiredHome 29:00116fc9da74 750 CallBackResults advanceState = ACCEPT_ERROR;
WiredHome 3:17928786bdb5 751 int bytecount;
WiredHome 7:99ad7a67f05e 752
WiredHome 3:17928786bdb5 753 // Buffer could have partial, but the double \r\n is the key
WiredHome 13:8975d7928678 754 // GET /QueryString?this=that&sky=blue HTTP/1.1\r\n
WiredHome 8:262583f054f6 755 // GET /QueryString HTTP/1.1\r\nHost: 192.168.1.140\r\nCache-Con
WiredHome 8:262583f054f6 756 // GET /QueryString HTTP/1.1\r\nHost: 192.168.1.140\r\nCache-Control: max-age=0\r\n\r\n
WiredHome 39:0427544a5c08 757 // POST /dyn2 HTTP/1.2\r\nAccept: text/html, application/xhtml+xml, */*\r\n\r\n
WiredHome 3:17928786bdb5 758 dblCR = strstr(buffer,"\r\n\r\n");
WiredHome 3:17928786bdb5 759 if (dblCR) { // Have to scan from the beginning in case split on \r
WiredHome 44:71f09e4255f4 760 INFO("\r\n==\r\n%s\r\n==", buffer);
WiredHome 3:17928786bdb5 761 char * soRec = buffer; // start of the next record of text
WiredHome 13:8975d7928678 762 char * eoRec = strchr(soRec, '\n'); // search for end of the current record
WiredHome 7:99ad7a67f05e 763
WiredHome 13:8975d7928678 764 headerParamCount = 0;
WiredHome 3:17928786bdb5 765 bytecount = strlen(buffer);
WiredHome 3:17928786bdb5 766 if (bytecount > maxheaderbytes)
WiredHome 3:17928786bdb5 767 maxheaderbytes = bytecount;
WiredHome 3:17928786bdb5 768 while (eoRec) {
WiredHome 3:17928786bdb5 769 *eoRec = '\0';
WiredHome 3:17928786bdb5 770 if (*(eoRec-1) == '\r')
WiredHome 3:17928786bdb5 771 *(eoRec-1) = '\0';
WiredHome 44:71f09e4255f4 772 INFO("method: %s", soRec);
WiredHome 44:71f09e4255f4 773 #if 1
WiredHome 44:71f09e4255f4 774 const QueryMethod * qm = QueryMethodList;
WiredHome 44:71f09e4255f4 775 while (*qm->queryType) {
WiredHome 44:71f09e4255f4 776 if (strstr(soRec, qm->queryType) == soRec) {
WiredHome 44:71f09e4255f4 777 Extract(soRec, qm->queryType, &queryString);
WiredHome 44:71f09e4255f4 778 if (queryString) {
WiredHome 58:5303e962f711 779 int qSize = strlen(qm->queryType)+1;
WiredHome 58:5303e962f711 780 queryType = (char *)mymalloc(qSize);
WiredHome 58:5303e962f711 781 strcpy_s(queryType, qSize, qm->queryType);
WiredHome 44:71f09e4255f4 782 }
WiredHome 44:71f09e4255f4 783 }
WiredHome 44:71f09e4255f4 784 qm++;
WiredHome 44:71f09e4255f4 785 }
WiredHome 44:71f09e4255f4 786 #else
WiredHome 8:262583f054f6 787 // Inspect the supported query types (GET, POST) and ignore (HEAD, PUT, OPTION, DELETE, TRACE, CONNECT]
WiredHome 44:71f09e4255f4 788 // This is presently very clumsy
WiredHome 44:71f09e4255f4 789 if (strstr(soRec, "GET ") == soRec) {
WiredHome 8:262583f054f6 790 Extract(soRec, "GET", &queryString);
WiredHome 8:262583f054f6 791 if (queryString) {
WiredHome 58:5303e962f711 792 int qSize = strlen("GET")+1;
WiredHome 58:5303e962f711 793 queryType = (char *)mymalloc(qSize);
WiredHome 58:5303e962f711 794 strcpy_s(queryType, qSize, "GET");
WiredHome 8:262583f054f6 795 }
WiredHome 8:262583f054f6 796 } else if (strstr(soRec, "POST ") == soRec) {
WiredHome 39:0427544a5c08 797 Extract(soRec, "POST", &queryString);
WiredHome 8:262583f054f6 798 if (queryString) {
WiredHome 58:5303e962f711 799 int qSize = strlen("POST")+1;
WiredHome 58:5303e962f711 800 queryType = (char *)mymalloc(qSize);
WiredHome 58:5303e962f711 801 strcpy_s(queryType, qSize, "POST");
WiredHome 8:262583f054f6 802 }
WiredHome 10:9c8d2c6a3469 803 }
WiredHome 44:71f09e4255f4 804 #endif
WiredHome 44:71f09e4255f4 805
WiredHome 13:8975d7928678 806 // if there is a ": " delimiter, we have a header item to parse into name,value pair
WiredHome 13:8975d7928678 807 // "Connection: keep-alive" becomes "Connection" "keep-alive"
WiredHome 13:8975d7928678 808 char *delim = strstr(soRec, ": ");
WiredHome 13:8975d7928678 809 char *chkSpace = strchr(soRec, ' '); // a field-name has no space ahead of the ":"
WiredHome 44:71f09e4255f4 810 //INFO("hpc:%d,mhp:%d, {%s}", headerParamCount, maxheaderParams, soRec);
WiredHome 29:00116fc9da74 811 if (delim
WiredHome 29:00116fc9da74 812 && (!chkSpace || (chkSpace && delim < chkSpace))
WiredHome 29:00116fc9da74 813 && headerParamCount < maxheaderParams) {
WiredHome 14:19c5f6151319 814 *delim++ = '\0'; // replace ": " with null
WiredHome 13:8975d7928678 815 *delim++ = '\0';
WiredHome 13:8975d7928678 816 headerParams[headerParamCount].name = soRec;
WiredHome 13:8975d7928678 817 headerParams[headerParamCount].value = delim;
WiredHome 37:0cb2774e2410 818 INFO("%d: headerParams[%s] = {%s}", headerParamCount,
WiredHome 37:0cb2774e2410 819 headerParams[headerParamCount].name, headerParams[headerParamCount].value);
WiredHome 13:8975d7928678 820 headerParamCount++;
WiredHome 13:8975d7928678 821 }
WiredHome 3:17928786bdb5 822 soRec = eoRec + 1;
WiredHome 3:17928786bdb5 823 eoRec = strchr(soRec, '\n');
WiredHome 44:71f09e4255f4 824 if (soRec > dblCR) // Just walked past the end of the header
WiredHome 44:71f09e4255f4 825 break;
WiredHome 3:17928786bdb5 826 }
WiredHome 29:00116fc9da74 827
WiredHome 3:17928786bdb5 828 if (queryString) {
WiredHome 3:17928786bdb5 829 // We have enough to try to reply
WiredHome 37:0cb2774e2410 830 INFO("create reply queryType{%s}, queryString{%s}", queryType, queryString);
WiredHome 13:8975d7928678 831 // parse queryParams - if any
WiredHome 3:17928786bdb5 832 // /file.htm?name1=value1&name2=value2...
WiredHome 3:17928786bdb5 833 // /file.htm?name1&name2=value2...
WiredHome 13:8975d7928678 834 queryParamCount = 0;
WiredHome 3:17928786bdb5 835 char * paramDelim = strchr(queryString, '?');
WiredHome 3:17928786bdb5 836 if (paramDelim) {
WiredHome 3:17928786bdb5 837 *paramDelim++ = '\0';
WiredHome 3:17928786bdb5 838 UnescapeString(paramDelim); // everything after the '?'
WiredHome 39:0427544a5c08 839 ParseParameters(queryParams, &queryParamCount, maxqueryParams, paramDelim); // pointing past the NULL, and there are queryParams here
WiredHome 3:17928786bdb5 840 }
WiredHome 3:17928786bdb5 841 } else {
WiredHome 29:00116fc9da74 842 ERR("queryString not found in (%s) [this should never happen]", soRec);
WiredHome 3:17928786bdb5 843 }
WiredHome 44:71f09e4255f4 844 advanceState = ACCEPT_COMPLETE; // Should be ACCEPT_CONTINUE and the stuff below moves out of here
WiredHome 3:17928786bdb5 845 buffer[0] = 0;
WiredHome 3:17928786bdb5 846
WiredHome 3:17928786bdb5 847 // This part parses the extra data on a POST method.
WiredHome 3:17928786bdb5 848 // Since there has to be a dynamic handler registered for this
WiredHome 3:17928786bdb5 849 // it would make sense to move some of this responsibility to
WiredHome 3:17928786bdb5 850 // that handler. It could then choose if it wanted to allocate
WiredHome 3:17928786bdb5 851 // the requested 'Content-Length' amount of memory.
WiredHome 13:8975d7928678 852 int postBytes = atoi(GetHeaderValue("Content-Length"));
WiredHome 28:f93ef41b78e1 853 CallBackResults acceptIt = ACCEPT_ERROR;
WiredHome 44:71f09e4255f4 854 INFO("Content-Length: %d", postBytes);
WiredHome 44:71f09e4255f4 855 if (strcmp(queryType, "POST ") == 0 ) {
WiredHome 44:71f09e4255f4 856 INFO("parse POST data %d bytes", postBytes); // We might have no idea how much data is coming...
WiredHome 44:71f09e4255f4 857 int ndxHandler = 0;
WiredHome 44:71f09e4255f4 858 bool regHandled = false;
WiredHome 44:71f09e4255f4 859 // Registered Dynamic Handler
WiredHome 44:71f09e4255f4 860 // Callback and ask if they want to accept this data
WiredHome 44:71f09e4255f4 861 for (ndxHandler=0; ndxHandler<handlercount; ndxHandler++) {
WiredHome 44:71f09e4255f4 862 INFO("is '%s' a handler for '%s' ?", handlers[ndxHandler].path, queryString);
WiredHome 44:71f09e4255f4 863 if (strcmp(handlers[ndxHandler].path, queryString) == 0) {
WiredHome 44:71f09e4255f4 864 acceptIt = (*handlers[ndxHandler].callback)(this, CONTENT_LENGTH_REQUEST, queryString, queryParams, queryParamCount);
WiredHome 44:71f09e4255f4 865 regHandled = true;
WiredHome 44:71f09e4255f4 866 break; // only one callback per path allowed
WiredHome 3:17928786bdb5 867 }
WiredHome 44:71f09e4255f4 868 }
WiredHome 44:71f09e4255f4 869 INFO("reghandled: %d, acceptIt: %d", regHandled, acceptIt);
WiredHome 44:71f09e4255f4 870 if (regHandled && acceptIt != ACCEPT_ERROR) {
WiredHome 44:71f09e4255f4 871 // @todo need to refactor - if the thing is bigger than the buffer,
WiredHome 44:71f09e4255f4 872 // then we can receive it a chunk at a time, and hand off
WiredHome 44:71f09e4255f4 873 // the chunks to the callback. May need callbacks that
WiredHome 44:71f09e4255f4 874 // are: DATA_TRANSFER: self-detect to extract the filename/object name,
WiredHome 44:71f09e4255f4 875 // DATA_TRANSFER: subsequent chunk of data,
WiredHome 44:71f09e4255f4 876 // DATA_TRANSFER_END: signals that last chunk is enclosed.
WiredHome 44:71f09e4255f4 877 //
WiredHome 44:71f09e4255f4 878 // If so, we'll make space for it
WiredHome 44:71f09e4255f4 879 postQueryString = (char *)mymalloc(CHUNK_SIZE);
WiredHome 44:71f09e4255f4 880 //INFO("Free space %d", Free());
WiredHome 44:71f09e4255f4 881 INFO("postQueryString %p", postQueryString);
WiredHome 44:71f09e4255f4 882 if (postQueryString) {
WiredHome 44:71f09e4255f4 883 int len = 0;
WiredHome 44:71f09e4255f4 884 int ttlCount;
WiredHome 44:71f09e4255f4 885 Timer escapePlan;
WiredHome 44:71f09e4255f4 886 bool escape = false;
WiredHome 44:71f09e4255f4 887
WiredHome 44:71f09e4255f4 888 INFO("Processing tail...");
WiredHome 44:71f09e4255f4 889 escapePlan.start();
WiredHome 44:71f09e4255f4 890 dblCR += 4; // There may be some after the double CR that we need
WiredHome 44:71f09e4255f4 891 ttlCount = strlen(dblCR);
WiredHome 58:5303e962f711 892 strcpy_s(postQueryString, CHUNK_SIZE, dblCR);
WiredHome 44:71f09e4255f4 893 //INFO(" {%s}", postQueryString);
WiredHome 44:71f09e4255f4 894 while ((!postBytes || ttlCount < postBytes) && !escape) {
WiredHome 44:71f09e4255f4 895 INFO("ttlCount: %d < postBytes: %d, of max chunk alloc %d", ttlCount, postBytes, CHUNK_SIZE);
WiredHome 44:71f09e4255f4 896 len = client.receive(postQueryString + ttlCount, CHUNK_SIZE - ttlCount);
WiredHome 44:71f09e4255f4 897 if (len > 0) {
WiredHome 44:71f09e4255f4 898 ttlCount += len;
WiredHome 44:71f09e4255f4 899 postQueryString[ttlCount] = '\0'; // Whether binary or ASCII, this is ok as it's after the data
WiredHome 44:71f09e4255f4 900 INFO(" postBytes %d: [%s], [%d]", postBytes, postQueryString, ndxHandler);
WiredHome 44:71f09e4255f4 901 escapePlan.reset();
WiredHome 44:71f09e4255f4 902 } else if (len < 0) {
WiredHome 44:71f09e4255f4 903 INFO("*** connection closed ***");
WiredHome 44:71f09e4255f4 904 break; // no more data, before the plan
WiredHome 44:71f09e4255f4 905 } else { // n == 0
WiredHome 44:71f09e4255f4 906 ;
WiredHome 3:17928786bdb5 907 }
WiredHome 44:71f09e4255f4 908 if (escapePlan.read_ms() > HANG_TIMEOUT_MS) { // if no Content-Length, we wait...
WiredHome 44:71f09e4255f4 909 escape = true;
WiredHome 44:71f09e4255f4 910 WARN("Escape plan activated.");
WiredHome 44:71f09e4255f4 911 }
WiredHome 44:71f09e4255f4 912 if (postBytes > 0 && ttlCount >= postBytes)
WiredHome 44:71f09e4255f4 913 break;
WiredHome 3:17928786bdb5 914 }
WiredHome 44:71f09e4255f4 915 //postParamCount = 0;
WiredHome 44:71f09e4255f4 916 //INFO("post: %s", postQueryString);
WiredHome 44:71f09e4255f4 917 //We're after the header, so there is "body" stuff which could be anything...
WiredHome 44:71f09e4255f4 918 //but probably html or xml stuff...
WiredHome 44:71f09e4255f4 919 //ParseParameters(postParams, &postParamCount, maxPostParams, postQueryString);
WiredHome 44:71f09e4255f4 920 acceptIt = (*handlers[ndxHandler].callback)(this, DATA_TRANSFER, postQueryString, NULL, ttlCount);
WiredHome 44:71f09e4255f4 921 INFO("..processing exit");
WiredHome 44:71f09e4255f4 922 acceptIt = (*handlers[ndxHandler].callback)(this, DATA_TRANSFER_END, NULL, NULL, 0);
WiredHome 3:17928786bdb5 923 } else {
WiredHome 44:71f09e4255f4 924 ERR("attempt to allocate %d failed.", CHUNK_SIZE);
WiredHome 44:71f09e4255f4 925 }
WiredHome 44:71f09e4255f4 926 } else {
WiredHome 44:71f09e4255f4 927 // Simply copy it to the bitbucket
WiredHome 44:71f09e4255f4 928 WARN("No handler, so to the bit bucket it goes ...");
WiredHome 44:71f09e4255f4 929 int bytesToDump = postBytes;
WiredHome 44:71f09e4255f4 930 char * bitbucket = (char *)mymalloc(201);
WiredHome 44:71f09e4255f4 931
WiredHome 44:71f09e4255f4 932 dblCR += 4;
WiredHome 44:71f09e4255f4 933 while (*dblCR && *dblCR <= ' ')
WiredHome 44:71f09e4255f4 934 dblCR++;
WiredHome 44:71f09e4255f4 935 bytesToDump -= strlen(dblCR);
WiredHome 44:71f09e4255f4 936 while (bytesToDump > 0) {
WiredHome 44:71f09e4255f4 937 int n = (bytesToDump > 200) ? 200 : bytesToDump;
WiredHome 44:71f09e4255f4 938 n = client.receive(bitbucket, n);
WiredHome 44:71f09e4255f4 939 if (n < 0) {
WiredHome 44:71f09e4255f4 940 ERR("to the bitbucket.");
WiredHome 44:71f09e4255f4 941 break;
WiredHome 3:17928786bdb5 942 }
WiredHome 44:71f09e4255f4 943 bytesToDump -= n;
WiredHome 3:17928786bdb5 944 }
WiredHome 44:71f09e4255f4 945 myfree(bitbucket);
WiredHome 3:17928786bdb5 946 }
WiredHome 3:17928786bdb5 947 }
WiredHome 3:17928786bdb5 948 }
WiredHome 3:17928786bdb5 949 return advanceState;
WiredHome 3:17928786bdb5 950 }
WiredHome 3:17928786bdb5 951
WiredHome 14:19c5f6151319 952
WiredHome 27:90a1f5a5392f 953
WiredHome 13:8975d7928678 954 const char * HTTPServer::GetHeaderValue(const char * hdr)
WiredHome 13:8975d7928678 955 {
WiredHome 13:8975d7928678 956 int i;
WiredHome 29:00116fc9da74 957
WiredHome 29:00116fc9da74 958 for (i=0; i<headerParamCount; i++) {
WiredHome 13:8975d7928678 959 if (strcmp(hdr, headerParams[i].name) == 0)
WiredHome 13:8975d7928678 960 return headerParams[i].value;
WiredHome 29:00116fc9da74 961 }
WiredHome 13:8975d7928678 962 return NULL;
WiredHome 13:8975d7928678 963 }
WiredHome 13:8975d7928678 964
WiredHome 12:109bf1558300 965
WiredHome 7:99ad7a67f05e 966 void HTTPServer::GetPerformanceData(SW_PerformanceData * p)
WiredHome 7:99ad7a67f05e 967 {
WiredHome 3:17928786bdb5 968 memcpy(p, &perfData, sizeof(perfData));
WiredHome 3:17928786bdb5 969 }
WiredHome 3:17928786bdb5 970
WiredHome 17:69ff00ce39f4 971 unsigned int HTTPServer::GetPerformanceClock()
WiredHome 17:69ff00ce39f4 972 {
WiredHome 17:69ff00ce39f4 973 return (unsigned int)PerformanceTimer.read_us();
WiredHome 17:69ff00ce39f4 974 }
WiredHome 14:19c5f6151319 975
WiredHome 16:6ebacf2946d8 976 unsigned int HTTPServer::RecordPerformanceData(SW_PerformanceParam * param, unsigned int refTime)
WiredHome 7:99ad7a67f05e 977 {
WiredHome 16:6ebacf2946d8 978 unsigned int t_now = (unsigned int)PerformanceTimer.read_us();
WiredHome 3:17928786bdb5 979 param->TotalTime_us += (t_now - refTime);
WiredHome 3:17928786bdb5 980 param->Samples++;
WiredHome 3:17928786bdb5 981 if ((t_now - refTime) > param->MaxTime_us)
WiredHome 3:17928786bdb5 982 param->MaxTime_us = (t_now - refTime);
WiredHome 3:17928786bdb5 983 return t_now;
WiredHome 3:17928786bdb5 984 }
WiredHome 3:17928786bdb5 985
WiredHome 14:19c5f6151319 986
WiredHome 7:99ad7a67f05e 987 void HTTPServer::ResetPerformanceData()
WiredHome 7:99ad7a67f05e 988 {
WiredHome 3:17928786bdb5 989 memset(&perfData, 0, sizeof(perfData));
WiredHome 3:17928786bdb5 990 }
WiredHome 3:17928786bdb5 991