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