WebServer.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil;  c-file-style: "k&r"; c-basic-offset: 2; -*-
   2
   3    Webduino, a simple Arduino web server
   4    Copyright 2009-2012 Ben Combee, Ran Talbott, Christopher Lee, Martin Lormes
   5
   6    Permission is hereby granted, free of charge, to any person obtaining a copy
   7    of this software and associated documentation files (the "Software"), to deal
   8    in the Software without restriction, including without limitation the rights
   9    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10    copies of the Software, and to permit persons to whom the Software is
  11    furnished to do so, subject to the following conditions:
  12
  13    The above copyright notice and this permission notice shall be included in
  14    all copies or substantial portions of the Software.
  15
  16    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22    THE SOFTWARE.
  23 */
  24
  25 #ifndef WEBDUINO_H_
  26 #define WEBDUINO_H_
  27
  28 #include <string.h>
  29 #include <stdlib.h>
  30
  31 #include <EthernetClient.h>
  32 #include <EthernetServer.h>
  33
  34 /********************************************************************
  35  * CONFIGURATION
  36  ********************************************************************/
  37
  38 #define WEBDUINO_VERSION 1007
  39 #define WEBDUINO_VERSION_STRING "1.7"
  40
  41 #if WEBDUINO_SUPRESS_SERVER_HEADER
  42 #define WEBDUINO_SERVER_HEADER ""
  43 #else
  44 #define WEBDUINO_SERVER_HEADER "Server: Webduino/" WEBDUINO_VERSION_STRING CRLF
  45 #endif
  46
  47 // standard END-OF-LINE marker in HTTP
  48 #define CRLF "\r\n"
  49
  50 // If processConnection is called without a buffer, it allocates one
  51 // of 32 bytes
  52 #define WEBDUINO_DEFAULT_REQUEST_LENGTH 32
  53
  54 // How long to wait before considering a connection as dead when
  55 // reading the HTTP request.  Used to avoid DOS attacks.
  56 #ifndef WEBDUINO_READ_TIMEOUT_IN_MS
  57 #define WEBDUINO_READ_TIMEOUT_IN_MS 1000
  58 #endif
  59
  60 #ifndef WEBDUINO_URL_PATH_COMMAND_LENGTH
  61 #define WEBDUINO_URL_PATH_COMMAND_LENGTH 8
  62 #endif
  63
  64 #ifndef WEBDUINO_FAIL_MESSAGE
  65 #define WEBDUINO_FAIL_MESSAGE "<h1>EPIC FAIL</h1>"
  66 #endif
  67
  68 #ifndef WEBDUINO_AUTH_REALM
  69 #define WEBDUINO_AUTH_REALM "Webduino"
  70 #endif // #ifndef WEBDUINO_AUTH_REALM
  71
  72 #ifndef WEBDUINO_AUTH_MESSAGE
  73 #define WEBDUINO_AUTH_MESSAGE "<h1>401 Unauthorized</h1>"
  74 #endif // #ifndef WEBDUINO_AUTH_MESSAGE
  75
  76 #ifndef WEBDUINO_SERVER_ERROR_MESSAGE
  77 #define WEBDUINO_SERVER_ERROR_MESSAGE "<h1>500 Internal Server Error</h1>"
  78 #endif // WEBDUINO_SERVER_ERROR_MESSAGE
  79
  80 #ifndef WEBDUINO_OUTPUT_BUFFER_SIZE
  81 #define WEBDUINO_OUTPUT_BUFFER_SIZE 32
  82 #endif // WEBDUINO_OUTPUT_BUFFER_SIZE
  83
  84 // add '#define WEBDUINO_FAVICON_DATA ""' to your application
  85 // before including WebServer.h to send a null file as the favicon.ico file
  86 // otherwise this defaults to a 16x16 px black diode on blue ground
  87 // (or include your own icon if you like)
  88 #ifndef WEBDUINO_FAVICON_DATA
  89 #define WEBDUINO_FAVICON_DATA { 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x10, \
  90                                 0x10, 0x02, 0x00, 0x01, 0x00, 0x01, 0x00, \
  91                                 0xb0, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, \
  92                                 0x00, 0x28, 0x00, 0x00, 0x00, 0x10, 0x00, \
  93                                 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x01, \
  94                                 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, \
  95                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
  96                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
  97                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
  98                                 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, \
  99                                 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, \
 100                                 0x00, 0xff, 0xff, 0x00, 0x00, 0xcf, 0xbf, \
 101                                 0x00, 0x00, 0xc7, 0xbf, 0x00, 0x00, 0xc3, \
 102                                 0xbf, 0x00, 0x00, 0xc1, 0xbf, 0x00, 0x00, \
 103                                 0xc0, 0xbf, 0x00, 0x00, 0x00, 0x00, 0x00, \
 104                                 0x00, 0xc0, 0xbf, 0x00, 0x00, 0xc1, 0xbf, \
 105                                 0x00, 0x00, 0xc3, 0xbf, 0x00, 0x00, 0xc7, \
 106                                 0xbf, 0x00, 0x00, 0xcf, 0xbf, 0x00, 0x00, \
 107                                 0xff, 0xff, 0x00, 0x00, 0xff, 0xff, 0x00, \
 108                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
 109                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
 110                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
 111                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
 112                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
 113                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
 114                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
 115                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
 116                                 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, \
 117                                 0x00, 0x00 }
 118 #endif // #ifndef WEBDUINO_FAVICON_DATA
 119
 120 // add "#define WEBDUINO_SERIAL_DEBUGGING 1" to your application
 121 // before including WebServer.h to have incoming requests logged to
 122 // the serial port.
 123 #ifndef WEBDUINO_SERIAL_DEBUGGING
 124 #define WEBDUINO_SERIAL_DEBUGGING 0
 125 #endif
 126 #if WEBDUINO_SERIAL_DEBUGGING
 127 #include <HardwareSerial.h>
 128 #endif
 129
 130 // declared in wiring.h
 131 extern "C" unsigned long millis(void);
 132
 133 // declare a static string
 134 #ifdef __AVR__
 135 #define P(name)   static const unsigned char name[] PROGMEM
 136 #else
 137 #define P(name)   static const unsigned char name[]
 138 #endif
 139
 140 // returns the number of elements in the array
 141 #define SIZE(array) (sizeof(array) / sizeof(*array))
 142
 143 #ifdef _VARIANT_ARDUINO_DUE_X_
 144 #define pgm_read_byte(ptr) (unsigned char)(* ptr)
 145 #endif
 146 /********************************************************************
 147  * DECLARATIONS
 148  ********************************************************************/
 149
 150 /* Return codes from nextURLparam.  NOTE: URLPARAM_EOS is returned
 151  * when you call nextURLparam AFTER the last parameter is read.  The
 152  * last actual parameter gets an "OK" return code. */
 153
 154 enum URLPARAM_RESULT { URLPARAM_OK,
 155                        URLPARAM_NAME_OFLO,
 156                        URLPARAM_VALUE_OFLO,
 157                        URLPARAM_BOTH_OFLO,
 158                        URLPARAM_EOS         // No params left
 159 };
 160
 161 class WebServer: public Print
 162 {
 163 public:
 164   // passed to a command to indicate what kind of request was received
 165   enum ConnectionType { INVALID, GET, HEAD, POST, PUT, DELETE, PATCH };
 166
 167   // any commands registered with the web server have to follow
 168   // this prototype.
 169   // url_tail contains the part of the URL that wasn't matched against
 170   //          the registered command table.
 171   // tail_complete is true if the complete URL fit in url_tail,  false if
 172   //          part of it was lost because the buffer was too small.
 173   typedef void Command(WebServer &server, ConnectionType type,
 174                        char *url_tail, bool tail_complete);
 175
 176   // Prototype for the optional function which consumes the URL path itself.
 177   // url_path contains pointers to the seperate parts of the URL path where '/'
 178   //          was used as the delimiter.
 179   typedef void UrlPathCommand(WebServer &server, ConnectionType type,
 180                               char **url_path, char *url_tail,
 181                               bool tail_complete);
 182
 183   // constructor for webserver object
 184   WebServer(const char *urlPrefix = "", int port = 80);
 185
 186   // start listening for connections
 187   void begin();
 188
 189   // check for an incoming connection, and if it exists, process it
 190   // by reading its request and calling the appropriate command
 191   // handler.  This version is for compatibility with apps written for
 192   // version 1.1,  and allocates the URL "tail" buffer internally.
 193   void processConnection();
 194
 195   // check for an incoming connection, and if it exists, process it
 196   // by reading its request and calling the appropriate command
 197   // handler.  This version saves the "tail" of the URL in buff.
 198   void processConnection(char *buff, int *bufflen);
 199
 200   // set command that's run when you access the root of the server
 201   void setDefaultCommand(Command *cmd);
 202
 203   // set command run for undefined pages
 204   void setFailureCommand(Command *cmd);
 205
 206   // add a new command to be run at the URL specified by verb
 207   void addCommand(const char *verb, Command *cmd);
 208
 209   // Set command that's run if default command or URL specified commands do
 210   // not run, uses extra url_path parameter to allow resolving the URL in the
 211   // function.
 212   void setUrlPathCommand(UrlPathCommand *cmd);
 213
 214   // utility function to output CRLF pair
 215   void printCRLF();
 216
 217   // output a string stored in program memory, usually one defined
 218   // with the P macro
 219   void printP(const unsigned char *str);
 220
 221   // inline overload for printP to handle signed char strings
 222   void printP(const char *str) { printP((unsigned char*)str); }
 223
 224   // output raw data stored in program memory
 225   void writeP(const unsigned char *data, size_t length);
 226
 227   // output HTML for a radio button
 228   void radioButton(const char *name, const char *val,
 229                    const char *label, bool selected);
 230
 231   // output HTML for a checkbox
 232   void checkBox(const char *name, const char *val,
 233                 const char *label, bool selected);
 234
 235   // returns next character or -1 if we're at end-of-stream
 236   int read();
 237
 238   // put a character that's been read back into the input pool
 239   void push(int ch);
 240
 241   // returns true if the string is next in the stream.  Doesn't
 242   // consume any character if false, so can be used to try out
 243   // different expected values.
 244   bool expect(const char *expectedStr);
 245
 246   // returns true if a number, with possible whitespace in front, was
 247   // read from the server stream.  number will be set with the new
 248   // value or 0 if nothing was read.
 249   bool readInt(int &number);
 250
 251   // reads a header value, stripped of possible whitespace in front,
 252   // from the server stream
 253   void readHeader(char *value, int valueLen);
 254
 255   // Read the next keyword parameter from the socket.  Assumes that other
 256   // code has already skipped over the headers,  and the next thing to
 257   // be read will be the start of a keyword.
 258   //
 259   // returns true if we're not at end-of-stream
 260   bool readPOSTparam(char *name, int nameLen, char *value, int valueLen);
 261
 262   // Read the next keyword parameter from the buffer filled by getRequest.
 263   //
 264   // returns 0 if everything weent okay,  non-zero if not
 265   // (see the typedef for codes)
 266   URLPARAM_RESULT nextURLparam(char **tail, char *name, int nameLen,
 267                                char *value, int valueLen);
 268
 269   // compare string against credentials in current request
 270   //
 271   // authCredentials must be Base64 encoded outside of Webduino
 272   // (I wanted to be easy on the resources)
 273   //
 274   // returns true if strings match, false otherwise
 275   bool checkCredentials(const char authCredentials[45]);
 276
 277   // output headers and a message indicating a server error
 278   void httpFail();
 279
 280   // output headers and a message indicating "401 Unauthorized"
 281   void httpUnauthorized();
 282
 283   // output headers and a message indicating "500 Internal Server Error"
 284   void httpServerError();
 285
 286   // output headers indicating "204 No Content" and no further message
 287   void httpNoContent();
 288
 289   // output standard headers indicating "200 Success".  You can change the
 290   // type of the data you're outputting or also add extra headers like
 291   // "Refresh: 1".  Extra headers should each be terminated with CRLF.
 292   void httpSuccess(const char *contentType = "text/html; charset=utf-8",
 293                    const char *extraHeaders = NULL);
 294
 295   // used with POST to output a redirect to another URL.  This is
 296   // preferable to outputting HTML from a post because you can then
 297   // refresh the page without getting a "resubmit form" dialog.
 298   void httpSeeOther(const char *otherURL);
 299
 300   // implementation of write used to implement Print interface
 301   virtual size_t write(uint8_t);
 302
 303   // tells if there is anything to process
 304   uint8_t available();
 305
 306 private:
 307   EthernetServer m_server;
 308   EthernetClient m_client;
 309   const char *m_urlPrefix;
 310
 311   unsigned char m_pushback[32];
 312   unsigned char m_pushbackDepth;
 313
 314   int m_contentLength;
 315   char m_authCredentials[51];
 316   bool m_readingContent;
 317
 318   Command *m_failureCmd;
 319   Command *m_defaultCmd;
 320   struct CommandMap
 321   {
 322     const char *verb;
 323     Command *cmd;
 324   } m_commands[8];
 325   unsigned char m_cmdCount;
 326   UrlPathCommand *m_urlPathCmd;
 327
 328   uint8_t m_buffer[WEBDUINO_OUTPUT_BUFFER_SIZE];
 329   uint8_t m_bufFill;
 330
 331   void reset();
 332   void getRequest(WebServer::ConnectionType &type, char *request, int *length);
 333   bool dispatchCommand(ConnectionType requestType, char *verb,
 334                        bool tail_complete);
 335   void processHeaders();
 336   void outputCheckboxOrRadio(const char *element, const char *name,
 337                              const char *val, const char *label,
 338                              bool selected);
 339
 340   static void defaultFailCmd(WebServer &server, ConnectionType type,
 341                              char *url_tail, bool tail_complete);
 342   void noRobots(ConnectionType type);
 343   void favicon(ConnectionType type);
 344   void flushBuf();
 345 };
 346
 347 /* define this macro if you want to include the header in a sketch source
 348    file but not define any of the implementation. This is useful if
 349    multiple source files are using the Webduino class. */
 350 #ifndef WEBDUINO_NO_IMPLEMENTATION
 351
 352 /********************************************************************
 353  * IMPLEMENTATION
 354  ********************************************************************/
 355
 356 WebServer::WebServer(const char *urlPrefix, int port) :
 357   m_server(port),
 358   m_client(MAX_SOCK_NUM),
 359   m_urlPrefix(urlPrefix),
 360   m_pushbackDepth(0),
 361   m_contentLength(0),
 362   m_failureCmd(&defaultFailCmd),
 363   m_defaultCmd(&defaultFailCmd),
 364   m_cmdCount(0),
 365   m_urlPathCmd(NULL),
 366   m_bufFill(0)
 367 {
 368 }
 369
 370 void WebServer::begin()
 371 {
 372   m_server.begin();
 373 }
 374
 375 void WebServer::setDefaultCommand(Command *cmd)
 376 {
 377   m_defaultCmd = cmd;
 378 }
 379
 380 void WebServer::setFailureCommand(Command *cmd)
 381 {
 382   m_failureCmd = cmd;
 383 }
 384
 385 void WebServer::addCommand(const char *verb, Command *cmd)
 386 {
 387   if (m_cmdCount < SIZE(m_commands))
 388   {
 389     m_commands[m_cmdCount].verb = verb;
 390     m_commands[m_cmdCount++].cmd = cmd;
 391   }
 392 }
 393
 394 void WebServer::setUrlPathCommand(UrlPathCommand *cmd)
 395 {
 396   m_urlPathCmd = cmd;
 397 }
 398
 399 size_t WebServer::write(uint8_t ch)
 400 {
 401   m_buffer[m_bufFill++] = ch;
 402
 403   if(m_bufFill == sizeof(m_buffer))
 404   {
 405     m_client.write(m_buffer, sizeof(m_buffer));
 406     m_bufFill = 0;
 407   }
 408
 409   return sizeof(ch);
 410 }
 411
 412 void WebServer::flushBuf()
 413 {
 414   if(m_bufFill > 0)
 415   {
 416     m_client.write(m_buffer, m_bufFill);
 417     m_bufFill = 0;
 418   }
 419 }
 420
 421 void WebServer::writeP(const unsigned char *data, size_t length)
 422 {
 423   // copy data out of program memory into local storage
 424
 425   while (length--)
 426   {
 427     write(pgm_read_byte(data++));
 428   }
 429 }
 430
 431 void WebServer::printP(const unsigned char *str)
 432 {
 433   // copy data out of program memory into local storage
 434
 435   while (uint8_t value = pgm_read_byte(str++))
 436   {
 437     write(value);
 438   }
 439 }
 440
 441 void WebServer::printCRLF()
 442 {
 443   print(CRLF);
 444 }
 445
 446 bool WebServer::dispatchCommand(ConnectionType requestType, char *verb,
 447         bool tail_complete)
 448 {
 449   // if there is no URL, i.e. we have a prefix and it's requested without a
 450   // trailing slash or if the URL is just the slash
 451   if ((verb[0] == 0) || ((verb[0] == '/') && (verb[1] == 0)))
 452   {
 453     m_defaultCmd(*this, requestType, (char*)"", tail_complete);
 454     return true;
 455   }
 456   // if the URL is just a slash followed by a question mark
 457   // we're looking at the default command with GET parameters passed
 458   if ((verb[0] == '/') && (verb[1] == '?'))
 459   {
 460     verb+=2; // skip over the "/?" part of the url
 461     m_defaultCmd(*this, requestType, verb, tail_complete);
 462     return true;
 463   }
 464   // We now know that the URL contains at least one character.  And,
 465   // if the first character is a slash,  there's more after it.
 466   if (verb[0] == '/')
 467   {
 468     unsigned char i;
 469     char *qm_loc;
 470     unsigned int verb_len;
 471     int qm_offset;
 472     // Skip over the leading "/",  because it makes the code more
 473     // efficient and easier to understand.
 474     verb++;
 475     // Look for a "?" separating the filename part of the URL from the
 476     // parameters.  If it's not there, compare to the whole URL.
 477     qm_loc = strchr(verb, '?');
 478     verb_len = (qm_loc == NULL) ? strlen(verb) : (qm_loc - verb);
 479     qm_offset = (qm_loc == NULL) ? 0 : 1;
 480     for (i = 0; i < m_cmdCount; ++i)
 481     {
 482       if ((verb_len == strlen(m_commands[i].verb))
 483           && (strncmp(verb, m_commands[i].verb, verb_len) == 0))
 484       {
 485         // Skip over the "verb" part of the URL (and the question
 486         // mark, if present) when passing it to the "action" routine
 487         m_commands[i].cmd(*this, requestType,
 488         verb + verb_len + qm_offset,
 489         tail_complete);
 490         return true;
 491       }
 492     }
 493     // Check if UrlPathCommand is assigned.
 494     if (m_urlPathCmd != NULL)
 495     {
 496       // Initialize with null bytes, so number of parts can be determined.
 497       char *url_path[WEBDUINO_URL_PATH_COMMAND_LENGTH] = {0};
 498       int part = 0;
 499
 500       // URL path should be terminated with null byte.
 501       *(verb + verb_len) = 0;
 502
 503       // First URL path part is at the start of verb.
 504       url_path[part++] = verb;
 505       // Replace all slashes ('/') with a null byte so every part of the URL
 506       // path is a seperate string. Add every char following a '/' as a new
 507       // part of the URL, even if that char is a '/' (which will be replaced
 508       // with a null byte).
 509       for (char * p = verb; p < verb + verb_len; p++)
 510       {
 511         if (*p == '/')
 512         {
 513           *p = 0;
 514           url_path[part++] = p + 1;
 515           // Don't try to assign out of array bounds.
 516           if (part == WEBDUINO_URL_PATH_COMMAND_LENGTH) break;
 517         }
 518       }
 519       m_urlPathCmd(*this, requestType, url_path,
 520                    verb + verb_len + qm_offset, tail_complete);
 521       return true;
 522     }
 523   }
 524   return false;
 525 }
 526
 527 // processConnection with a default buffer
 528 void WebServer::processConnection()
 529 {
 530   char request[WEBDUINO_DEFAULT_REQUEST_LENGTH];
 531   int  request_len = WEBDUINO_DEFAULT_REQUEST_LENGTH;
 532   processConnection(request, &request_len);
 533 }
 534
 535 void WebServer::processConnection(char *buff, int *bufflen)
 536 {
 537   int urlPrefixLen = strlen(m_urlPrefix);
 538
 539   m_client = m_server.available();
 540
 541   if (m_client) {
 542     m_readingContent = false;
 543     buff[0] = 0;
 544     ConnectionType requestType = INVALID;
 545 #if WEBDUINO_SERIAL_DEBUGGING > 1
 546     Serial.println("*** checking request ***");
 547 #endif
 548     getRequest(requestType, buff, bufflen);
 549 #if WEBDUINO_SERIAL_DEBUGGING > 1
 550     Serial.print("*** requestType = ");
 551     Serial.print((int)requestType);
 552     Serial.print(", request = \"");
 553     Serial.print(buff);
 554     Serial.println("\" ***");
 555 #endif
 556
 557     // don't even look further at invalid requests.
 558     // this is done to prevent Webduino from hanging
 559     // - when there are illegal requests,
 560     // - when someone contacts it through telnet rather than proper HTTP,
 561     // - etc.
 562     if (requestType != INVALID)
 563     {
 564       processHeaders();
 565 #if WEBDUINO_SERIAL_DEBUGGING > 1
 566       Serial.println("*** headers complete ***");
 567 #endif
 568
 569       if (strcmp(buff, "/robots.txt") == 0)
 570       {
 571         noRobots(requestType);
 572       }
 573       else if (strcmp(buff, "/favicon.ico") == 0)
 574       {
 575         favicon(requestType);
 576       }
 577     }
 578     // Only try to dispatch command if request type and prefix are correct.
 579     // Fix by quarencia.
 580     if (requestType == INVALID ||
 581         strncmp(buff, m_urlPrefix, urlPrefixLen) != 0)
 582     {
 583       m_failureCmd(*this, requestType, buff, (*bufflen) >= 0);
 584     }
 585     else if (!dispatchCommand(requestType, buff + urlPrefixLen,
 586              (*bufflen) >= 0))
 587     {
 588       m_failureCmd(*this, requestType, buff, (*bufflen) >= 0);
 589     }
 590
 591     flushBuf();
 592
 593 #if WEBDUINO_SERIAL_DEBUGGING > 1
 594     Serial.println("*** stopping connection ***");
 595 #endif
 596     reset();
 597   }
 598 }
 599
 600 bool WebServer::checkCredentials(const char authCredentials[45])
 601 {
 602   char basic[7] = "Basic ";
 603   if((0 == strncmp(m_authCredentials,basic,6)) &&
 604      (0 == strcmp(authCredentials, m_authCredentials + 6))) return true;
 605   return false;
 606 }
 607
 608 void WebServer::httpFail()
 609 {
 610   P(failMsg) =
 611     "HTTP/1.0 400 Bad Request" CRLF
 612     WEBDUINO_SERVER_HEADER
 613     "Content-Type: text/html" CRLF
 614     CRLF
 615     WEBDUINO_FAIL_MESSAGE;
 616
 617   printP(failMsg);
 618 }
 619
 620 void WebServer::defaultFailCmd(WebServer &server,
 621                                WebServer::ConnectionType type,
 622                                char *url_tail,
 623                                bool tail_complete)
 624 {
 625   server.httpFail();
 626 }
 627
 628 void WebServer::noRobots(ConnectionType type)
 629 {
 630   httpSuccess("text/plain");
 631   if (type != HEAD)
 632   {
 633     P(allowNoneMsg) = "User-agent: *" CRLF "Disallow: /" CRLF;
 634     printP(allowNoneMsg);
 635   }
 636 }
 637
 638 void WebServer::favicon(ConnectionType type)
 639 {
 640   httpSuccess("image/x-icon","Cache-Control: max-age=31536000\r\n");
 641   if (type != HEAD)
 642   {
 643     P(faviconIco) = WEBDUINO_FAVICON_DATA;
 644     writeP(faviconIco, sizeof(faviconIco));
 645   }
 646 }
 647
 648 void WebServer::httpUnauthorized()
 649 {
 650   P(failMsg) =
 651     "HTTP/1.0 401 Authorization Required" CRLF
 652     WEBDUINO_SERVER_HEADER
 653     "Content-Type: text/html" CRLF
 654     "WWW-Authenticate: Basic realm=\"" WEBDUINO_AUTH_REALM "\"" CRLF
 655     CRLF
 656     WEBDUINO_AUTH_MESSAGE;
 657
 658   printP(failMsg);
 659 }
 660
 661 void WebServer::httpServerError()
 662 {
 663   P(failMsg) =
 664     "HTTP/1.0 500 Internal Server Error" CRLF
 665     WEBDUINO_SERVER_HEADER
 666     "Content-Type: text/html" CRLF
 667     CRLF
 668     WEBDUINO_SERVER_ERROR_MESSAGE;
 669
 670   printP(failMsg);
 671 }
 672
 673 void WebServer::httpNoContent()
 674 {
 675   P(noContentMsg) =
 676     "HTTP/1.0 204 NO CONTENT" CRLF
 677     WEBDUINO_SERVER_HEADER
 678     CRLF
 679     CRLF;
 680
 681   printP(noContentMsg);
 682 }
 683
 684 void WebServer::httpSuccess(const char *contentType,
 685                             const char *extraHeaders)
 686 {
 687   P(successMsg1) =
 688     "HTTP/1.0 200 OK" CRLF
 689     WEBDUINO_SERVER_HEADER
 690     "Access-Control-Allow-Origin: *" CRLF
 691     "Content-Type: ";
 692
 693   printP(successMsg1);
 694   print(contentType);
 695   printCRLF();
 696   if (extraHeaders)
 697     print(extraHeaders);
 698   printCRLF();
 699 }
 700
 701 void WebServer::httpSeeOther(const char *otherURL)
 702 {
 703   P(seeOtherMsg) =
 704     "HTTP/1.0 303 See Other" CRLF
 705     WEBDUINO_SERVER_HEADER
 706     "Location: ";
 707
 708   printP(seeOtherMsg);
 709   print(otherURL);
 710   printCRLF();
 711   printCRLF();
 712 }
 713
 714 int WebServer::read()
 715 {
 716   if (!m_client)
 717     return -1;
 718
 719   if (m_pushbackDepth == 0)
 720   {
 721     unsigned long timeoutTime = millis() + WEBDUINO_READ_TIMEOUT_IN_MS;
 722
 723     while (m_client.connected())
 724     {
 725       // stop reading the socket early if we get to content-length
 726       // characters in the POST.  This is because some clients leave
 727       // the socket open because they assume HTTP keep-alive.
 728       if (m_readingContent)
 729       {
 730         if (m_contentLength == 0)
 731         {
 732 #if WEBDUINO_SERIAL_DEBUGGING > 1
 733           Serial.println("\n*** End of content, terminating connection");
 734 #endif
 735           return -1;
 736         }
 737       }
 738
 739       int ch = m_client.read();
 740
 741       // if we get a character, return it, otherwise continue in while
 742       // loop, checking connection status
 743       if (ch != -1)
 744       {
 745         // count character against content-length
 746         if (m_readingContent)
 747         {
 748           --m_contentLength;
 749         }
 750
 751 #if WEBDUINO_SERIAL_DEBUGGING
 752         if (ch == '\r')
 753           Serial.print("<CR>");
 754         else if (ch == '\n')
 755           Serial.println("<LF>");
 756         else
 757           Serial.print((char)ch);
 758 #endif
 759         return ch;
 760       }
 761       else
 762       {
 763         unsigned long now = millis();
 764         if (now > timeoutTime)
 765         {
 766           // connection timed out, destroy client, return EOF
 767 #if WEBDUINO_SERIAL_DEBUGGING
 768           Serial.println("*** Connection timed out");
 769 #endif
 770           reset();
 771           return -1;
 772         }
 773       }
 774     }
 775
 776     // connection lost, return EOF
 777 #if WEBDUINO_SERIAL_DEBUGGING
 778     Serial.println("*** Connection lost");
 779 #endif
 780     return -1;
 781   }
 782   else
 783     return m_pushback[--m_pushbackDepth];
 784 }
 785
 786 void WebServer::push(int ch)
 787 {
 788   // don't allow pushing EOF
 789   if (ch == -1)
 790     return;
 791
 792   m_pushback[m_pushbackDepth++] = ch;
 793   // can't raise error here, so just replace last char over and over
 794   if (m_pushbackDepth == SIZE(m_pushback))
 795     m_pushbackDepth = SIZE(m_pushback) - 1;
 796 }
 797
 798 void WebServer::reset()
 799 {
 800   m_pushbackDepth = 0;
 801   m_client.flush();
 802   m_client.stop();
 803 }
 804
 805 bool WebServer::expect(const char *str)
 806 {
 807   const char *curr = str;
 808   while (*curr != 0)
 809   {
 810     int ch = read();
 811     if (ch != *curr++)
 812     {
 813       // push back ch and the characters we accepted
 814       push(ch);
 815       while (--curr != str)
 816         push(curr[-1]);
 817       return false;
 818     }
 819   }
 820   return true;
 821 }
 822
 823 bool WebServer::readInt(int &number)
 824 {
 825   bool negate = false;
 826   bool gotNumber = false;
 827   int ch;
 828   number = 0;
 829
 830   // absorb whitespace
 831   do
 832   {
 833     ch = read();
 834   } while (ch == ' ' || ch == '\t');
 835
 836   // check for leading minus sign
 837   if (ch == '-')
 838   {
 839     negate = true;
 840     ch = read();
 841   }
 842
 843   // read digits to update number, exit when we find non-digit
 844   while (ch >= '0' && ch <= '9')
 845   {
 846     gotNumber = true;
 847     number = number * 10 + ch - '0';
 848     ch = read();
 849   }
 850
 851   push(ch);
 852   if (negate)
 853     number = -number;
 854   return gotNumber;
 855 }
 856
 857 void WebServer::readHeader(char *value, int valueLen)
 858 {
 859   int ch;
 860   memset(value, 0, valueLen);
 861   --valueLen;
 862
 863   // absorb whitespace
 864   do
 865   {
 866     ch = read();
 867   } while (ch == ' ' || ch == '\t');
 868
 869   // read rest of line
 870   do
 871   {
 872     if (valueLen > 1)
 873     {
 874       *value++=ch;
 875       --valueLen;
 876     }
 877     ch = read();
 878   } while (ch != '\r');
 879   push(ch);
 880 }
 881
 882 bool WebServer::readPOSTparam(char *name, int nameLen,
 883                               char *value, int valueLen)
 884 {
 885   // assume name is at current place in stream
 886   int ch;
 887   // to not to miss the last parameter
 888   bool foundSomething = false;
 889
 890   // clear out name and value so they'll be NUL terminated
 891   memset(name, 0, nameLen);
 892   memset(value, 0, valueLen);
 893
 894   // decrement length so we don't write into NUL terminator
 895   --nameLen;
 896   --valueLen;
 897
 898   while ((ch = read()) != -1)
 899   {
 900     foundSomething = true;
 901     if (ch == '+')
 902     {
 903       ch = ' ';
 904     }
 905     else if (ch == '=')
 906     {
 907       /* that's end of name, so switch to storing in value */
 908       nameLen = 0;
 909       continue;
 910     }
 911     else if (ch == '&')
 912     {
 913       /* that's end of pair, go away */
 914       return true;
 915     }
 916     else if (ch == '%')
 917     {
 918       /* handle URL encoded characters by converting back to original form */
 919       int ch1 = read();
 920       int ch2 = read();
 921       if (ch1 == -1 || ch2 == -1)
 922         return false;
 923       char hex[3] = { ch1, ch2, 0 };
 924       ch = strtoul(hex, NULL, 16);
 925     }
 926
 927     // output the new character into the appropriate buffer or drop it if
 928     // there's no room in either one.  This code will malfunction in the
 929     // case where the parameter name is too long to fit into the name buffer,
 930     // but in that case, it will just overflow into the value buffer so
 931     // there's no harm.
 932     if (nameLen > 0)
 933     {
 934       *name++ = ch;
 935       --nameLen;
 936     }
 937     else if (valueLen > 0)
 938     {
 939       *value++ = ch;
 940       --valueLen;
 941     }
 942   }
 943
 944   if (foundSomething)
 945   {
 946     // if we get here, we have one last parameter to serve
 947     return true;
 948   }
 949   else
 950   {
 951     // if we get here, we hit the end-of-file, so POST is over and there
 952     // are no more parameters
 953     return false;
 954   }
 955 }
 956
 957 /* Retrieve a parameter that was encoded as part of the URL, stored in
 958  * the buffer pointed to by *tail.  tail is updated to point just past
 959  * the last character read from the buffer. */
 960 URLPARAM_RESULT WebServer::nextURLparam(char **tail, char *name, int nameLen,
 961                                         char *value, int valueLen)
 962 {
 963   // assume name is at current place in stream
 964   char ch, hex[3];
 965   URLPARAM_RESULT result = URLPARAM_OK;
 966   char *s = *tail;
 967   bool keep_scanning = true;
 968   bool need_value = true;
 969
 970   // clear out name and value so they'll be NUL terminated
 971   memset(name, 0, nameLen);
 972   memset(value, 0, valueLen);
 973
 974   if (*s == 0)
 975     return URLPARAM_EOS;
 976   // Read the keyword name
 977   while (keep_scanning)
 978   {
 979     ch = *s++;
 980     switch (ch)
 981     {
 982     case 0:
 983       s--;  // Back up to point to terminating NUL
 984       // Fall through to "stop the scan" code
 985     case '&':
 986       /* that's end of pair, go away */
 987       keep_scanning = false;
 988       need_value = false;
 989       break;
 990     case '+':
 991       ch = ' ';
 992       break;
 993     case '%':
 994       /* handle URL encoded characters by converting back
 995        * to original form */
 996       if ((hex[0] = *s++) == 0)
 997       {
 998         s--;        // Back up to NUL
 999         keep_scanning = false;
1000         need_value = false;
1001       }
1002       else
1003       {
1004         if ((hex[1] = *s++) == 0)
1005         {
1006           s--;  // Back up to NUL
1007           keep_scanning = false;
1008           need_value = false;
1009         }
1010         else
1011         {
1012           hex[2] = 0;
1013           ch = strtoul(hex, NULL, 16);
1014         }
1015       }
1016       break;
1017     case '=':
1018       /* that's end of name, so switch to storing in value */
1019       keep_scanning = false;
1020       break;
1021     }
1022
1023
1024     // check against 1 so we don't overwrite the final NUL
1025     if (keep_scanning && (nameLen > 1))
1026     {
1027       *name++ = ch;
1028       --nameLen;
1029     }
1030     else if(keep_scanning)
1031       result = URLPARAM_NAME_OFLO;
1032   }
1033
1034   if (need_value && (*s != 0))
1035   {
1036     keep_scanning = true;
1037     while (keep_scanning)
1038     {
1039       ch = *s++;
1040       switch (ch)
1041       {
1042       case 0:
1043         s--;  // Back up to point to terminating NUL
1044               // Fall through to "stop the scan" code
1045       case '&':
1046         /* that's end of pair, go away */
1047         keep_scanning = false;
1048         need_value = false;
1049         break;
1050       case '+':
1051         ch = ' ';
1052         break;
1053       case '%':
1054         /* handle URL encoded characters by converting back to original form */
1055         if ((hex[0] = *s++) == 0)
1056         {
1057           s--;  // Back up to NUL
1058           keep_scanning = false;
1059           need_value = false;
1060         }
1061         else
1062         {
1063           if ((hex[1] = *s++) == 0)
1064           {
1065             s--;  // Back up to NUL
1066             keep_scanning = false;
1067             need_value = false;
1068           }
1069           else
1070           {
1071             hex[2] = 0;
1072             ch = strtoul(hex, NULL, 16);
1073           }
1074
1075         }
1076         break;
1077       }
1078
1079
1080       // check against 1 so we don't overwrite the final NUL
1081       if (keep_scanning && (valueLen > 1))
1082       {
1083         *value++ = ch;
1084         --valueLen;
1085       }
1086       else if(keep_scanning)
1087         result = (result == URLPARAM_OK) ?
1088           URLPARAM_VALUE_OFLO :
1089           URLPARAM_BOTH_OFLO;
1090     }
1091   }
1092   *tail = s;
1093   return result;
1094 }
1095
1096
1097
1098 // Read and parse the first line of the request header.
1099 // The "command" (GET/HEAD/POST) is translated into a numeric value in type.
1100 // The URL is stored in request,  up to the length passed in length
1101 // NOTE 1: length must include one byte for the terminating NUL.
1102 // NOTE 2: request is NOT checked for NULL,  nor length for a value < 1.
1103 // Reading stops when the code encounters a space, CR, or LF.  If the HTTP
1104 // version was supplied by the client,  it will still be waiting in the input
1105 // stream when we exit.
1106 //
1107 // On return, length contains the amount of space left in request.  If it's
1108 // less than 0,  the URL was longer than the buffer,  and part of it had to
1109 // be discarded.
1110
1111 void WebServer::getRequest(WebServer::ConnectionType &type,
1112                            char *request, int *length)
1113 {
1114   --*length; // save room for NUL
1115
1116   type = INVALID;
1117
1118   // store the HTTP method line of the request
1119   if (expect("GET "))
1120     type = GET;
1121   else if (expect("HEAD "))
1122     type = HEAD;
1123   else if (expect("POST "))
1124     type = POST;
1125   else if (expect("PUT "))
1126     type = PUT;
1127   else if (expect("DELETE "))
1128     type = DELETE;
1129   else if (expect("PATCH "))
1130     type = PATCH;
1131
1132   // if it doesn't start with any of those, we have an unknown method
1133   // so just get out of here
1134   else
1135     return;
1136
1137   int ch;
1138   while ((ch = read()) != -1)
1139   {
1140     // stop storing at first space or end of line
1141     if (ch == ' ' || ch == '\n' || ch == '\r')
1142     {
1143       break;
1144     }
1145     if (*length > 0)
1146     {
1147       *request = ch;
1148       ++request;
1149     }
1150     --*length;
1151   }
1152   // NUL terminate
1153   *request = 0;
1154 }
1155
1156 void WebServer::processHeaders()
1157 {
1158   // look for three things: the Content-Length header, the Authorization
1159   // header, and the double-CRLF that ends the headers.
1160
1161   // empty the m_authCredentials before every run of this function.
1162   // otherwise users who don't send an Authorization header would be treated
1163   // like the last user who tried to authenticate (possibly successful)
1164   m_authCredentials[0]=0;
1165
1166   while (1)
1167   {
1168     if (expect("Content-Length:"))
1169     {
1170       readInt(m_contentLength);
1171 #if WEBDUINO_SERIAL_DEBUGGING > 1
1172       Serial.print("\n*** got Content-Length of ");
1173       Serial.print(m_contentLength);
1174       Serial.print(" ***");
1175 #endif
1176       continue;
1177     }
1178
1179     if (expect("Authorization:"))
1180     {
1181       readHeader(m_authCredentials,51);
1182 #if WEBDUINO_SERIAL_DEBUGGING > 1
1183       Serial.print("\n*** got Authorization: of ");
1184       Serial.print(m_authCredentials);
1185       Serial.print(" ***");
1186 #endif
1187       continue;
1188     }
1189
1190     if (expect(CRLF CRLF))
1191     {
1192       m_readingContent = true;
1193       return;
1194     }
1195
1196     // no expect checks hit, so just absorb a character and try again
1197     if (read() == -1)
1198     {
1199       return;
1200     }
1201   }
1202 }
1203
1204 void WebServer::outputCheckboxOrRadio(const char *element, const char *name,
1205                                       const char *val, const char *label,
1206                                       bool selected)
1207 {
1208   P(cbPart1a) = "<label><input type='";
1209   P(cbPart1b) = "' name='";
1210   P(cbPart2) = "' value='";
1211   P(cbPart3) = "' ";
1212   P(cbChecked) = "checked ";
1213   P(cbPart4) = "/> ";
1214   P(cbPart5) = "</label>";
1215
1216   printP(cbPart1a);
1217   print(element);
1218   printP(cbPart1b);
1219   print(name);
1220   printP(cbPart2);
1221   print(val);
1222   printP(cbPart3);
1223   if (selected)
1224     printP(cbChecked);
1225   printP(cbPart4);
1226   print(label);
1227   printP(cbPart5);
1228 }
1229
1230 void WebServer::checkBox(const char *name, const char *val,
1231                          const char *label, bool selected)
1232 {
1233   outputCheckboxOrRadio("checkbox", name, val, label, selected);
1234 }
1235
1236 void WebServer::radioButton(const char *name, const char *val,
1237                             const char *label, bool selected)
1238 {
1239   outputCheckboxOrRadio("radio", name, val, label, selected);
1240 }
1241
1242 uint8_t WebServer::available(){
1243   return m_server.available();
1244 }
1245
1246 #endif // WEBDUINO_NO_IMPLEMENTATION
1247
1248 #endif // WEBDUINO_H_