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@14:19c5f6151319, 2013-08-12 (annotated)

Committer:
WiredHome
Date:
Mon Aug 12 23:03:25 2013 +0000
Revision:
14:19c5f6151319
Parent:
13:8975d7928678
Child:
16:6ebacf2946d8
Refactor the base64 encoder and decoder.; Refactor the http server code to simplify the parsing of the header.;

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