civetweb/src/CivetServer.cpp

/*
 * Copyright (c) 2013 No Face Press, LLC
 * License http://opensource.org/licenses/mit-license.php MIT License
 */

#include "CivetServer.h"

#include <stdlib.h>
#include <string.h>
#include <assert.h>

#ifndef UNUSED_PARAMETER
 #define UNUSED_PARAMETER(x) (void)(x)
#endif

bool CivetHandler::handleGet(CivetServer *server, struct mg_connection *conn) {
    UNUSED_PARAMETER(server);
    UNUSED_PARAMETER(conn);
    return false;
}

bool CivetHandler::handlePost(CivetServer *server, struct mg_connection *conn) {
    UNUSED_PARAMETER(server);
    UNUSED_PARAMETER(conn);
    return false;
}

bool CivetHandler::handlePut(CivetServer *server, struct mg_connection *conn) {
    UNUSED_PARAMETER(server);
    UNUSED_PARAMETER(conn);
    return false;
}

bool CivetHandler::handleDelete(CivetServer *server, struct mg_connection *conn) {
    UNUSED_PARAMETER(server);
    UNUSED_PARAMETER(conn);
    return false;
}

int CivetServer::requestHandler(struct mg_connection *conn, void *cbdata) {
    struct mg_request_info *request_info = mg_get_request_info(conn);
    CivetServer *me = (CivetServer*) (request_info->user_data);
    CivetHandler *handler = (CivetHandler *)cbdata;

    if (handler) {
        if (strcmp(request_info->request_method, "GET") == 0) {
            return handler->handleGet(me, conn) ? 1 : 0;
        } else if (strcmp(request_info->request_method, "POST") == 0) {
            return handler->handlePost(me, conn) ? 1 : 0;
        } else if (strcmp(request_info->request_method, "PUT") == 0) {
            return !handler->handlePut(me, conn) ? 1 : 0;
        } else if (strcmp(request_info->request_method, "DELETE") == 0) {
            return !handler->handleDelete(me, conn) ? 1 : 0;
        }
    }

    return 0; // No handler found

}

CivetServer::CivetServer(const char **options,
        const struct mg_callbacks *_callbacks) :
        context(0) {


    if (_callbacks) {
        context = mg_start(_callbacks, this, options);
    } else {
        struct mg_callbacks callbacks;
        memset(&callbacks, 0, sizeof(callbacks));
        context = mg_start(&callbacks, this, options);
    }
}

CivetServer::~CivetServer() {
    close();
}

void CivetServer::addHandler(const std::string &uri, CivetHandler *handler) {
    mg_set_request_handler(context, uri.c_str(), requestHandler, handler);
}

void CivetServer::removeHandler(const std::string &uri) {
    mg_set_request_handler(context, uri.c_str(), NULL, NULL);
}

void CivetServer::close() {
    if (context) {
        mg_stop (context);
        context = 0;
    }
}

int CivetServer::getCookie(struct mg_connection *conn, const std::string &cookieName, std::string &cookieValue)
{
    //Maximum cookie length as per microsoft is 4096. http://msdn.microsoft.com/en-us/library/ms178194.aspx
    char _cookieValue[4096];
    const char *cookie = mg_get_header(conn, "Cookie");
    int lRead = mg_get_cookie(cookie, cookieName.c_str(), _cookieValue, sizeof(_cookieValue));
    cookieValue.clear();
    cookieValue.append(_cookieValue);
    return lRead;
}

const char* CivetServer::getHeader(struct mg_connection *conn, const std::string &headerName)
{
    return mg_get_header(conn, headerName.c_str());
}

void
CivetServer::urlDecode(const char *src, std::string &dst, bool is_form_url_encoded) {
    urlDecode(src, strlen(src), dst, is_form_url_encoded);
}

void
CivetServer::urlDecode(const char *src, size_t src_len, std::string &dst, bool is_form_url_encoded) {
  int i, j, a, b;
#define HEXTOI(x) (isdigit(x) ? x - '0' : x - 'W')

  dst.clear();
  for (i = j = 0; i < (int)src_len; i++, j++) {
    if (src[i] == '%' && i < (int)src_len - 2 &&
        isxdigit(* (const unsigned char *) (src + i + 1)) &&
        isxdigit(* (const unsigned char *) (src + i + 2))) {
      a = tolower(* (const unsigned char *) (src + i + 1));
      b = tolower(* (const unsigned char *) (src + i + 2));
      dst.push_back((char) ((HEXTOI(a) << 4) | HEXTOI(b)));
      i += 2;
    } else if (is_form_url_encoded && src[i] == '+') {
      dst.push_back(' ');
    } else {
      dst.push_back(src[i]);
    }
  }
}

bool
CivetServer::getParam(struct mg_connection *conn, const char *name,
               std::string &dst, size_t occurrence) {
        const char *query = mg_get_request_info(conn)->query_string;
        return getParam(query, strlen(query), name, dst, occurrence);
}

bool
CivetServer::getParam(const char *data, size_t data_len, const char *name,
               std::string &dst, size_t occurrence) {
  const char *p, *e, *s;
  size_t name_len;

  dst.clear();
  if (data == NULL || name == NULL || data_len == 0) {
      return false;
  }
  name_len = strlen(name);
  e = data + data_len;

  // data is "var1=val1&var2=val2...". Find variable first
  for (p = data; p + name_len < e; p++) {
    if ((p == data || p[-1] == '&') && p[name_len] == '=' &&
        !mg_strncasecmp(name, p, name_len) && 0 == occurrence--) {

      // Point p to variable value
      p += name_len + 1;

      // Point s to the end of the value
      s = (const char *) memchr(p, '&', (size_t)(e - p));
      if (s == NULL) {
        s = e;
      }
      assert(s >= p);

      // Decode variable into destination buffer
      urlDecode(p, (int)(s - p), dst, true);
      return true;
    }
  }
  return false;
}

void
CivetServer::urlEncode(const char *src, std::string &dst, bool append) {
    urlEncode(src, strlen(src), dst, append);
}

void
CivetServer::urlEncode(const char *src, size_t src_len, std::string &dst, bool append) {
  static const char *dont_escape = "._-$,;~()";
  static const char *hex = "0123456789abcdef";

  if (!append)
      dst.clear();

  for (; src_len > 0; src_len--) {
    if (isalnum(*(const unsigned char *) src) ||
        strchr(dont_escape, * (const unsigned char *) src) != NULL) {
      dst.push_back(*src);
    } else {
      dst.push_back('%');
      dst.push_back(hex[(* (const unsigned char *) src) >> 4]);
      dst.push_back(hex[(* (const unsigned char *) src) & 0xf]);
    }
  }
}