1 files changed, 281 insertions, 0 deletions

diff --git a/src/lib/internal.c b/src/lib/internal.c
new file mode 100644
index 00000000..d2532c54
--- /dev/null
+++ b/src/lib/internal.c
@@ -0,0 +1,281 @@
+/*
+     This file is part of libmicrohttpd
+     Copyright (C) 2007 Daniel Pittman and Christian Grothoff
+
+     This library is free software; you can redistribute it and/or
+     modify it under the terms of the GNU Lesser General Public
+     License as published by the Free Software Foundation; either
+     version 2.1 of the License, or (at your option) any later version.
+
+     This library is distributed in the hope that it will be useful,
+     but WITHOUT ANY WARRANTY; without even the implied warranty of
+     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+     Lesser General Public License for more details.
+
+     You should have received a copy of the GNU Lesser General Public
+     License along with this library; if not, write to the Free Software
+     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+/**
+ * @file microhttpd/internal.c
+ * @brief  internal shared structures
+ * @author Daniel Pittman
+ * @author Christian Grothoff
+ */
+
+#include "internal.h"
+#include "mhd_str.h"
+
+#ifdef HAVE_MESSAGES
+#if DEBUG_STATES
+/**
+ * State to string dictionary.
+ */
+const char *
+MHD_state_to_string (enum MHD_CONNECTION_STATE state)
+{
+  switch (state)
+    {
+    case MHD_CONNECTION_INIT:
+      return "connection init";
+    case MHD_CONNECTION_URL_RECEIVED:
+      return "connection url received";
+    case MHD_CONNECTION_HEADER_PART_RECEIVED:
+      return "header partially received";
+    case MHD_CONNECTION_HEADERS_RECEIVED:
+      return "headers received";
+    case MHD_CONNECTION_HEADERS_PROCESSED:
+      return "headers processed";
+    case MHD_CONNECTION_CONTINUE_SENDING:
+      return "continue sending";
+    case MHD_CONNECTION_CONTINUE_SENT:
+      return "continue sent";
+    case MHD_CONNECTION_BODY_RECEIVED:
+      return "body received";
+    case MHD_CONNECTION_FOOTER_PART_RECEIVED:
+      return "footer partially received";
+    case MHD_CONNECTION_FOOTERS_RECEIVED:
+      return "footers received";
+    case MHD_CONNECTION_HEADERS_SENDING:
+      return "headers sending";
+    case MHD_CONNECTION_HEADERS_SENT:
+      return "headers sent";
+    case MHD_CONNECTION_NORMAL_BODY_READY:
+      return "normal body ready";
+    case MHD_CONNECTION_NORMAL_BODY_UNREADY:
+      return "normal body unready";
+    case MHD_CONNECTION_CHUNKED_BODY_READY:
+      return "chunked body ready";
+    case MHD_CONNECTION_CHUNKED_BODY_UNREADY:
+      return "chunked body unready";
+    case MHD_CONNECTION_BODY_SENT:
+      return "body sent";
+    case MHD_CONNECTION_FOOTERS_SENDING:
+      return "footers sending";
+    case MHD_CONNECTION_FOOTERS_SENT:
+      return "footers sent";
+    case MHD_CONNECTION_CLOSED:
+      return "closed";
+    default:
+      return "unrecognized connection state";
+    }
+}
+#endif
+#endif
+
+
+#ifdef HAVE_MESSAGES
+/**
+ * fprintf-like helper function for logging debug
+ * messages.
+ */
+void
+MHD_DLOG (const struct MHD_Daemon *daemon,
+          const char *format,
+          ...)
+{
+  va_list va;
+
+  if (0 == (daemon->options & MHD_USE_ERROR_LOG))
+    return;
+  va_start (va, format);
+  daemon->custom_error_log (daemon->custom_error_log_cls,
+                            format,
+                            va);
+  va_end (va);
+}
+#endif
+
+
+/**
+ * Convert all occurrences of '+' to ' '.
+ *
+ * @param arg string that is modified (in place), must be 0-terminated
+ */
+void
+MHD_unescape_plus (char *arg)
+{
+  char *p;
+
+  for (p=strchr (arg, '+'); NULL != p; p = strchr (p + 1, '+'))
+    *p = ' ';
+}
+
+
+/**
+ * Process escape sequences ('%HH') Updates val in place; the
+ * result should be UTF-8 encoded and cannot be larger than the input.
+ * The result must also still be 0-terminated.
+ *
+ * @param val value to unescape (modified in the process)
+ * @return length of the resulting val (strlen(val) maybe
+ *  shorter afterwards due to elimination of escape sequences)
+ */
+size_t
+MHD_http_unescape (char *val)
+{
+  char *rpos = val;
+  char *wpos = val;
+
+  while ('\0' != *rpos)
+    {
+      uint32_t num;
+      switch (*rpos)
+        {
+        case '%':
+          if (2 == MHD_strx_to_uint32_n_ (rpos + 1,
+                                          2,
+                                          &num))
+            {
+              *wpos = (char)((unsigned char) num);
+              wpos++;
+              rpos += 3;
+              break;
+            }
+          /* TODO: add bad sequence handling */
+          /* intentional fall through! */
+        default:
+          *wpos = *rpos;
+          wpos++;
+          rpos++;
+        }
+    }
+  *wpos = '\0'; /* add 0-terminator */
+  return wpos - val; /* = strlen(val) */
+}
+
+
+/**
+ * Parse and unescape the arguments given by the client
+ * as part of the HTTP request URI.
+ *
+ * @param kind header kind to pass to @a cb
+ * @param connection connection to add headers to
+ * @param[in,out] args argument URI string (after "?" in URI),
+ *        clobbered in the process!
+ * @param cb function to call on each key-value pair found
+ * @param[out] num_headers set to the number of headers found
+ * @return #MHD_NO on failure (@a cb returned #MHD_NO),
+ *         #MHD_YES for success (parsing succeeded, @a cb always
+ *                               returned #MHD_YES)
+ */
+int
+MHD_parse_arguments_ (struct MHD_Connection *connection,
+                      enum MHD_ValueKind kind,
+                      char *args,
+                      MHD_ArgumentIterator_ cb,
+                      unsigned int *num_headers)
+{
+  struct MHD_Daemon *daemon = connection->daemon;
+  char *equals;
+  char *amper;
+
+  *num_headers = 0;
+  while ( (NULL != args) &&
+          ('\0' != args[0]) )
+    {
+      equals = strchr (args, '=');
+      amper = strchr (args, '&');
+      if (NULL == amper)
+        {
+          /* last argument */
+          if (NULL == equals)
+            {
+              /* last argument, without '=' */
+              MHD_unescape_plus (args);
+              daemon->unescape_callback (daemon->unescape_callback_cls,
+                                         connection,
+                                         args);
+              if (MHD_YES != cb (connection,
+                                 args,
+                                 NULL,
+                                 kind))
+                return MHD_NO;
+              (*num_headers)++;
+              break;
+            }
+          /* got 'foo=bar' */
+          equals[0] = '\0';
+          equals++;
+          MHD_unescape_plus (args);
+          daemon->unescape_callback (daemon->unescape_callback_cls,
+                                     connection,
+                                     args);
+          MHD_unescape_plus (equals);
+          daemon->unescape_callback (daemon->unescape_callback_cls,
+                                     connection,
+                                     equals);
+          if (MHD_YES != cb (connection,
+                             args,
+                             equals,
+                             kind))
+            return MHD_NO;
+          (*num_headers)++;
+          break;
+        }
+      /* amper is non-NULL here */
+      amper[0] = '\0';
+      amper++;
+      if ( (NULL == equals) ||
+           (equals >= amper) )
+        {
+          /* got 'foo&bar' or 'foo&bar=val', add key 'foo' with NULL for value */
+          MHD_unescape_plus (args);
+          daemon->unescape_callback (daemon->unescape_callback_cls,
+                                     connection,
+                                     args);
+          if (MHD_YES != cb (connection,
+                             args,
+                             NULL,
+                             kind))
+            return MHD_NO;
+          /* continue with 'bar' */
+          (*num_headers)++;
+          args = amper;
+          continue;
+        }
+      /* equals and amper are non-NULL here, and equals < amper,
+         so we got regular 'foo=value&bar...'-kind of argument */
+      equals[0] = '\0';
+      equals++;
+      MHD_unescape_plus (args);
+      daemon->unescape_callback (daemon->unescape_callback_cls,
+                                 connection,
+                                 args);
+      MHD_unescape_plus (equals);
+      daemon->unescape_callback (daemon->unescape_callback_cls,
+                                 connection,
+                                 equals);
+      if (MHD_YES != cb (connection,
+                         args,
+                         equals,
+                         kind))
+        return MHD_NO;
+      (*num_headers)++;
+      args = amper;
+    }
+  return MHD_YES;
+}
+
+/* end of internal.c */