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