server/fastcgi.c

   1 /**
   2  * @file fastcgi.c
   3  * @purpose Runs the FCGI request loop to handle web interface requests.
   4  *
   5  * fcgi_stdio.h must be included before all else so the stdio function
   6  * redirection works ok.
   7  */
   8
   9 #include <fcgi_stdio.h>
  10 #include <openssl/sha.h>
  11 #include <time.h>
  12
  13 #include "common.h"
  14 #include "fastcgi.h"
  15 #include "sensor.h"
  16 #include "log.h"
  17
  18 #define LOGIN_TIMEOUT 180
  19
  20 struct FCGIContext {
  21         /**The time of last valid logged-in user access*/
  22         time_t login_timestamp;
  23         char login_key[41];
  24         char login_ip[16];
  25         /**The name of the current module**/
  26         const char *current_module;
  27         /**For debugging purposes?**/
  28         int response_number;
  29 };
  30
  31 /**
  32  * Handles user logins.
  33  * @param context The context to work in
  34  * @param params User specified parameters
  35  */
  36 static void LoginHandler(FCGIContext *context, char *params) {
  37         const char *key, *value;
  38         bool force = 0, end = 0;
  39
  40         while ((params = FCGI_KeyPair(params, &key, &value))) {
  41                 if (!strcmp(key, "force"))
  42                         force = !force;
  43                 else if (!strcmp(key, "end"))
  44                         end = !end;
  45         }
  46
  47         if (end) {
  48                 *(context->login_key) = 0;
  49                 FCGI_BeginJSON(context, STATUS_OK);
  50                 FCGI_EndJSON();
  51                 return;
  52         }
  53
  54         time_t now = time(NULL);
  55         if (force || !*(context->login_key) ||
  56            (now - context->login_timestamp > LOGIN_TIMEOUT))
  57         {
  58                 SHA_CTX sha1ctx;
  59                 unsigned char sha1[20];
  60                 int i = rand();
  61
  62                 SHA1_Init(&sha1ctx);
  63                 SHA1_Update(&sha1ctx, &now, sizeof(now));
  64                 SHA1_Update(&sha1ctx, &i, sizeof(i));
  65                 SHA1_Final(sha1, &sha1ctx);
  66
  67                 context->login_timestamp = now;
  68                 for (i = 0; i < 20; i++)
  69                         sprintf(context->login_key + i * 2, "%02x", sha1[i]);
  70                 snprintf(context->login_ip, 16, "%s", getenv("REMOTE_ADDR"));
  71                 FCGI_BeginJSON(context, STATUS_OK);
  72                 FCGI_JSONPair("key", context->login_key);
  73                 FCGI_EndJSON();
  74         } else {
  75                 char buf[128];
  76                 strftime(buf, 128, "%H:%M:%S %d-%m-%Y",
  77                         localtime(&(context->login_timestamp)));
  78                 FCGI_BeginJSON(context, STATUS_UNAUTHORIZED);
  79                 FCGI_JSONPair("description", "Already logged in");
  80                 FCGI_JSONPair("user", context->login_ip);
  81                 FCGI_JSONPair("time", buf);
  82                 FCGI_EndJSON();
  83         }
  84 }
  85
  86 /*TODO: Remove and replace with the actual actuator code*/
  87 static void ActuatorHandler(FCGIContext *context, char *params) {
  88         const char *key, *value, *loginkey = NULL;
  89         while ((params = FCGI_KeyPair(params, &key, &value))) {
  90                 if (!strcmp(key, "key")) {
  91                         loginkey = value;
  92                 }
  93         }
  94         if (!loginkey || !FCGI_Authorized(context, loginkey)) {
  95                 FCGI_BeginJSON(context, STATUS_UNAUTHORIZED);
  96                 FCGI_JSONPair("description", "Invalid key specified.");
  97                 FCGI_EndJSON();
  98         } else {
  99                 FCGI_BeginJSON(context, STATUS_OK);
 100                 FCGI_JSONPair("description", "Logged in!");
 101                 FCGI_EndJSON();
 102         }
 103 }
 104
 105 /**
 106  * Given an FCGIContext, determines if the current user (as specified by
 107  * the key) is authorized or not. If validated, the context login_timestamp is
 108  * updated.
 109  * @param context The context to work in
 110  * @param key The login key to be validated.
 111  * @return TRUE if authorized, FALSE if not.
 112  */
 113 bool FCGI_Authorized(FCGIContext *context, const char *key) {
 114         time_t now = time(NULL);
 115         int result = (now - context->login_timestamp) <= LOGIN_TIMEOUT &&
 116                                  !strcmp(context->login_key, key);
 117         if (result) {
 118                 context->login_timestamp = now; //Update the login_timestamp
 119         }
 120         return result;
 121 }
 122
 123 /**
 124  * Extracts a key/value pair from a request string.
 125  * Note that the input is modified by this function.
 126  * @param in The string from which to extract the pair
 127  * @param key A pointer to a variable to hold the key string
 128  * @param value A pointer to a variable to hold the value string
 129  * @return A pointer to the start of the next search location, or NULL if
 130  *         the EOL is reached.
 131  */
 132 char *FCGI_KeyPair(char *in, const char **key, const char **value)
 133 {
 134         char *ptr;
 135         if (!in || !*in) { //Invalid input or string is EOL
 136                 return NULL;
 137         }
 138
 139         *key = in;
 140         //Find either = or &, whichever comes first
 141         if ((ptr = strpbrk(in, "=&"))) {
 142                 if (*ptr == '&') { //No value specified
 143                         *value = ptr;
 144                         *ptr++ = 0;
 145                 } else {
 146                         //Stopped at an '=' sign
 147                         *ptr++ = 0;
 148                         *value = ptr;
 149                         if ((ptr = strchr(ptr,'&'))) {
 150                                 *ptr++ = 0;
 151                         } else {
 152                                 ptr = "";
 153                         }
 154                 }
 155         } else { //No value specified and no other pair
 156                 ptr = "";
 157                 *value = ptr;
 158         }
 159         return ptr;
 160 }
 161
 162 /**
 163  * Begins a response to the client in JSON format.
 164  * @param context The context to work in.
 165  * @param status_code The status code to be returned.
 166  */
 167 void FCGI_BeginJSON(FCGIContext *context, StatusCodes status_code)
 168 {
 169         printf("Content-type: application/json; charset=utf-8\r\n\r\n");
 170         printf("{\r\n");
 171         printf("\t\"module\" : \"%s\"", context->current_module);
 172         FCGI_JSONLong("status", status_code);
 173 }
 174
 175 /**
 176  * Adds a key/value pair to a JSON response. The response must have already
 177  * been initiated by FCGI_BeginJSON. Note that characters are not escaped.
 178  * @param key The key of the JSON entry
 179  * &param value The value associated with the key.
 180  */
 181 void FCGI_JSONPair(const char *key, const char *value)
 182 {
 183         printf(",\r\n\t\"%s\" : \"%s\"", key, value);
 184 }
 185
 186 /**
 187  * Similar to FCGI_JSONPair except for signed integer values.
 188  * @param key The key of the JSON entry
 189  * @param value The value associated with the key
 190  */
 191 void FCGI_JSONLong(const char *key, long value)
 192 {
 193         printf(",\r\n\t\"%s\" : %ld", key, value);
 194 }
 195
 196 /**
 197  * Similar to FCGI_JsonPair except for floating point values.
 198  * @param key The key of the JSON entry
 199  * @param value The value associated with the key
 200  */
 201 void FCGI_JSONDouble(const char *key, double value)
 202 {
 203         printf(",\r\n\t\"%s\" : %f", key, value);
 204 }
 205
 206 /**
 207  * Begins a JSON entry by writing the key. To be used in conjunction
 208  * with FCGI_JsonValue.
 209  * @param key The key of the JSON entry
 210  */
 211 void FCGI_JSONKey(const char *key)
 212 {
 213         printf(",\r\n\t\"%s\" : ", key);
 214 }
 215
 216 /**
 217  * Should be used to write out the value of a JSON key. This has
 218  * the same format as the printf functions. Care should be taken to format
 219  * the output in valid JSON.
 220  */
 221 void FCGI_JSONValue(const char *format, ...)
 222 {
 223         va_list list;
 224         va_start(list, format);
 225         vprintf(format, list);
 226         va_end(list);
 227 }
 228
 229 /**
 230  * Ends a JSON response that was initiated by FCGI_BeginJSON.
 231  */
 232 void FCGI_EndJSON()
 233 {
 234         printf("\r\n}\r\n");
 235 }
 236
 237 /**
 238  * To be used when the input parameters are invalid.
 239  * Sends a response with HTTP status 400 Bad request, along with
 240  * JSON data for debugging.
 241  * @param context The context to work in
 242  * @param params The parameters that the module handler received.
 243  */
 244 void FCGI_RejectJSON(FCGIContext *context)
 245 {
 246         printf("Status: 400 Bad Request\r\n");
 247
 248         FCGI_BeginJSON(context, STATUS_ERROR);
 249         FCGI_JSONPair("description", "Invalid request");
 250         FCGI_JSONLong("responsenumber", context->response_number);
 251         FCGI_JSONPair("params", getenv("DOCUMENT_URI_LOCAL"));
 252         FCGI_JSONPair("host", getenv("SERVER_HOSTNAME"));
 253         FCGI_JSONPair("user", getenv("REMOTE_USER"));
 254         FCGI_JSONPair("ip", getenv("REMOTE_ADDR"));
 255         FCGI_EndJSON();
 256 }
 257
 258 /**
 259  * Main FCGI request loop that receives/responds to client requests.
 260  * @param data Reserved.
 261  */
 262 void FCGI_RequestLoop (void *data)
 263 {
 264         FCGIContext context = {0};
 265
 266         while (FCGI_Accept() >= 0) {
 267                 ModuleHandler module_handler = NULL;
 268                 char module[BUFSIZ], params[BUFSIZ];
 269
 270                 //strncpy doesn't zero-truncate properly
 271                 snprintf(module, BUFSIZ, "%s", getenv("DOCUMENT_URI_LOCAL"));
 272                 snprintf(params, BUFSIZ, "%s", getenv("QUERY_STRING"));
 273
 274                 //Remove trailing slashes (if present) from module query
 275                 size_t lastchar = strlen(module) - 1;
 276                 if (lastchar > 0 && module[lastchar] == '/')
 277                         module[lastchar] = 0;
 278
 279
 280                 if (!strcmp("login", module)) {
 281                         module_handler = LoginHandler;
 282                 } else if (!strcmp("sensors", module)) {
 283                         module_handler = Sensor_Handler;
 284                 } else if (!strcmp("actuators", module)) {
 285                         module_handler = ActuatorHandler;
 286                 }
 287
 288                 context.current_module = module;
 289                 if (module_handler) {
 290                         module_handler(&context, params);
 291                 } else {
 292                         strncat(module, " [unknown]", BUFSIZ);
 293                         FCGI_RejectJSON(&context);
 294                 }
 295
 296                 context.response_number++;
 297         }
 298 }