X-Git-Url: https://git.ucc.asn.au/?a=blobdiff_plain;f=server%2Ffastcgi.c;h=c24678167adb9dbbb2efc9f3c265e76457b06693;hb=75b9743b95672218a61811b03433c0ab6e00ec5c;hp=1bd520bd379ae30fe2bcf4c31123c2e5f4417b9a;hpb=18027c718bc45eaa191068da1e739eebeb6111e4;p=matches%2FMCTX3420.git diff --git a/server/fastcgi.c b/server/fastcgi.c index 1bd520b..c246781 100644 --- a/server/fastcgi.c +++ b/server/fastcgi.c @@ -8,26 +8,24 @@ #include #include +#include +#include +#include +#include #include "common.h" #include "sensor.h" +#include "actuator.h" #include "control.h" #include "options.h" +#include "image.h" +#include "pin_test.h" +#include "login.h" -/**The time period (in seconds) before the control key expires @ */ +/**The time period (in seconds) before the control key expires */ #define CONTROL_TIMEOUT 180 -/**Contextual information related to FCGI requests*/ -struct FCGIContext { - /**The time of last valid user access possessing the control key*/ - time_t control_timestamp; - char control_key[41]; - char control_ip[16]; - /**The name of the current module**/ - const char *current_module; - /**For debugging purposes?**/ - int response_number; -}; + /** * Identifies build information and the current API version to the user. @@ -36,42 +34,53 @@ struct FCGIContext { * @param context The context to work in * @param params User specified paramters: [actuators, sensors] */ -static void IdentifyHandler(FCGIContext *context, char *params) { - bool identSensors = false, identActuators = false; - const char *key, *value; +static void IdentifyHandler(FCGIContext *context, char *params) +{ + bool ident_sensors = false, ident_actuators = false; int i; - while ((params = FCGI_KeyPair(params, &key, &value))) { - if (!strcmp(key, "sensors")) { - identSensors = !identSensors; - } else if (!strcmp(key, "actuators")) { - identActuators = !identActuators; - } - } + FCGIValue values[2] = {{"sensors", &ident_sensors, FCGI_BOOL_T}, + {"actuators", &ident_actuators, FCGI_BOOL_T}}; + if (!FCGI_ParseRequest(context, params, values, 2)) + return; FCGI_BeginJSON(context, STATUS_OK); FCGI_JSONPair("description", "MCTX3420 Server API (2013)"); FCGI_JSONPair("build_date", __DATE__ " " __TIME__); + struct timespec t = {0}; + clock_getres(CLOCK_MONOTONIC, &t); + FCGI_JSONDouble("clock_getres", TIMEVAL_TO_DOUBLE(t)); FCGI_JSONLong("api_version", API_VERSION); - if (identSensors) { + + bool has_control = FCGI_HasControl(context); + FCGI_JSONBool("logged_in", has_control); + FCGI_JSONPair("user_name", has_control ? context->user_name : ""); + + + //Sensor and actuator information + if (ident_sensors) { FCGI_JSONKey("sensors"); FCGI_JSONValue("{\n\t\t"); - for (i = 0; i < NUMSENSORS; i++) { + for (i = 0; i < g_num_sensors; i++) { if (i > 0) { FCGI_JSONValue(",\n\t\t"); } - FCGI_JSONValue("\"%d\" : \"%s\"", i, g_sensor_names[i]); + DataPoint d = Sensor_LastData(i); + FCGI_JSONValue("\"%d\" : {\"name\" : \"%s\", \"value\" : [%f,%f] }", + i, Sensor_GetName(i), d.time_stamp, d.value); } FCGI_JSONValue("\n\t}"); } - if (identActuators) { + if (ident_actuators) { FCGI_JSONKey("actuators"); FCGI_JSONValue("{\n\t\t"); - for (i = 0; i < NUMACTUATORS; i++) { + for (i = 0; i < g_num_actuators; i++) { if (i > 0) { FCGI_JSONValue(",\n\t\t"); } - FCGI_JSONValue("\"%d\" : \"%s\"", i, g_actuator_names[i]); + + DataPoint d = Actuator_LastData(i); + FCGI_JSONValue("\"%d\" : {\"name\" : \"%s\", \"value\" : [%f, %f] }", i, Actuator_GetName(i), d.time_stamp, d.value); } FCGI_JSONValue("\n\t}"); } @@ -79,45 +88,75 @@ static void IdentifyHandler(FCGIContext *context, char *params) { } /** - * Gives the user a key that determines who has control over - * the system at any one time. The key can be forcibly generated, revoking - * any previous control keys. To be used in conjunction with HTTP - * basic authentication. - * This function will generate a JSON response that indicates success/failure. + * Given an authorised user, attempt to set the control over the system. + * Modifies members in the context structure appropriately if successful. * @param context The context to work in - * @param force Whether to force key generation or not. - */ -void FCGI_BeginControl(FCGIContext *context, bool force) { + * @param user_name - Name of the user + * @param user_type - Type of the user, passed after successful authentication + * @return true on success, false otherwise (eg someone else already in control) + */ +bool FCGI_LockControl(FCGIContext *context, const char * user_name, UserType user_type) +{ + // Get current time time_t now = time(NULL); bool expired = now - context->control_timestamp > CONTROL_TIMEOUT; - - if (force || !*(context->control_key) || expired) { - SHA_CTX sha1ctx; - unsigned char sha1[20]; - int i = rand(); - - SHA1_Init(&sha1ctx); - SHA1_Update(&sha1ctx, &now, sizeof(now)); - SHA1_Update(&sha1ctx, &i, sizeof(i)); - SHA1_Final(sha1, &sha1ctx); - - context->control_timestamp = now; - for (i = 0; i < 20; i++) - sprintf(context->control_key + i * 2, "%02x", sha1[i]); - snprintf(context->control_ip, 16, "%s", getenv("REMOTE_ADDR")); - FCGI_BeginJSON(context, STATUS_OK); - FCGI_JSONPair("key", context->control_key); - FCGI_EndJSON(); - } else { - char buf[128]; - strftime(buf, 128, "%H:%M:%S %d-%m-%Y", - localtime(&(context->control_timestamp))); - FCGI_BeginJSON(context, STATUS_UNAUTHORIZED); - FCGI_JSONPair("description", "Another user already has control"); - FCGI_JSONPair("current_user", context->control_ip); - FCGI_JSONPair("when", buf); - FCGI_EndJSON(); + int i; + + // Can't lock control if: User not actually logged in (sanity), or key is still valid and the user is not an admin + if (user_type == USER_UNAUTH || + (user_type != USER_ADMIN && !expired && *(context->control_key) != '\0')) + return false; + + // Release any existing control (if any) + FCGI_ReleaseControl(context); + + // Set timestamp + context->control_timestamp = now; + + // Generate a SHA1 hash for the user + SHA_CTX sha1ctx; + unsigned char sha1[20]; + i = rand(); + SHA1_Init(&sha1ctx); + SHA1_Update(&sha1ctx, &now, sizeof(now)); + SHA1_Update(&sha1ctx, &i, sizeof(i)); + SHA1_Final(sha1, &sha1ctx); + for (i = 0; i < sizeof(sha1); i++) + sprintf(context->control_key + i * 2, "%02x", sha1[i]); + + // Set the IPv4 address + snprintf(context->control_ip, 16, "%s", getenv("REMOTE_ADDR")); + + // Set the user name + int uname_len = strlen(user_name); + i = snprintf(context->user_name, sizeof(context->user_name), "%s", user_name); + if (i < uname_len) { + Log(LOGERR, "Username at %d characters too long (limit %d)", + uname_len, sizeof(context->user_name)); + return false; // :-( + } + // Set the user type + context->user_type = user_type; + + // Build the user directory + i = snprintf(context->user_dir, sizeof(context->user_dir), "%s/%s", + g_options.experiment_dir, context->user_name); + if (i >= sizeof(context->user_dir)) { + Log(LOGERR, "Experiment dir too long (required %d, limit %d)", + i, sizeof(context->user_dir)); + return false; } + + Log(LOGDEBUG, "User dir: %s", context->user_dir); + // Create directory + if (mkdir(context->user_dir, 0777) != 0 && errno != EEXIST) + { + Log(LOGERR, "Couldn't create user directory %s - %s", + context->user_dir, strerror(errno)); + return false; // :-( + } + + return true; // :-) } /** @@ -128,10 +167,12 @@ void FCGI_BeginControl(FCGIContext *context, bool force) { * @param key The control key to be validated. * @return TRUE if authorized, FALSE if not. */ -bool FCGI_HasControl(FCGIContext *context, const char *key) { +bool FCGI_HasControl(FCGIContext *context) +{ time_t now = time(NULL); int result = (now - context->control_timestamp) <= CONTROL_TIMEOUT && - key != NULL && !strcmp(context->control_key, key); + context->control_key[0] != '\0' && + !strcmp(context->control_key, context->received_key); if (result) { context->control_timestamp = now; //Update the control_timestamp } @@ -143,13 +184,50 @@ bool FCGI_HasControl(FCGIContext *context, const char *key) { * Revokes the current control key, if present. * @param context The context to work in */ -void FCGI_EndControl(FCGIContext *context) { +void FCGI_ReleaseControl(FCGIContext *context) +{ *(context->control_key) = 0; - FCGI_BeginJSON(context, STATUS_OK); - FCGI_EndJSON(); + // Note: context->user_name should *not* be cleared return; } +/** + * Gets the control cookie + * @param buffer A storage buffer of exactly CONTROL_KEY_BUFSIZ length to + store the control key + */ +void FCGI_GetControlCookie(char buffer[CONTROL_KEY_BUFSIZ]) +{ + const char *cookies = getenv("COOKIE_STRING"); + const char *start = strstr(cookies, "mctxkey="); + + *buffer = 0; //Clear the buffer + if (start != NULL) { + int i; + start += 8; //length of mctxkey= + for (i = 0; i < CONTROL_KEY_BUFSIZ; i++) { + if (*start == 0 || *start == ';') { + break; + } + buffer[i] = *start++; + } + buffer[i] = 0; + } +} + +/** + * Sends the control key to the user as a cookie. + * @param context the context to work in + * @param set Whether to set or unset the control cookie + */ +void FCGI_SendControlCookie(FCGIContext *context, bool set) { + if (set) { + printf("Set-Cookie: mctxkey=%s\r\n", context->control_key); + } else { + printf("Set-Cookie: mctxkey=\r\n"); + } +} + /** * Extracts a key/value pair from a request string. * Note that the input is modified by this function. @@ -189,6 +267,101 @@ char *FCGI_KeyPair(char *in, const char **key, const char **value) return ptr; } +/** + * Aids in parsing request parameters. + * Input: The expected keys along with their type and whether or not + * they're required. + * @param context The context to work in + * @param params The parameter string to be parsed + * @param values An array of FCGIValue's that specify expected keys + * @param count The number of elements in 'values'. + * @return true If the parameter string was parsed successfully, false otherwise. + * Modes of failure include: Invalid a parsing error on the value, + * an unknown key is specified, + * a key/value pair is specified more than once, or + * not all required keys were present. + * If this function returns false, it is guaranteed that FCGI_RejectJSON + * has already been called with the appropriate description message. + */ +bool FCGI_ParseRequest(FCGIContext *context, char *params, FCGIValue values[], size_t count) +{ + const char *key, *value; + char buf[BUFSIZ], *ptr; + size_t i; + + while ((params = FCGI_KeyPair(params, &key, &value))) { + for (i = 0; i < count; i++) { + if (!strcmp(key, values[i].key)) { + FCGIValue *val = &values[i]; + + if (FCGI_RECEIVED(val->flags)) { + snprintf(buf, BUFSIZ, "Value already specified for '%s'.", key); + FCGI_RejectJSON(context, buf); + return false; + } + val->flags |= FCGI_PARAM_RECEIVED; + + switch(FCGI_TYPE(val->flags)) { + case FCGI_BOOL_T: + if (!*value) //No value: Default true + *((bool*) val->value) = true; + else { + *((bool*) val->value) = !!(strtol(value, &ptr, 10)); + if (*ptr) { + snprintf(buf, BUFSIZ, "Expected bool for '%s' but got '%s'", key, value); + FCGI_RejectJSON(context, buf); + return false; + } + } + break; + case FCGI_INT_T: case FCGI_LONG_T: { + long parsed = strtol(value, &ptr, 10); + if (!*value || *ptr) { + snprintf(buf, BUFSIZ, "Expected int for '%s' but got '%s'", key, value); + FCGI_RejectJSON(context, buf); + return false; + } + + if (FCGI_TYPE(val->flags) == FCGI_INT_T) + *((int*) val->value) = (int) parsed; + else + *((long*) val->value) = parsed; + } break; + case FCGI_DOUBLE_T: + *((double*) val->value) = strtod(value, &ptr); + if (!*value || *ptr) { + snprintf(buf, BUFSIZ, "Expected float for '%s' but got '%s'", key, value); + FCGI_RejectJSON(context, buf); + return false; + } + break; + case FCGI_STRING_T: + *((const char**) val->value) = value; + break; + default: + Fatal("Invalid type %d given", FCGI_TYPE(val->flags)); + } + break; //No need to search any more + } + } //End for loop + if (i == count) { + snprintf(buf, BUFSIZ, "Unknown key '%s' specified", key); + FCGI_RejectJSON(context, buf); + return false; + } + } + + //Check that required parameters are received + for (i = 0; i < count; i++) { + if (FCGI_IS_REQUIRED(values[i].flags) && !FCGI_RECEIVED(values[i].flags)) { + snprintf(buf, BUFSIZ, "Key '%s' required, but was not given.", values[i].key); + FCGI_RejectJSON(context, buf); + return false; + } + } + return true; +} + /** * Begins a response to the client in JSON format. * @param context The context to work in. @@ -200,20 +373,34 @@ void FCGI_BeginJSON(FCGIContext *context, StatusCodes status_code) printf("{\r\n"); printf("\t\"module\" : \"%s\"", context->current_module); FCGI_JSONLong("status", status_code); + //Time and running statistics + struct timespec now; + clock_gettime(CLOCK_MONOTONIC, &now); + FCGI_JSONDouble("start_time", TIMEVAL_TO_DOUBLE(g_options.start_time)); + FCGI_JSONDouble("current_time", TIMEVAL_TO_DOUBLE(now)); + FCGI_JSONDouble("running_time", TIMEVAL_DIFF(now, g_options.start_time)); + FCGI_JSONPair("control_state", Control_GetModeName()); +} - // Jeremy: Should we include a timestamp in the JSON; something like this? - double start_time = g_options.start_time.tv_sec + 1e-6*(g_options.start_time.tv_usec); - struct timeval now; - gettimeofday(&now, NULL); - double current_time = now.tv_sec + 1e-6*(now.tv_usec); - FCGI_JSONDouble("start_time", start_time); - FCGI_JSONDouble("current_time", current_time); - FCGI_JSONDouble("running_time", current_time - start_time); +/** + * Generic accept response in JSON format. + * @param context The context to work in + * @param description A short description. + * @param cookie Optional. If given, the cookie field is set to that value. + */ +void FCGI_AcceptJSON(FCGIContext *context, const char *description) +{ + printf("Content-type: application/json; charset=utf-8\r\n"); + printf("\r\n{\r\n"); + printf("\t\"module\" : \"%s\"", context->current_module); + FCGI_JSONLong("status", STATUS_OK); + FCGI_JSONPair("description", description); + FCGI_EndJSON(); } /** * Adds a key/value pair to a JSON response. The response must have already - * been initiated by FCGI_BeginJSON. Note that characters are not escaped. + * been initiated by FCGI_BeginJSON. Special characters are not escaped. * @param key The key of the JSON entry * @param value The value associated with the key. */ @@ -239,7 +426,7 @@ void FCGI_JSONLong(const char *key, long value) */ void FCGI_JSONDouble(const char *key, double value) { - printf(",\r\n\t\"%s\" : %f", key, value); + printf(",\r\n\t\"%s\" : %.9f", key, value); } /** @@ -286,7 +473,7 @@ void FCGI_RejectJSONEx(FCGIContext *context, StatusCodes status, const char *des FCGI_BeginJSON(context, status); FCGI_JSONPair("description", description); FCGI_JSONLong("responsenumber", context->response_number); - FCGI_JSONPair("params", getenv("QUERY_STRING")); + //FCGI_JSONPair("params", getenv("QUERY_STRING")); //A bad idea if contains password but also if contains unescaped stuff FCGI_JSONPair("host", getenv("SERVER_HOSTNAME")); FCGI_JSONPair("user", getenv("REMOTE_USER")); FCGI_JSONPair("ip", getenv("REMOTE_ADDR")); @@ -309,6 +496,84 @@ void FCGI_PrintRaw(const char *format, ...) va_end(list); } + +/** + * Write binary data + * See fwrite + */ +void FCGI_WriteBinary(void * data, size_t size, size_t num_elem) +{ + Log(LOGDEBUG,"Writing!"); + fwrite(data, size, num_elem, stdout); +} + +/** + * Escapes a string so it can be used safely. + * Currently escapes to ensure the validity for use as a JSON string + * Does not support unicode specifiers in the form of \uXXXX. + * @param buf The string to be escaped + * @return The escaped string (return value == buf) + */ +char *FCGI_EscapeText(char *buf) +{ + int length, i; + length = strlen(buf); + + //Escape special characters. Must count down to escape properly + for (i = length - 1; i >= 0; i--) { + if (buf[i] < 0x20) { //Control characters + buf[i] = ' '; + } else if (buf[i] == '"') { + if (i-1 >= 0 && buf[i-1] == '\\') + i--; + else + buf[i] = '\''; + } else if (buf[i] == '\\') { + if (i-1 >= 0 && buf[i-1] == '\'') + i--; + else + buf[i] = ' '; + } + } + return buf; +} + +/** + * Unescapes a URL encoded string in-place. The string + * must be NULL terminated. + * (e.g this%2d+string --> this- string) + * @param buf The buffer to decode. Will be modified in-place. + * @return The same buffer. + */ +char *FCGI_URLDecode(char *buf) +{ + char *head = buf, *tail = buf; + char val, hex[3] = {0}; + + while (*tail) { + if (*tail == '%') { //%hh hex to char + tail++; + if (isxdigit(*tail) && isxdigit(*(tail+1))) { + hex[0] = *tail++; + hex[1] = *tail++; + char val = (char)strtol(hex, NULL, 16); + //Control codes --> Space character + *head++ = (val < 0x20) ? 0x20 : val; + } else { //Not valid format; keep original + head++; + } + } else if (*tail == '+') { //Plus to space + tail++; + *head++ = ' '; + } else { //Anything else + *head++ = *tail++; + } + } + *head = 0; //NULL-terminate at new end point + + return buf; +} + /** * Main FCGI request loop that receives/responds to client requests. * @param data Reserved. @@ -319,27 +584,24 @@ void * FCGI_RequestLoop (void *data) { FCGIContext context = {0}; - Log(LOGDEBUG, "First request..."); - //TODO: The FCGI_Accept here is blocking. - // That means that if another thread terminates the program, this thread - // will not terminate until the next request is made. + Log(LOGDEBUG, "Start loop"); while (FCGI_Accept() >= 0) { - - if (Thread_Runstate() != RUNNING) - { - //TODO: Yeah... deal with this better :P - Log(LOGERR, "FIXME; FCGI gets request after other threads have finished."); - printf("Content-type: text/plain\r\n\r\n+++OUT OF CHEESE ERROR+++\n"); - break; - } - Log(LOGDEBUG, "Got request #%d", context.response_number); ModuleHandler module_handler = NULL; char module[BUFSIZ], params[BUFSIZ]; //strncpy doesn't zero-truncate properly snprintf(module, BUFSIZ, "%s", getenv("DOCUMENT_URI_LOCAL")); + + //Get the GET query string snprintf(params, BUFSIZ, "%s", getenv("QUERY_STRING")); + //URL decode the parameters + FCGI_URLDecode(params); + + FCGI_GetControlCookie(context.received_key); + Log(LOGDEBUG, "Got request #%d - Module %s, params %s", context.response_number, module, params); + Log(LOGDEBUG, "Control key: %s", context.received_key); + //Remove trailing slashes (if present) from module query size_t lastchar = strlen(module) - 1; @@ -356,21 +618,58 @@ void * FCGI_RequestLoop (void *data) module_handler = Control_Handler; } else if (!strcmp("sensors", module)) { module_handler = Sensor_Handler; + } else if (!strcmp("actuators", module)) { + module_handler = Actuator_Handler; + } else if (!strcmp("image", module)) { + module_handler = Image_Handler; + } else if (!strcmp("pin", module)) { + module_handler = Pin_Handler; // *Debug only* pin test module + } else if (!strcmp("bind", module)) { + module_handler = Login_Handler; + } else if (!strcmp("unbind", module)) { + module_handler = Logout_Handler; } context.current_module = module; + context.response_number++; + if (module_handler) { + if (module_handler == IdentifyHandler) { + FCGI_EscapeText(params); + } else if (module_handler != Login_Handler) { + if (!FCGI_HasControl(&context)) + { + if (g_options.auth_method == AUTH_NONE) { //:( + Log(LOGWARN, "Locking control (no auth!)"); + FCGI_LockControl(&context, NOAUTH_USERNAME, USER_ADMIN); + FCGI_SendControlCookie(&context, true); + } + else { + FCGI_RejectJSON(&context, "Please login. Invalid control key."); + continue; + } + } + + //Escape all special characters. + //Don't escape for login (password may have special chars?) + FCGI_EscapeText(params); + } else { //Only for Login handler. + //If GET data is empty, use POST instead. + if (*params == '\0') { + Log(LOGDEBUG, "Using POST!"); + fgets(params, BUFSIZ, stdin); + FCGI_URLDecode(params); + } + } + module_handler(&context, params); - } else { + } + else { FCGI_RejectJSON(&context, "Unhandled module"); } - context.response_number++; - - Log(LOGDEBUG, "Waiting for request #%d", context.response_number); } Log(LOGDEBUG, "Thread exiting."); - Thread_QuitProgram(false); // NOTE: Don't call pthread_exit, because this runs in the main thread. Just return. return NULL; }