/Users/maurits/Documents/studie/afstuderen/biosphere/modules/keystroke/bsmod_keystroke.c

Go to the documentation of this file.

/*
 * Author: MA Hartman
 * Date: april 10, 2007
 * 
 * Function:
 * A module which offers keystroke biometrics.
 * 
 * License information:
 * 
 * Copyright (c) 2006 Maurits Hartman
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 * 
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 * 
 */

#include <biosphere_module.h>
#include <io.h>
#include <list.h>
#include <str.h>
#include <type.h>

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <apr_strings.h>
#include <apr_thread_proc.h>
#include <sys/time.h>


bs_module bsmod_symtable;

static FILE *companion;

static apr_pool_t *mempool;


static bs_status bsmod_keystroke_init(void)
{
        /* Try to create a memory pool: */
        mempool = NULL;
        apr_pool_create(&mempool, NULL);
        if (!mempool) return BS_ERROR;
        
        /* Open the java companion program */
        companion = popen("java -cp /usr/local/keystroke/keystroke.jar:/usr/local/weka/weka.jar keystroke.KeystrokeCompanion", "w");
        if (!companion) {
                printf("Could not open companion program");
                return BS_ERROR;
        }
        setvbuf(companion, NULL, _IONBF, 0);
        return BS_OK;   
}


static void remove_temp_file(void)
{
        unlink("/usr/local/keystroke/answer.tmp");
}


static bs_status bsmod_keystroke_cleanup(void)
{
        apr_pool_destroy(mempool);
        fprintf(companion, "END\n");
        pclose(companion);
        return BS_OK;   
}


static bs_service_response *create_status_response(
                const bs_service_request *request, bs_status status, char *message)
{
        bs_service_response *resp;
        bs_message_instance *output = NULL;
        bs_part_instance *part1 = NULL, *part2 = NULL;
        bs_data_type *type1 = NULL, *type2 = NULL;
        char *data, *data2;
        
        data = apr_psprintf(mempool, "%u", status);
        data2 = apr_psprintf(mempool, "%s", message);
        type1 = new_bs_data_type(mempool, "bs_uint32");
        if (!type1) return NULL;
        type2 = new_bs_data_type(mempool, "bs_string");
        if (!type2) return NULL;
        
        part1 = new_bs_part_instance(mempool, "code", type1,
                        data, strlen(data));
        part2 = new_bs_part_instance(mempool, "message", type2,
                        data2, strlen(data2));
        if (!part1 || !part2) return NULL;
        output = new_bs_message_instance(mempool, "BSStatusMessage", 2);
        if (!output) return NULL;
        output->parts[0] = part1;
        output->parts[1] = part2;
        resp = new_bs_service_response(mempool, request->uuid,
                        request->service, request->port, request->operation,
                        output, NULL);
        
        return resp;
}


static bs_service_response *make_answer(const bs_service_request *request)
{
        bs_status rv;
        char *respbuf;
        bs_uint64 len;
        
        rv = read_file_into_buf("/usr/local/keystroke/answer.tmp", &respbuf, &len, mempool);
        if (rv != BS_OK || len == 0) {
                return create_status_response(request, 1, "Could not read temp file.");
        }
        
        remove_temp_file();
        return create_status_response(request, atoi(respbuf), respbuf + 2);
}


static void wait_for_answer(void)
{
        while (system("test -r /usr/local/keystroke/answer.tmp")) {
                apr_thread_yield();
        }
}


static bs_status bsmod_keystroke_handle_service(
                const bs_service_request *request,
                bs_service_response **response, void *extra)
{
        struct timeval t;
        gettimeofday(&t, 0);
        printf("%ld.%06ld,", t.tv_sec, t.tv_usec);
        
        remove_temp_file();
        
        /* Service request: */
        if (streq(request->operation, "enroll")) {
                fprintf(companion, "ENROLL %s\n", request->input->parts[0]->data);
        }
        else if (streq(request->operation, "remove")) {
                fprintf(companion, "REMOVE %s\n", request->input->parts[0]->data);
        }
        else if (streq(request->operation, "addVector")) {
                fprintf(companion, "ADD %s %s %s\n",
                                request->input->parts[0]->data,
                                request->input->parts[1]->data,
                                request->input->parts[2]->data);
        }
        else if (streq(request->operation, "train")) {
                fprintf(companion, "TRAIN %s %s\n",
                                request->input->parts[0]->data,
                                request->input->parts[1]->data);
        }
        else if (streq(request->operation, "verify")) {
                fprintf(companion, "VERIFY %s %s %s\n",
                                request->input->parts[0]->data,
                                request->input->parts[1]->data,
                                request->input->parts[2]->data);
        }
        else if (streq(request->operation, "verify_threshold")) {
                fprintf(companion, "VERIFYTHRESHOLD %s %s %s\n",
                                request->input->parts[0]->data,
                                request->input->parts[1]->data,
                                request->input->parts[2]->data);
        }
        else return BS_NO_SERVICE;

        wait_for_answer();
        *response = make_answer(request);
        
        gettimeofday(&t, 0);
        printf("%ld.%06ld,", t.tv_sec, t.tv_usec);
        return BS_OK;                   
}


/* Here come functions offered by the module: */

/* Final declaration of the bs_module struct: */
bs_module bsmod_symtable = {
        /* The major and minor version of the API used by this module: */
        0,
        0,
        
        /* The major and minor version of this module: */
        0,
        1,
        
        /* The name, author, date and copyright information: */
        "keystroke module",
        "M.A.Hartman",
        "apr 10, 2007",
        "(c) 2007, M.A.Hartman. See distributed LICENSE file for more information.",
        "A keystroking biometrics module. It implements some basic keystroking "
        "methods based mostly on text-dependent input, such as passwords.",
        
        /* Init and cleanup routines: */
        bsmod_keystroke_init,
        bsmod_keystroke_cleanup,
        
        /* Service request handling function: */
        bsmod_keystroke_handle_service,
        NULL,
        "bsmod_keystroke.wsdl"
};

---