Esempio n. 1
0
void cleanup(struct hash_map_t *arguments) {
    /* allocates space for the possible argument
    to be executed from the arguments map */
    void *value;

    /* prints a debug message */
    V_DEBUG("Cleaning the process information\n");

    /* in case no arguments map is provided must return
    immediately nothing left to be processed */
    if(arguments == NULL) {
        return;
    }

    /* tries to retrieve the daemon argument from the
    arguments map in case the value is set daemonclean
    the current process so that no structures remaining
    from the daemon process are left */
    get_value_string_hash_map(arguments, (unsigned char *) "daemon", &value);
    if(value != NULL) {
        daemonclean();
    }
}
Esempio n. 2
0
int execute_arguments(char *program_name, struct hash_map_t *arguments) {
    /* allocates space for the possible argument
    to be executed from the arguments map */
    void *value;

    /* allocates the value to be used to verify the
    exitence of error from the function */
    ERROR_CODE return_value;

    /* sets space for the flag that will control if
    the service should be run or not, this is used
    for certain situations (mostyle test) where the
    service is not meant to be run */
    char run_service = TRUE;

    /* tries to retrieve the help argument from the arguments
    map in case the value exists prints the help value and then
    exits the current system */
    get_value_string_hash_map(arguments, (unsigned char *) "help", &value);
    if(value != NULL) {
        return help();
    }

    /* tries to retrieve the version argument from the arguments
    map in case the value exists prints the version value and then
    exits the current system */
    get_value_string_hash_map(arguments, (unsigned char *) "version", &value);
    if(value != NULL) {
        return version();
    }

    /* retrieves the test argument value from the arguments map
    and in case it's set starts the test process runing a series
    of test functions in sequence */
    get_value_string_hash_map(arguments, (unsigned char *) "test", &value);
    if(value != NULL) {
        return test();
    }

    /* retrieves the speed argument value from the arguments map
    and in case it's set starts the speed measuring and disables
    the runnig of the service */
    get_value_string_hash_map(arguments, (unsigned char *) "speed", &value);
    if(value != NULL) {
        return speed();
    }

    /* tries to retrieve the daemon argument from the
    arguments map in case the value is set daemonizes
    the current process so that it remains in background
    and returns to the caller process immediately, otherwise
    prints the viriatum information into the standard
    output "file", the label should be standard */
    get_value_string_hash_map(arguments, (unsigned char *) "daemon", &value);
    if(value != NULL) {
        daemonize();
    }
    else {
        print_information();
    }

    /* tries to retrieve the local argument from the arguments
    map in case the value exists localizes the current service
    so that any file read is read from the current directory */
    get_value_string_hash_map(arguments, (unsigned char *) "local", &value);
    if(value != NULL) {
        localize();
    }

    /* in cas the flag that control if the service must be run is
    unset the control flow must be returned immediately (avoids
    running service) */
    if(run_service == FALSE) {
        RAISE_NO_ERROR;
    }

    /* runs the service, with the given arguments, this call
    should block the program control flow until an event
    stop the running of the main loop */
    return_value = run_service_s(program_name, arguments);

    /* tests the error code for error in case it exists
    prints a message indicating the problem that occurred */
    if(IS_ERROR_CODE(return_value)) {
        V_ERROR_F("Problem running service (%s)\n", (char *) GET_ERROR());
        RAISE_AGAIN(return_value);
    }

    /* returns the normal result value as no problems has
    occured during the execution of the command */
    RAISE_NO_ERROR;
}
Esempio n. 3
0
ERROR_CODE auth_file_http(char *auth_file, char *authorization, unsigned char *result) {
    /* allocates space for the error return value to be
    used in error checking for function calls */
    ERROR_CODE return_value;

    /* allocates space for the pointer to the passwd key
    value structure to be created by parsing the auth file */
    struct hash_map_t *passwd;

    /* allocates space to the various pointer values to be
    used for the separation and treatment of the auth value */
    char *pointer;
    char *authorization_b64;
    char *authorization_d;
    char *password_pointer;

    /* allocates space for the buffers to be used for the username
    and password values extracted from the authorization token */
    char username[128];
    char password[128];
    char *password_v;

    /* allocates the various size relates values for the buffer
    variables creation */
    size_t authorization_size;
    size_t username_size;
    size_t password_size;

    /* tries to find the token that separates the authentication
    type from the authorization base 64 value in case the value
    is not found raises an error indicating the problem */
    pointer = strchr(authorization, ' ');
    if(pointer == NULL) {
        RAISE_ERROR_M(
            RUNTIME_EXCEPTION_ERROR_CODE,
            (unsigned char *) "Authorization value not valid"
        );
    }
    authorization_b64 = pointer + 1;

    /* tries to decode the authorization base 64 value into a plain
    text value in case the decoding fails, re-raises the error to
    the upper levels for caller information */
    return_value = decode_base64(
        (unsigned char *) authorization_b64,
        strlen(authorization_b64),
        (unsigned char **) &authorization_d,
        &authorization_size
    );
    if(IS_ERROR_CODE(return_value)) {
        RAISE_ERROR_M(
            RUNTIME_EXCEPTION_ERROR_CODE,
            (unsigned char *) "Problem decoding base 64 authorization"
        );
    }

    /* tries to find the token that separates the username part of the
    authorization from the password part in case the value is not found
    raises an error to the upper levels */
    pointer = memchr(authorization_d, ':', authorization_size);
    if(pointer == NULL) {
        FREE(authorization_d);
        RAISE_ERROR_M(
            RUNTIME_EXCEPTION_ERROR_CODE,
            (unsigned char *) "No password separator found in authorization"
        );
    }
    password_pointer = pointer + 1;

    /* calculates the size of both the username and the password
    from the diference between the various pointers */
    username_size = password_pointer - authorization_d - 1;
    password_size = authorization_d + authorization_size - password_pointer;

    /* copies both the username and the password values to
    the apropriate internal buffers (to be used in comparision) */
    memcpy(username, authorization_d, username_size);
    username[username_size] = '\0';
    memcpy(password, password_pointer, password_size);
    password[password_size] = '\0';

    /* processes the passwd file using the provided file path
    for it, this is an expensive io driven operation, and must
    be used wth care */
    process_passwd_file(auth_file, &passwd);

    /* retrieves the password verification value for the
    retrieved username and in case it's valid compares it
    and sets the result value accordingly */
    get_value_string_hash_map(
        passwd,
        (unsigned char *) username,
        (void **) &password_v
    );
    if(password_v != NULL && strcmp(password, password_v) == 0) {
        *result = TRUE;
    } else { *result = FALSE; }

    /* releases the memory associated with the complete set
    of values in the passwd structure and then releases the
    memory from the hash map structure itself, then releases
    the memory associated with the authorization decoded string */
    delete_values_hash_map(passwd);
    delete_hash_map(passwd);
    FREE(authorization_d);

    /* raises no error, as everything has been done as possible
    with no problems created in the processing */
    RAISE_NO_ERROR;
}