Erik - / SW_HTTPServer

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Fork of SW_HTTPServer by David Smart

SW_HTTPServer.cpp@9:2ea342765c9d, 2013-07-04 (annotated)

Committer:
WiredHome
Date:
Thu Jul 04 01:58:13 2013 +0000
Revision:
9:2ea342765c9d
Parent:
8:262583f054f6
Child:
10:9c8d2c6a3469
Minor documentation changes, and allocation of some items to const space.

Who changed what in which revision?

UserRevisionLine numberNew contents of line
WiredHome 0:729320f63c5c 1 //
WiredHome 2:a29c32190037 2 // @note Copyright © 2013 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 0:729320f63c5c 14 #include "SW_HTTPServer.h"
WiredHome 0:729320f63c5c 15 #include "Utility.h"
WiredHome 0:729320f63c5c 16
WiredHome 8:262583f054f6 17 //#define DEBUG
WiredHome 0:729320f63c5c 18
WiredHome 0:729320f63c5c 19 const char * DEFAULT_FILENAME = "index.htm";
WiredHome 0:729320f63c5c 20
WiredHome 8:262583f054f6 21 // Header information to always send (must be \r\n terminated)
WiredHome 8:262583f054f6 22 const char hdr_httpver[] = "HTTP/1.0"; // typically HTTP/1.0 or HTTP/1.1
WiredHome 8:262583f054f6 23 const char hdr_age[] = "Max-age: 0\r\n"; // expires right away
WiredHome 8:262583f054f6 24 const char hdr_server[] = "Server: Smart_Server v0.1\r\n"; // Server
WiredHome 8:262583f054f6 25 const char hdr_dnt[] = "DNT: 1\r\n"; // Do Not Track
WiredHome 8:262583f054f6 26 const char hdr_close[] = "Connection: close\r\n"; // tell the client to close the connection
WiredHome 8:262583f054f6 27 const char nl[] = "\r\n"; // final \r\n for the termination of the header
WiredHome 0:729320f63c5c 28
WiredHome 0:729320f63c5c 29 static const struct {
WiredHome 0:729320f63c5c 30 char *ext;
WiredHome 0:729320f63c5c 31 char *filetype;
WiredHome 0:729320f63c5c 32 } extensions [] = {
WiredHome 3:17928786bdb5 33 {".gif", "Content-Type: image/gif\r\n" },
WiredHome 3:17928786bdb5 34 {".jpg", "Content-Type: image/jpeg\r\n" },
WiredHome 3:17928786bdb5 35 {".jpeg","Content-Type: image/jpeg\r\n" },
WiredHome 3:17928786bdb5 36 {".ico", "Content-Type: image/x-icon\r\n" },
WiredHome 3:17928786bdb5 37 {".png", "Content-Type: image/png\r\n" },
WiredHome 3:17928786bdb5 38 {".zip", "Content-Type: image/zip\r\n" },
WiredHome 3:17928786bdb5 39 {".gz", "Content-Type: image/gz\r\n" },
WiredHome 3:17928786bdb5 40 {".tar", "Content-Type: image/tar\r\n" },
WiredHome 3:17928786bdb5 41 {".txt", "Content-Type: plain/text\r\n" },
WiredHome 3:17928786bdb5 42 {".pdf", "Content-Type: application/pdf\r\n" },
WiredHome 3:17928786bdb5 43 {".htm", "Content-Type: text/html\r\n" },
WiredHome 3:17928786bdb5 44 {".html","Content-Type: text/html\r\n" },
WiredHome 0:729320f63c5c 45 {0,0}
WiredHome 0:729320f63c5c 46 };
WiredHome 0:729320f63c5c 47
WiredHome 8:262583f054f6 48 #ifdef DEBUG
WiredHome 9:2ea342765c9d 49 // This uses standard library dynamic memory management, but for an
WiredHome 9:2ea342765c9d 50 // embedded system there are alternates that may make better sense -
WiredHome 9:2ea342765c9d 51 // search the web for embedded system malloc alternates.
WiredHome 8:262583f054f6 52 static void * MyMalloc(int x, int y)
WiredHome 8:262583f054f6 53 {
WiredHome 8:262583f054f6 54 std::printf("[%04d] malloc(%d)\r\n", y, x);
WiredHome 8:262583f054f6 55 return malloc(x);
WiredHome 8:262583f054f6 56 }
WiredHome 8:262583f054f6 57 #define mymalloc(x) MyMalloc(x, __LINE__)
WiredHome 8:262583f054f6 58 #define myfree(x) \
WiredHome 8:262583f054f6 59 pc->printf("[%04d] free(%02x %02x %02x %02x ...\r\n", __LINE__, *x, *(x+1), *(x+2), *(x+3)); \
WiredHome 8:262583f054f6 60 free(x);
WiredHome 8:262583f054f6 61 #else
WiredHome 8:262583f054f6 62 #define mymalloc(x) malloc(x)
WiredHome 8:262583f054f6 63 #define myfree(x) free(x)
WiredHome 8:262583f054f6 64 #endif
WiredHome 8:262583f054f6 65
WiredHome 3:17928786bdb5 66 HTTPServer::HTTPServer(
WiredHome 7:99ad7a67f05e 67 Wifly * _wf,
WiredHome 7:99ad7a67f05e 68 int port,
WiredHome 7:99ad7a67f05e 69 const char * _webroot,
WiredHome 7:99ad7a67f05e 70 int _maxparams,
WiredHome 7:99ad7a67f05e 71 int _maxdynamicpages,
WiredHome 7:99ad7a67f05e 72 PC * _pc,
WiredHome 7:99ad7a67f05e 73 int _allocforheader,
WiredHome 3:17928786bdb5 74 int _allocforfile)
WiredHome 0:729320f63c5c 75 {
WiredHome 0:729320f63c5c 76 wifly = _wf;
WiredHome 0:729320f63c5c 77 webroot = (char *)malloc(strlen(_webroot)+1);
WiredHome 0:729320f63c5c 78 strcpy(webroot, _webroot);
WiredHome 0:729320f63c5c 79 maxparams = _maxparams;
WiredHome 0:729320f63c5c 80 maxdynamicpages = _maxdynamicpages;
WiredHome 0:729320f63c5c 81 params = (namevalue *)malloc(maxparams * sizeof(namevalue));
WiredHome 0:729320f63c5c 82 handlers = (handler *)malloc(maxdynamicpages * sizeof(handler));
WiredHome 3:17928786bdb5 83 headerbuffersize = _allocforheader;
WiredHome 3:17928786bdb5 84 headerbuffer = (char *)malloc(headerbuffersize);
WiredHome 0:729320f63c5c 85 pc = _pc;
WiredHome 3:17928786bdb5 86 queryType = NULL;
WiredHome 3:17928786bdb5 87 queryString = NULL;
WiredHome 3:17928786bdb5 88 hostString = NULL;
WiredHome 3:17928786bdb5 89 contentLength = NULL;
WiredHome 3:17928786bdb5 90 contentType = NULL;
WiredHome 3:17928786bdb5 91 postQueryString = NULL;
WiredHome 0:729320f63c5c 92 paramcount = 0;
WiredHome 0:729320f63c5c 93 handlercount = 0;
WiredHome 3:17928786bdb5 94 maxheaderbytes = 0;
WiredHome 0:729320f63c5c 95 server = new TCPSocketServer();
WiredHome 0:729320f63c5c 96 server->bind(port);
WiredHome 0:729320f63c5c 97 server->listen();
WiredHome 8:262583f054f6 98 // server->set_blocking(false, 0);
WiredHome 8:262583f054f6 99 // client.set_blocking(false, 0);
WiredHome 8:262583f054f6 100 // server->accept(client);
WiredHome 3:17928786bdb5 101 ResetPerformanceData();
WiredHome 3:17928786bdb5 102 timer.start();
WiredHome 0:729320f63c5c 103 }
WiredHome 0:729320f63c5c 104
WiredHome 0:729320f63c5c 105 HTTPServer::~HTTPServer()
WiredHome 0:729320f63c5c 106 {
WiredHome 8:262583f054f6 107 int i;
WiredHome 8:262583f054f6 108
WiredHome 8:262583f054f6 109 for (i=0; i<handlercount; i++)
WiredHome 8:262583f054f6 110 myfree(handlers[i].path);
WiredHome 8:262583f054f6 111 myfree(headerbuffer);
WiredHome 8:262583f054f6 112 myfree(handlers);
WiredHome 8:262583f054f6 113 myfree(params);
WiredHome 8:262583f054f6 114 myfree(webroot);
WiredHome 0:729320f63c5c 115 webroot = NULL;
WiredHome 0:729320f63c5c 116 }
WiredHome 0:729320f63c5c 117
WiredHome 3:17928786bdb5 118 int HTTPServer::GetMaxHeaderSize()
WiredHome 3:17928786bdb5 119 {
WiredHome 3:17928786bdb5 120 return maxheaderbytes;
WiredHome 3:17928786bdb5 121 }
WiredHome 3:17928786bdb5 122
WiredHome 0:729320f63c5c 123 bool HTTPServer::RegisterHandler(const char * path, Handler callback)
WiredHome 0:729320f63c5c 124 {
WiredHome 0:729320f63c5c 125 if (handlercount < maxdynamicpages && path && callback) {
WiredHome 8:262583f054f6 126 handlers[handlercount].path = (char *)mymalloc(strlen(path)+1);
WiredHome 0:729320f63c5c 127 memcpy(handlers[handlercount].path, path, strlen(path)+1);
WiredHome 0:729320f63c5c 128 handlers[handlercount].callback = callback;
WiredHome 0:729320f63c5c 129 handlercount++;
WiredHome 0:729320f63c5c 130 return true;
WiredHome 0:729320f63c5c 131 } else {
WiredHome 0:729320f63c5c 132 return false;
WiredHome 0:729320f63c5c 133 }
WiredHome 0:729320f63c5c 134 }
WiredHome 0:729320f63c5c 135
WiredHome 2:a29c32190037 136 // Poll()
WiredHome 0:729320f63c5c 137 //
WiredHome 0:729320f63c5c 138 // *OPEN*GET /x=1 HTTP/1.1
WiredHome 0:729320f63c5c 139 // Host: 192.168.1.140
WiredHome 0:729320f63c5c 140 // Connection: keep-alive
WiredHome 0:729320f63c5c 141 // Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
WiredHome 0:729320f63c5c 142 // 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 143 // Accept-Encoding: gzip,deflate,sdch
WiredHome 0:729320f63c5c 144 // Accept-Language: en-US,en;q=0.8
WiredHome 0:729320f63c5c 145 //
WiredHome 2:a29c32190037 146 void HTTPServer::Poll()
WiredHome 0:729320f63c5c 147 {
WiredHome 3:17928786bdb5 148 typedef enum {
WiredHome 3:17928786bdb5 149 Idle, // waiting for a connection
WiredHome 3:17928786bdb5 150 Receiving, // receiving data
WiredHome 3:17928786bdb5 151 Sending, // send the response
WiredHome 7:99ad7a67f05e 152 WaitingToClose, // small timeout to close
WiredHome 7:99ad7a67f05e 153 Reset
WiredHome 3:17928786bdb5 154 } state;
WiredHome 0:729320f63c5c 155 static state op = Idle;
WiredHome 3:17928786bdb5 156 static char * bPtr = headerbuffer;
WiredHome 0:729320f63c5c 157 int n;
WiredHome 3:17928786bdb5 158 static int t_ref; // reference point for the timer
WiredHome 0:729320f63c5c 159
WiredHome 8:262583f054f6 160 #ifdef DEBUG
WiredHome 8:262583f054f6 161 static state lastOp = Reset;
WiredHome 7:99ad7a67f05e 162 if (lastOp != op) {
WiredHome 9:2ea342765c9d 163 const char *states[] = {"Idle", "Receiving", "Sending", "WaitingToClose", "Reset"};
WiredHome 8:262583f054f6 164 pc->printf("Poll: %s\r\n", states[op]);
WiredHome 7:99ad7a67f05e 165 lastOp = op;
WiredHome 7:99ad7a67f05e 166 }
WiredHome 8:262583f054f6 167 #endif
WiredHome 0:729320f63c5c 168 switch(op) {
WiredHome 3:17928786bdb5 169 default: // not expected to arrive here
WiredHome 3:17928786bdb5 170 op = Idle;
WiredHome 3:17928786bdb5 171 break;
WiredHome 8:262583f054f6 172
WiredHome 3:17928786bdb5 173 case Idle:
WiredHome 3:17928786bdb5 174 timer.reset();
WiredHome 3:17928786bdb5 175 bPtr = headerbuffer;
WiredHome 8:262583f054f6 176 if (0 == server->accept(client)) { // client.receive(bPtr, 0)) { // server->accept(client) == 0) {
WiredHome 3:17928786bdb5 177 op = Receiving;
WiredHome 3:17928786bdb5 178 t_ref = timer.read_us();
WiredHome 8:262583f054f6 179 #ifdef DEBUG
WiredHome 8:262583f054f6 180 pc->printf("Accept at %d\r\n", t_ref);
WiredHome 8:262583f054f6 181 #endif
WiredHome 3:17928786bdb5 182 }
WiredHome 0:729320f63c5c 183 break;
WiredHome 8:262583f054f6 184
WiredHome 3:17928786bdb5 185 case Receiving:
WiredHome 3:17928786bdb5 186 n = client.receive(bPtr, headerbuffersize - (bPtr - headerbuffer));
WiredHome 3:17928786bdb5 187 if (n < 0) {
WiredHome 9:2ea342765c9d 188 #ifdef DEBUG
WiredHome 8:262583f054f6 189 pc->printf("*** client.receive() => %d\r\n", n);
WiredHome 9:2ea342765c9d 190 #endif
WiredHome 3:17928786bdb5 191 } else if (n) {
WiredHome 3:17928786bdb5 192 bPtr[n] = '\0';
WiredHome 3:17928786bdb5 193 if (ParseHeader(headerbuffer)) {
WiredHome 3:17928786bdb5 194 op = Sending;
WiredHome 3:17928786bdb5 195 t_ref = RecordPerformanceData(&perfData.Header, t_ref);
WiredHome 3:17928786bdb5 196 }
WiredHome 3:17928786bdb5 197 bPtr += n;
WiredHome 0:729320f63c5c 198 }
WiredHome 0:729320f63c5c 199 break;
WiredHome 8:262583f054f6 200
WiredHome 0:729320f63c5c 201 case Sending:
WiredHome 3:17928786bdb5 202 SendResponse();
WiredHome 0:729320f63c5c 203 op = WaitingToClose;
WiredHome 3:17928786bdb5 204 RecordPerformanceData(&perfData.SendData, t_ref);
WiredHome 0:729320f63c5c 205 break;
WiredHome 9:2ea342765c9d 206
WiredHome 0:729320f63c5c 207 case WaitingToClose:
WiredHome 3:17928786bdb5 208 close_connection();
WiredHome 0:729320f63c5c 209 op = Idle;
WiredHome 0:729320f63c5c 210 break;
WiredHome 0:729320f63c5c 211 }
WiredHome 0:729320f63c5c 212 }
WiredHome 0:729320f63c5c 213
WiredHome 0:729320f63c5c 214
WiredHome 0:729320f63c5c 215 const char * HTTPServer::GetSupportedType(const char * filename)
WiredHome 0:729320f63c5c 216 {
WiredHome 0:729320f63c5c 217 int i;
WiredHome 0:729320f63c5c 218 int buflen = strlen(filename);
WiredHome 0:729320f63c5c 219 int extlen;
WiredHome 0:729320f63c5c 220
WiredHome 0:729320f63c5c 221 for (i=0; extensions[i].ext != 0; i++) {
WiredHome 0:729320f63c5c 222 extlen = strlen(extensions[i].ext);
WiredHome 0:729320f63c5c 223 if ( !strncmp(&filename[buflen-extlen], extensions[i].ext, extlen)) {
WiredHome 0:729320f63c5c 224 return extensions[i].filetype;
WiredHome 0:729320f63c5c 225 }
WiredHome 0:729320f63c5c 226 }
WiredHome 0:729320f63c5c 227 return NULL;
WiredHome 0:729320f63c5c 228 }
WiredHome 0:729320f63c5c 229
WiredHome 3:17928786bdb5 230
WiredHome 0:729320f63c5c 231 void HTTPServer::send(const char * msg, int bytes)
WiredHome 0:729320f63c5c 232 {
WiredHome 0:729320f63c5c 233 if (bytes == -1)
WiredHome 0:729320f63c5c 234 bytes = strlen(msg);
WiredHome 0:729320f63c5c 235 wifly->send(msg, bytes);
WiredHome 0:729320f63c5c 236 }
WiredHome 0:729320f63c5c 237
WiredHome 3:17928786bdb5 238
WiredHome 0:729320f63c5c 239 bool HTTPServer::SendFile(const char * filename, const char * filetype)
WiredHome 0:729320f63c5c 240 {
WiredHome 0:729320f63c5c 241 FILE * fp;
WiredHome 3:17928786bdb5 242
WiredHome 0:729320f63c5c 243 fp = fopen(filename,"rb");
WiredHome 0:729320f63c5c 244 if (fp) { // can open it
WiredHome 8:262583f054f6 245 char *fbuffer = (char *)mymalloc(FILESEND_BUF_SIZE);
WiredHome 0:729320f63c5c 246 int bytes;
WiredHome 0:729320f63c5c 247
WiredHome 3:17928786bdb5 248 if (fbuffer) {
WiredHome 3:17928786bdb5 249 header(200, "OK", filetype);
WiredHome 0:729320f63c5c 250 bytes = fread(fbuffer,sizeof(char),FILESEND_BUF_SIZE,fp);
WiredHome 3:17928786bdb5 251 while (bytes > 0) {
WiredHome 3:17928786bdb5 252 send(fbuffer, bytes);
WiredHome 3:17928786bdb5 253 bytes = fread(fbuffer,sizeof(char),FILESEND_BUF_SIZE,fp);
WiredHome 3:17928786bdb5 254 }
WiredHome 8:262583f054f6 255 myfree(fbuffer);
WiredHome 3:17928786bdb5 256 } else {
WiredHome 3:17928786bdb5 257 header(500, "Server Error", "Pragma: err - insufficient memory\r\n");
WiredHome 0:729320f63c5c 258 }
WiredHome 0:729320f63c5c 259 fclose(fp);
WiredHome 0:729320f63c5c 260 return true;
WiredHome 0:729320f63c5c 261 } else {
WiredHome 3:17928786bdb5 262 header(404, "Not Found", "Pragma: err - Can't open file\r\n");
WiredHome 0:729320f63c5c 263 return false;
WiredHome 0:729320f63c5c 264 }
WiredHome 0:729320f63c5c 265 }
WiredHome 0:729320f63c5c 266
WiredHome 0:729320f63c5c 267 int HTTPServer::HexCharToInt(char c)
WiredHome 0:729320f63c5c 268 {
WiredHome 0:729320f63c5c 269 if (c >= 'a' && c <= 'f')
WiredHome 0:729320f63c5c 270 return (c - 'a' + 10);
WiredHome 0:729320f63c5c 271 else if (c >= 'A' && c <= 'F')
WiredHome 0:729320f63c5c 272 return (c - 'A' + 10);
WiredHome 0:729320f63c5c 273 else if (c >= '0' && c <= '9')
WiredHome 0:729320f63c5c 274 return c - '0';
WiredHome 0:729320f63c5c 275 else
WiredHome 0:729320f63c5c 276 return 0;
WiredHome 0:729320f63c5c 277 }
WiredHome 0:729320f63c5c 278
WiredHome 0:729320f63c5c 279 char HTTPServer::HexPairToChar(char * p)
WiredHome 0:729320f63c5c 280 {
WiredHome 0:729320f63c5c 281 return 16 * HexCharToInt(*p) + HexCharToInt(*(p+1));
WiredHome 0:729320f63c5c 282 }
WiredHome 0:729320f63c5c 283
WiredHome 0:729320f63c5c 284 void HTTPServer::UnescapeString(char * encoded)
WiredHome 0:729320f63c5c 285 {
WiredHome 0:729320f63c5c 286 char *p;
WiredHome 0:729320f63c5c 287
WiredHome 0:729320f63c5c 288 // first convert '+' to ' '
WiredHome 0:729320f63c5c 289 p = strchr(encoded, '+');
WiredHome 0:729320f63c5c 290 while (p) {
WiredHome 0:729320f63c5c 291 *p = ' ';
WiredHome 0:729320f63c5c 292 p = strchr(encoded, '+');
WiredHome 0:729320f63c5c 293 }
WiredHome 0:729320f63c5c 294 // then convert hex '%xx' to char 'x'
WiredHome 0:729320f63c5c 295 p = strchr(encoded, '%');
WiredHome 0:729320f63c5c 296 while (p) {
WiredHome 0:729320f63c5c 297 if (strchr("0123456789ABCDEFabcdef", *(p+1))
WiredHome 0:729320f63c5c 298 && strchr("0123456789ABCDEFabcdef", *(p+2)) ) {
WiredHome 0:729320f63c5c 299 *p = HexPairToChar(p+1);
WiredHome 0:729320f63c5c 300 p++; // advance past the %
WiredHome 0:729320f63c5c 301 char * a = p;
WiredHome 0:729320f63c5c 302 char * b = p + 2;
WiredHome 0:729320f63c5c 303 do {
WiredHome 0:729320f63c5c 304 *a++ = *b++;
WiredHome 0:729320f63c5c 305 } while (*b);
WiredHome 0:729320f63c5c 306 *a = '\0';
WiredHome 0:729320f63c5c 307 }
WiredHome 0:729320f63c5c 308 p = strchr(p, '%');
WiredHome 0:729320f63c5c 309 }
WiredHome 0:729320f63c5c 310 }
WiredHome 0:729320f63c5c 311
WiredHome 0:729320f63c5c 312 const char * HTTPServer::GetParameter(const char * name)
WiredHome 0:729320f63c5c 313 {
WiredHome 0:729320f63c5c 314 for (int i=0; i<paramcount; i++) {
WiredHome 0:729320f63c5c 315 if (strcmp(params[i].name, name) == 0) {
WiredHome 0:729320f63c5c 316 return params[i].value;
WiredHome 0:729320f63c5c 317 }
WiredHome 0:729320f63c5c 318 }
WiredHome 0:729320f63c5c 319 return NULL;
WiredHome 0:729320f63c5c 320 }
WiredHome 0:729320f63c5c 321
WiredHome 0:729320f63c5c 322 // this=that&who=what&more=stuff...
WiredHome 0:729320f63c5c 323 // ^ ^ ^
WiredHome 3:17928786bdb5 324 void HTTPServer::ParseParameters(char * pName)
WiredHome 0:729320f63c5c 325 {
WiredHome 0:729320f63c5c 326 char * pVal;
WiredHome 0:729320f63c5c 327 char * pNextName;
WiredHome 0:729320f63c5c 328
WiredHome 0:729320f63c5c 329 // Parse params
WiredHome 0:729320f63c5c 330 pVal = strchr(pName, '#'); // If there is a '#fragment_id', we can ignore it
WiredHome 0:729320f63c5c 331 if (pVal)
WiredHome 3:17928786bdb5 332 *pVal = '\0';
WiredHome 0:729320f63c5c 333 do {
WiredHome 0:729320f63c5c 334 //pc->printf("Parse(%s)\r\n", pName);
WiredHome 0:729320f63c5c 335 //*pName++ = '\0'; // already '\0' on the first entry
WiredHome 0:729320f63c5c 336 params[paramcount].name = pName;
WiredHome 0:729320f63c5c 337 pVal = strchr(pName, '=');
WiredHome 0:729320f63c5c 338 pNextName = strchr(pName,'&');
WiredHome 0:729320f63c5c 339 if (pVal) {
WiredHome 0:729320f63c5c 340 if (pNextName == NULL || (pNextName && pNextName > pVal)) {
WiredHome 0:729320f63c5c 341 *pVal++ = '\0';
WiredHome 0:729320f63c5c 342 params[paramcount].value = pVal;
WiredHome 0:729320f63c5c 343 pName = pVal;
WiredHome 0:729320f63c5c 344 }
WiredHome 0:729320f63c5c 345 }
WiredHome 0:729320f63c5c 346 //pc->printf(" [%s]=[%s]\r\n", params[paramcount].name, params[paramcount].value);
WiredHome 0:729320f63c5c 347 paramcount++;
WiredHome 0:729320f63c5c 348 if (pNextName) {
WiredHome 0:729320f63c5c 349 pName = pNextName;
WiredHome 0:729320f63c5c 350 *pName++ = '\0';
WiredHome 0:729320f63c5c 351 } else {
WiredHome 0:729320f63c5c 352 pName = NULL;
WiredHome 0:729320f63c5c 353 }
WiredHome 0:729320f63c5c 354 } while (pName && paramcount < maxparams);
WiredHome 0:729320f63c5c 355 }
WiredHome 0:729320f63c5c 356
WiredHome 0:729320f63c5c 357
WiredHome 5:c9b27e718054 358 bool HTTPServer::GetRemoteAddr(char * str, int strSize)
WiredHome 0:729320f63c5c 359 {
WiredHome 0:729320f63c5c 360 bool res = false;
WiredHome 0:729320f63c5c 361 char *p;
WiredHome 0:729320f63c5c 362
WiredHome 4:f34642902056 363 if (strSize < 16) { // Can only guard it here w/o modifying Wifly class
WiredHome 3:17928786bdb5 364 *str = '\0';
WiredHome 5:c9b27e718054 365 return res;
WiredHome 3:17928786bdb5 366 }
WiredHome 5:c9b27e718054 367 res = wifly->sendCommand("show z\r", NULL, str, strSize);
WiredHome 0:729320f63c5c 368 if (res) {
WiredHome 0:729320f63c5c 369 p = strchr(str, '\n'); // truncate after the octets.
WiredHome 0:729320f63c5c 370 if (p) *p = '\0';
WiredHome 0:729320f63c5c 371 p = strchr(str, ' '); // or a space
WiredHome 0:729320f63c5c 372 if (p) *p = '\0';
WiredHome 0:729320f63c5c 373 p = strchr(str, '<'); // or a <
WiredHome 0:729320f63c5c 374 if (p) *p = '\0';
WiredHome 5:c9b27e718054 375 res = true;
WiredHome 0:729320f63c5c 376 }
WiredHome 0:729320f63c5c 377 wifly->exit();
WiredHome 5:c9b27e718054 378 return res;
WiredHome 0:729320f63c5c 379 }
WiredHome 0:729320f63c5c 380
WiredHome 0:729320f63c5c 381
WiredHome 0:729320f63c5c 382 void HTTPServer::header(int code, const char * code_text, const char * content_type, const char * optional_text)
WiredHome 0:729320f63c5c 383 {
WiredHome 0:729320f63c5c 384 char http[100];
WiredHome 0:729320f63c5c 385
WiredHome 0:729320f63c5c 386 sprintf(http, "%s %i %s\r\n", hdr_httpver, code, code_text);
WiredHome 0:729320f63c5c 387 send(http);
WiredHome 0:729320f63c5c 388 send(hdr_age);
WiredHome 0:729320f63c5c 389 send(hdr_server);
WiredHome 0:729320f63c5c 390 if (content_type) {
WiredHome 0:729320f63c5c 391 send(content_type);
WiredHome 0:729320f63c5c 392 }
WiredHome 0:729320f63c5c 393 if (optional_text) {
WiredHome 0:729320f63c5c 394 send(optional_text);
WiredHome 0:729320f63c5c 395 }
WiredHome 2:a29c32190037 396 send(hdr_dnt);
WiredHome 0:729320f63c5c 397 send(hdr_close);
WiredHome 0:729320f63c5c 398 send(nl);
WiredHome 0:729320f63c5c 399 }
WiredHome 0:729320f63c5c 400
WiredHome 7:99ad7a67f05e 401 bool HTTPServer::close_connection()
WiredHome 0:729320f63c5c 402 {
WiredHome 7:99ad7a67f05e 403 bool res;
WiredHome 7:99ad7a67f05e 404
WiredHome 7:99ad7a67f05e 405 res = wifly->close();
WiredHome 7:99ad7a67f05e 406 #ifdef DEBUG
WiredHome 7:99ad7a67f05e 407 pc->printf("close connection returned %d\r\n", res);
WiredHome 0:729320f63c5c 408 #endif
WiredHome 7:99ad7a67f05e 409 return res;
WiredHome 0:729320f63c5c 410 }
WiredHome 0:729320f63c5c 411
WiredHome 0:729320f63c5c 412 bool HTTPServer::Extract(char * haystack, char * needle, char ** string)
WiredHome 0:729320f63c5c 413 {
WiredHome 0:729320f63c5c 414 bool ret = false; // assume failure until proven otherwise
WiredHome 0:729320f63c5c 415 char * qs = NULL;
WiredHome 0:729320f63c5c 416 char * eqs = NULL;
WiredHome 0:729320f63c5c 417 char * container = NULL;
WiredHome 0:729320f63c5c 418 char * get = strstr(haystack, needle); // what if not at the front?
WiredHome 0:729320f63c5c 419 if (get) {
WiredHome 0:729320f63c5c 420 // Seems to be a valid "...GET /QueryString HTTP/1.1"
WiredHome 8:262583f054f6 421 // or "...<needle>param..."
WiredHome 0:729320f63c5c 422 qs = get + strlen(needle); // in case the needle didn't have space delimiters
WiredHome 0:729320f63c5c 423 while (*qs == ' ')
WiredHome 0:729320f63c5c 424 qs++;
WiredHome 0:729320f63c5c 425 // /QueryString\0HTTP/1.1\0\0
WiredHome 0:729320f63c5c 426 if (*string) // recycle old string when working a new one
WiredHome 8:262583f054f6 427 myfree(*string);
WiredHome 8:262583f054f6 428 container = (char *)mymalloc(strlen(qs));
WiredHome 0:729320f63c5c 429 if (container) {
WiredHome 0:729320f63c5c 430 strcpy(container, qs);
WiredHome 0:729320f63c5c 431 eqs = strchr(container, ' ');
WiredHome 0:729320f63c5c 432 if (eqs)
WiredHome 0:729320f63c5c 433 *eqs = '\0';
WiredHome 0:729320f63c5c 434 *string = container;
WiredHome 8:262583f054f6 435 #ifdef DEBUG
WiredHome 8:262583f054f6 436 pc->printf("Extract(%s) = %s\r\n", needle, container);
WiredHome 8:262583f054f6 437 #endif
WiredHome 0:729320f63c5c 438 ret = true;
WiredHome 0:729320f63c5c 439 } else {
WiredHome 0:729320f63c5c 440 *string = NULL; // something bad happened... no memory
WiredHome 0:729320f63c5c 441 }
WiredHome 0:729320f63c5c 442 }
WiredHome 0:729320f63c5c 443 return ret;
WiredHome 0:729320f63c5c 444 }
WiredHome 0:729320f63c5c 445
WiredHome 0:729320f63c5c 446 char * HTTPServer::rewriteWithDefaultFile(char * queryString)
WiredHome 0:729320f63c5c 447 {
WiredHome 8:262583f054f6 448 char * temp = (char *)mymalloc(strlen(queryString) + strlen(DEFAULT_FILENAME) + 1);
WiredHome 0:729320f63c5c 449
WiredHome 0:729320f63c5c 450 if (temp) {
WiredHome 0:729320f63c5c 451 *temp = '\0';
WiredHome 0:729320f63c5c 452 strcpy(temp, queryString);
WiredHome 0:729320f63c5c 453 strcat(temp, DEFAULT_FILENAME);
WiredHome 8:262583f054f6 454 myfree(queryString);
WiredHome 0:729320f63c5c 455 return temp;
WiredHome 0:729320f63c5c 456 } else {
WiredHome 0:729320f63c5c 457 return queryString;
WiredHome 0:729320f63c5c 458 }
WiredHome 0:729320f63c5c 459 }
WiredHome 0:729320f63c5c 460
WiredHome 0:729320f63c5c 461 char * HTTPServer::rewritePrependWebroot(char * queryString)
WiredHome 0:729320f63c5c 462 {
WiredHome 8:262583f054f6 463 char * temp = (char *)mymalloc(strlen(webroot) + strlen(queryString) + 1);
WiredHome 0:729320f63c5c 464
WiredHome 0:729320f63c5c 465 if (temp) {
WiredHome 0:729320f63c5c 466 *temp = '\0';
WiredHome 0:729320f63c5c 467 strcpy(temp, webroot);
WiredHome 0:729320f63c5c 468 if (temp[strlen(temp)-1] == '/' && *queryString == '/')
WiredHome 0:729320f63c5c 469 temp[strlen(temp)-1] = '\0';
WiredHome 0:729320f63c5c 470 strcat(temp, queryString);
WiredHome 8:262583f054f6 471 myfree(queryString);
WiredHome 0:729320f63c5c 472 return temp;
WiredHome 0:729320f63c5c 473 } else {
WiredHome 0:729320f63c5c 474 return queryString;
WiredHome 0:729320f63c5c 475 }
WiredHome 0:729320f63c5c 476 }
WiredHome 0:729320f63c5c 477
WiredHome 3:17928786bdb5 478 bool HTTPServer::CheckDynamicHandlers()
WiredHome 3:17928786bdb5 479 {
WiredHome 3:17928786bdb5 480 bool regHandled = false;
WiredHome 0:729320f63c5c 481
WiredHome 3:17928786bdb5 482 // If this queryString is in the list of registered handlers, call that
WiredHome 3:17928786bdb5 483 for (int i=0; i<handlercount; i++) {
WiredHome 3:17928786bdb5 484 if (strcmp(handlers[i].path, queryString) == 0) {
WiredHome 3:17928786bdb5 485 (*handlers[i].callback)(this, SEND_PAGE, queryString, params, paramcount);
WiredHome 3:17928786bdb5 486 regHandled = true;
WiredHome 3:17928786bdb5 487 break; // we only execute the first one
WiredHome 3:17928786bdb5 488 }
WiredHome 3:17928786bdb5 489 }
WiredHome 3:17928786bdb5 490 return regHandled;
WiredHome 3:17928786bdb5 491 }
WiredHome 3:17928786bdb5 492
WiredHome 3:17928786bdb5 493 void HTTPServer::SendResponse()
WiredHome 3:17928786bdb5 494 {
WiredHome 8:262583f054f6 495 #ifdef DEBUG
WiredHome 8:262583f054f6 496 pc->printf("SendResponse(%s) [%d]\r\n", queryType, __LINE__);
WiredHome 8:262583f054f6 497 #endif
WiredHome 3:17928786bdb5 498 if (strcmp(queryType, "GET") == 0 || strcmp(queryType, "POST") == 0) {
WiredHome 3:17928786bdb5 499 if (!(queryString[0] == '.' && queryString[1] == '.')) {
WiredHome 3:17928786bdb5 500 const char * fType;
WiredHome 3:17928786bdb5 501
WiredHome 8:262583f054f6 502 #ifdef DEBUG
WiredHome 8:262583f054f6 503 pc->printf(" SendResponse() [%d]\r\n", __LINE__);
WiredHome 8:262583f054f6 504 #endif
WiredHome 3:17928786bdb5 505 if (!CheckDynamicHandlers()) {
WiredHome 3:17928786bdb5 506 // Otherwise, this queryString must be trying to reference a static file
WiredHome 3:17928786bdb5 507 if (queryString[strlen(queryString)-1] == '/') {
WiredHome 3:17928786bdb5 508 queryString = rewriteWithDefaultFile(queryString);
WiredHome 3:17928786bdb5 509 }
WiredHome 3:17928786bdb5 510 // see if we support this file type
WiredHome 3:17928786bdb5 511 fType = GetSupportedType(queryString);
WiredHome 3:17928786bdb5 512 if (fType) {
WiredHome 3:17928786bdb5 513 queryString = rewritePrependWebroot(queryString);
WiredHome 3:17928786bdb5 514 SendFile(queryString, fType);
WiredHome 3:17928786bdb5 515 } else {
WiredHome 3:17928786bdb5 516 //pc->printf("Unsupported file type %s\r\n", queryString);
WiredHome 3:17928786bdb5 517 header(404, "Not Found", "Pragma: err - Unsupported type\r\n");
WiredHome 3:17928786bdb5 518 }
WiredHome 3:17928786bdb5 519 }
WiredHome 3:17928786bdb5 520 } else {
WiredHome 3:17928786bdb5 521 //pc->printf("Unsupported path %s\r\n", queryString);
WiredHome 3:17928786bdb5 522 header(400, "Bad Request", "Pragma: err - Unsupported path\r\n");
WiredHome 3:17928786bdb5 523 }
WiredHome 3:17928786bdb5 524 } else {
WiredHome 3:17928786bdb5 525 //pc->printf("Unsupported query type %s\r\n", queryType);
WiredHome 3:17928786bdb5 526 header(400, "Bad Request", "Pragma: err - Unsupported query type\r\n");
WiredHome 3:17928786bdb5 527 }
WiredHome 3:17928786bdb5 528 if (queryType) {
WiredHome 8:262583f054f6 529 myfree(queryType);
WiredHome 3:17928786bdb5 530 queryType = NULL;
WiredHome 3:17928786bdb5 531 }
WiredHome 3:17928786bdb5 532 if (queryString) {
WiredHome 8:262583f054f6 533 myfree(queryString);
WiredHome 3:17928786bdb5 534 queryString = NULL;
WiredHome 3:17928786bdb5 535 }
WiredHome 3:17928786bdb5 536 if (hostString) {
WiredHome 8:262583f054f6 537 myfree(hostString);
WiredHome 3:17928786bdb5 538 hostString = NULL;
WiredHome 3:17928786bdb5 539 }
WiredHome 3:17928786bdb5 540 if (contentLength) {
WiredHome 8:262583f054f6 541 myfree(contentLength);
WiredHome 3:17928786bdb5 542 contentLength = NULL;
WiredHome 3:17928786bdb5 543 }
WiredHome 3:17928786bdb5 544 if (contentType) {
WiredHome 8:262583f054f6 545 myfree(contentType);
WiredHome 3:17928786bdb5 546 contentType = NULL;
WiredHome 3:17928786bdb5 547 }
WiredHome 3:17928786bdb5 548 if (postQueryString) {
WiredHome 8:262583f054f6 549 myfree(postQueryString);
WiredHome 3:17928786bdb5 550 postQueryString = NULL;
WiredHome 3:17928786bdb5 551 }
WiredHome 3:17928786bdb5 552 }
WiredHome 3:17928786bdb5 553
WiredHome 3:17928786bdb5 554 bool HTTPServer::ParseHeader(char * buffer)
WiredHome 3:17928786bdb5 555 {
WiredHome 3:17928786bdb5 556 char * dblCR;
WiredHome 3:17928786bdb5 557 bool advanceState = false;
WiredHome 3:17928786bdb5 558 int bytecount;
WiredHome 7:99ad7a67f05e 559
WiredHome 3:17928786bdb5 560 // Bad hack to have to do this here, but it isn't being set in the
WiredHome 3:17928786bdb5 561 // underlying layer, and this is what allows it to properly "close"
WiredHome 3:17928786bdb5 562 // when it is done.
WiredHome 3:17928786bdb5 563 wifly->setConnectionState(true);
WiredHome 3:17928786bdb5 564 // Buffer could have partial, but the double \r\n is the key
WiredHome 8:262583f054f6 565 // GET /QueryString HTTP/1.1\r\n
WiredHome 8:262583f054f6 566 // GET /QueryString HTTP/1.1\r\nHost: 192.168.1.140\r\nCache-Con
WiredHome 8:262583f054f6 567 // GET /QueryString HTTP/1.1\r\nHost: 192.168.1.140\r\nCache-Control: max-age=0\r\n\r\n
WiredHome 3:17928786bdb5 568 dblCR = strstr(buffer,"\r\n\r\n");
WiredHome 3:17928786bdb5 569 if (dblCR) { // Have to scan from the beginning in case split on \r
WiredHome 8:262583f054f6 570 #ifdef DEBUG
WiredHome 8:262583f054f6 571 pc->printf("==\r\n%s==\r\n", buffer);
WiredHome 3:17928786bdb5 572 #endif
WiredHome 3:17928786bdb5 573 char * soRec = buffer; // start of the next record of text
WiredHome 3:17928786bdb5 574 char * eoRec = strchr(soRec, '\n'); // search for end of a record
WiredHome 7:99ad7a67f05e 575
WiredHome 3:17928786bdb5 576 bytecount = strlen(buffer);
WiredHome 3:17928786bdb5 577 if (bytecount > maxheaderbytes)
WiredHome 3:17928786bdb5 578 maxheaderbytes = bytecount;
WiredHome 3:17928786bdb5 579 while (eoRec) {
WiredHome 3:17928786bdb5 580 *eoRec = '\0';
WiredHome 3:17928786bdb5 581 if (*(eoRec-1) == '\r')
WiredHome 3:17928786bdb5 582 *(eoRec-1) = '\0';
WiredHome 8:262583f054f6 583 #ifdef DEBUG
WiredHome 8:262583f054f6 584 pc->printf("rec {%s}\r\n", soRec);
WiredHome 8:262583f054f6 585 #endif
WiredHome 8:262583f054f6 586 // Inspect the supported query types (GET, POST) and ignore (HEAD, PUT, OPTION, DELETE, TRACE, CONNECT]
WiredHome 8:262583f054f6 587 // This is very clumsy
WiredHome 8:262583f054f6 588 if (strstr(soRec, "GET ") == soRec) {
WiredHome 8:262583f054f6 589 Extract(soRec, "GET", &queryString);
WiredHome 8:262583f054f6 590 if (queryString) {
WiredHome 8:262583f054f6 591 queryType = (char *)mymalloc(strlen("GET")+1);
WiredHome 8:262583f054f6 592 strcpy(queryType, "GET");
WiredHome 8:262583f054f6 593 }
WiredHome 8:262583f054f6 594 } else if (strstr(soRec, "POST ") == soRec) {
WiredHome 8:262583f054f6 595 Extract(soRec, "POST", &queryString);
WiredHome 8:262583f054f6 596 if (queryString) {
WiredHome 8:262583f054f6 597 queryType = (char *)mymalloc(strlen("POST")+1);
WiredHome 8:262583f054f6 598 strcpy(queryType, "POST");
WiredHome 8:262583f054f6 599 }
WiredHome 8:262583f054f6 600 }
WiredHome 3:17928786bdb5 601 Extract(soRec, "Host: ", &hostString);
WiredHome 3:17928786bdb5 602 Extract(soRec, "Content-Length: ", &contentLength);
WiredHome 3:17928786bdb5 603 Extract(soRec, "Content-Type: ", &contentType);
WiredHome 3:17928786bdb5 604 soRec = eoRec + 1;
WiredHome 3:17928786bdb5 605 eoRec = strchr(soRec, '\n');
WiredHome 3:17928786bdb5 606 }
WiredHome 3:17928786bdb5 607 if (queryString) {
WiredHome 3:17928786bdb5 608 // We have enough to try to reply
WiredHome 8:262583f054f6 609 #ifdef DEBUG
WiredHome 8:262583f054f6 610 pc->printf("create reply queryType{%s}, queryString{%s}\r\n", "GET", queryString);
WiredHome 8:262583f054f6 611 #endif
WiredHome 3:17928786bdb5 612 // parse params - if any
WiredHome 3:17928786bdb5 613 // /file.htm?name1=value1&name2=value2...
WiredHome 3:17928786bdb5 614 // /file.htm?name1&name2=value2...
WiredHome 3:17928786bdb5 615 paramcount = 0;
WiredHome 3:17928786bdb5 616 char * paramDelim = strchr(queryString, '?');
WiredHome 3:17928786bdb5 617 if (paramDelim) {
WiredHome 3:17928786bdb5 618 *paramDelim++ = '\0';
WiredHome 3:17928786bdb5 619 UnescapeString(paramDelim); // everything after the '?'
WiredHome 3:17928786bdb5 620 ParseParameters(paramDelim); // pointing at the NULL, but there are params beyond
WiredHome 3:17928786bdb5 621 }
WiredHome 3:17928786bdb5 622 //for (int i=0; i<paramcount; i++)
WiredHome 3:17928786bdb5 623 // pc->printf("param %d '%s'='%s'\r\n", i, params[i].name, params[i].value);
WiredHome 3:17928786bdb5 624 } else {
WiredHome 8:262583f054f6 625 pc->printf("ERROR: queryString not found\r\n");
WiredHome 3:17928786bdb5 626 }
WiredHome 3:17928786bdb5 627 advanceState = true;
WiredHome 3:17928786bdb5 628 buffer[0] = 0;
WiredHome 3:17928786bdb5 629
WiredHome 3:17928786bdb5 630 // This part parses the extra data on a POST method.
WiredHome 3:17928786bdb5 631 // Since there has to be a dynamic handler registered for this
WiredHome 3:17928786bdb5 632 // it would make sense to move some of this responsibility to
WiredHome 3:17928786bdb5 633 // that handler. It could then choose if it wanted to allocate
WiredHome 3:17928786bdb5 634 // the requested 'Content-Length' amount of memory.
WiredHome 3:17928786bdb5 635 // Should we check the 'Content-Type' to see if it is
WiredHome 3:17928786bdb5 636 // 'application/x-www-form-urlencoded'?
WiredHome 3:17928786bdb5 637 int postBytes = atoi(contentLength);
WiredHome 3:17928786bdb5 638 bool acceptIt = false;
WiredHome 3:17928786bdb5 639 //pc->printf("Content-Length = %d\r\n", postBytes);
WiredHome 3:17928786bdb5 640 if (strcmp(queryType, "POST") == 0 && postBytes > 0 ) {
WiredHome 3:17928786bdb5 641 if (postBytes) {
WiredHome 3:17928786bdb5 642 bool regHandled = false;
WiredHome 3:17928786bdb5 643 // Registered Dynamic Handler
WiredHome 3:17928786bdb5 644 // Callback and ask if they want to accept this data
WiredHome 3:17928786bdb5 645 for (int i=0; i<handlercount; i++) {
WiredHome 3:17928786bdb5 646 if (strcmp(handlers[i].path, queryString) == 0) {
WiredHome 3:17928786bdb5 647 acceptIt = (*handlers[i].callback)(this, CONTENT_LENGTH_REQUEST, queryString, params, paramcount);
WiredHome 3:17928786bdb5 648 regHandled = true;
WiredHome 3:17928786bdb5 649 break; // we only execute the first one
WiredHome 3:17928786bdb5 650 }
WiredHome 3:17928786bdb5 651 }
WiredHome 3:17928786bdb5 652
WiredHome 3:17928786bdb5 653 if (regHandled && acceptIt) {
WiredHome 3:17928786bdb5 654 // If so, we'll make space for it
WiredHome 8:262583f054f6 655 postQueryString = (char *)mymalloc(postBytes + 1);
WiredHome 3:17928786bdb5 656 if (postQueryString) {
WiredHome 3:17928786bdb5 657 char * offset;
WiredHome 3:17928786bdb5 658 int len;
WiredHome 3:17928786bdb5 659
WiredHome 3:17928786bdb5 660 dblCR += 4; // If we slurped up any of the POST,
WiredHome 3:17928786bdb5 661 while (*dblCR && *dblCR <= ' ')
WiredHome 3:17928786bdb5 662 dblCR++;
WiredHome 3:17928786bdb5 663 strcpy(postQueryString, dblCR); // copy that in and then get the rest
WiredHome 3:17928786bdb5 664 while ((len = strlen(postQueryString)) < postBytes) {
WiredHome 3:17928786bdb5 665 int n;
WiredHome 3:17928786bdb5 666 offset = postQueryString + len;
WiredHome 3:17928786bdb5 667 n = client.receive(offset, postBytes - len);
WiredHome 3:17928786bdb5 668 if (n >=0) {
WiredHome 3:17928786bdb5 669 offset[n] = '\0';
WiredHome 3:17928786bdb5 670 }
WiredHome 3:17928786bdb5 671 }
WiredHome 3:17928786bdb5 672 if (len >= 0) {
WiredHome 3:17928786bdb5 673 UnescapeString(postQueryString);
WiredHome 3:17928786bdb5 674 ParseParameters(postQueryString);
WiredHome 3:17928786bdb5 675 }
WiredHome 3:17928786bdb5 676 }
WiredHome 3:17928786bdb5 677 } else {
WiredHome 3:17928786bdb5 678 // Simply copy it to the bitbucket
WiredHome 3:17928786bdb5 679 int bytesToDump = postBytes;
WiredHome 8:262583f054f6 680 char * bitbucket = (char *)mymalloc(201);
WiredHome 3:17928786bdb5 681 dblCR += 4;
WiredHome 3:17928786bdb5 682 while (*dblCR && *dblCR <= ' ')
WiredHome 3:17928786bdb5 683 dblCR++;
WiredHome 3:17928786bdb5 684 bytesToDump -= strlen(dblCR);
WiredHome 3:17928786bdb5 685 while (bytesToDump > 0) {
WiredHome 3:17928786bdb5 686 int n = (bytesToDump > 200) ? 200 : bytesToDump;
WiredHome 3:17928786bdb5 687 n = client.receive(bitbucket, n);
WiredHome 3:17928786bdb5 688 bytesToDump -= n;
WiredHome 3:17928786bdb5 689 }
WiredHome 8:262583f054f6 690 myfree(bitbucket);
WiredHome 3:17928786bdb5 691 }
WiredHome 3:17928786bdb5 692 }
WiredHome 3:17928786bdb5 693 }
WiredHome 3:17928786bdb5 694 }
WiredHome 3:17928786bdb5 695 return advanceState;
WiredHome 3:17928786bdb5 696 }
WiredHome 3:17928786bdb5 697
WiredHome 7:99ad7a67f05e 698 void HTTPServer::GetPerformanceData(SW_PerformanceData * p)
WiredHome 7:99ad7a67f05e 699 {
WiredHome 3:17928786bdb5 700 memcpy(p, &perfData, sizeof(perfData));
WiredHome 3:17928786bdb5 701 }
WiredHome 3:17928786bdb5 702
WiredHome 7:99ad7a67f05e 703 int HTTPServer::RecordPerformanceData(SW_PerformanceParam * param, int refTime)
WiredHome 7:99ad7a67f05e 704 {
WiredHome 3:17928786bdb5 705 int t_now = timer.read_us();
WiredHome 3:17928786bdb5 706 param->TotalTime_us += (t_now - refTime);
WiredHome 3:17928786bdb5 707 param->Samples++;
WiredHome 3:17928786bdb5 708 if ((t_now - refTime) > param->MaxTime_us)
WiredHome 3:17928786bdb5 709 param->MaxTime_us = (t_now - refTime);
WiredHome 3:17928786bdb5 710 return t_now;
WiredHome 3:17928786bdb5 711 }
WiredHome 3:17928786bdb5 712
WiredHome 7:99ad7a67f05e 713 void HTTPServer::ResetPerformanceData()
WiredHome 7:99ad7a67f05e 714 {
WiredHome 3:17928786bdb5 715 memset(&perfData, 0, sizeof(perfData));
WiredHome 3:17928786bdb5 716 }
WiredHome 3:17928786bdb5 717
WiredHome 4:f34642902056 718