root/vowfsc/db.c

#include "db.h"

#define DEBUG

#include "db-util.h"

// Begin fuction implementation
char *db_normalize_dir_name( char *dir_name ){
        // Linked list structure
        typedef struct list list;
        struct list{
                char  *dir_name;
                int    str_len;
                list *next;
                list *prev;
        };

        list *temp, *list_tail, *list_head;
        list_tail=list_head=malloc(sizeof(list));
        list_tail->dir_name=dir_name;

        int substr_len=0, str_len=1;
        while( *dir_name ){
                if(*dir_name=='/'){
                        if( substr_len ){
                                // If there was a non-zero length string between two '/'s, then record it
                                list_tail->str_len=substr_len;
                                str_len+=substr_len+1;
                                
                                temp=malloc(sizeof(list));
                                list_tail->next=temp;
                                temp->prev=list_tail;
                                list_tail=temp;
                                list_tail->next=NULL;
                        }
                        list_tail->dir_name=dir_name+1;
                        ++dir_name;
                        substr_len=0;

                        if(*(dir_name)=='.'){
                                if(*(dir_name+1)=='/'){ // case: "/./"
                                        // Clear tail node
                                        ++dir_name;
                                        list_tail->dir_name=dir_name+1;
                                        substr_len=0;
                                }
                                if(*(dir_name+1)=='.'){
                                        if(*(dir_name+2)=='/'){ //case: "/../"
                                                // Pop the tail node off the list
                                                temp=list_tail;
                                                list_tail=list_tail->prev;
                                                list_tail->next=NULL;
                                                free(temp);
                                        
                                                // Clear tail node
                                                dir_name+=2;
                                                str_len-=list_tail->str_len+1;
                                                list_tail->dir_name=dir_name+1;
                                                substr_len=0;

                                        }
                                }
                        }
                        continue;
                }
                ++dir_name;
                ++substr_len;
        }

        if(substr_len){
                // If there is something still at the end, add it
                list_tail->str_len=substr_len;
                str_len+=substr_len+1;
        }else{
                // Pop the tail node off the list
                temp=list_tail;
                list_tail=list_tail->prev;
                list_tail->next=NULL;
                free(temp);
        }
        
        char *new_str=malloc(str_len+1);
        new_str[0]='/';
        int str_pos=1;
        while( list_head ){
                // Reconstruct the string
                memcpy(new_str+str_pos,list_head->dir_name, list_head->str_len);
                str_pos+=list_head->str_len;
                new_str[str_pos++]='/';
                int i;

                // Pop the head node off the list
                temp=list_head;
                list_head=list_head->next;
                free(temp);
        }
        new_str[str_pos]='\0';
        return new_str; 
}

int db_split_file_name( char *file_path, char **dir_name, char **file_name ){
        // Find the last '/'
        char *tmp_file_name, *i=file_path;
        while( *i++ )
                if( *i =='/' )
                        tmp_file_name=i+1;
        // Copy the file_name
        *file_name = malloc(i-tmp_file_name+1);
        memcpy(*file_name, tmp_file_name,i-tmp_file_name);
        (*file_name)[i-tmp_file_name]='\0';

        // Copy and normalize the directory name
        char *tmp_dir_name=malloc(tmp_file_name-file_path+1);
        memcpy(tmp_dir_name, file_path, tmp_file_name-file_path);
        tmp_dir_name[tmp_file_name-file_path]='\0';
        
        *dir_name=db_normalize_dir_name(tmp_dir_name);
        free(tmp_dir_name);
        
        return 0;
}

int db_parse_file_res( PGresult *res, file_t *file ){
        // Initialize format
        if( !NUM_FILE_FIELDS ){
                NUM_FILE_FIELDS = sizeof(file_format)/4+1;

                if( PQnfields(res) != NUM_FILE_FIELDS ){
                        NUM_FILE_FIELDS = 0;
                        return NULL;
                }

        // Fill file_format with column numbers
#define db_int(name)    file_format.name = PQfnumber(res, #name );
#define db_long(name)   file_format.name = PQfnumber(res, #name );
#define db_string(name) file_format.name = PQfnumber(res, #name );
#include "file.db"
        }

        if( PQresultStatus(res) != PGRES_TUPLES_OK ) return NULL;
        
        if( PQnfields(res) != NUM_FILE_FIELDS ) return NULL;

        // Fill stat
#define db_int(name)    file->name = atoi(PQgetvalue(res, 0, file_format.name ));
#define db_long(name)   file->name = atol(PQgetvalue(res, 0, file_format.name ));
#define db_string(name) file->name = strdup(PQgetvalue(res, 0, file_format.name ));
#include "file.db"
        
        return 0;
}

int db_parse_dir_res( PGresult *res, dir_t *dir ){
        // Initialize format
        if( !NUM_DIR_FIELDS ){
                NUM_DIR_FIELDS = sizeof(dir_format)/4;

                if( PQnfields(res) != NUM_DIR_FIELDS ){
                        NUM_DIR_FIELDS = 0;
                        return NULL;
                }

        // Fill dir_format with column numbers
#define db_int(name)    dir_format.name = PQfnumber(res, #name );
#define db_long(name)   dir_format.name = PQfnumber(res, #name );
#define db_string(name) dir_format.name = PQfnumber(res, #name );
#include "dir.db"
        }

        if( PQresultStatus(res) != PGRES_TUPLES_OK ) return NULL;
        
        if( PQnfields(res) != NUM_DIR_FIELDS ) return NULL;

        // Fill stat
#define db_int(name)    dir->name = atoi(PQgetvalue(res, 0, dir_format.name ));
#define db_long(name)   dir->name = atol(PQgetvalue(res, 0, dir_format.name ));
#define db_string(name) dir->name = strdup(PQgetvalue(res, 0, dir_format.name ));
#include "dir.db"
        
        return 0;
}

int db_get_file_max_revision( int file_id ){
        // Make the request
        char pq_request[BUFFER_SIZE];
        sprintf(pq_request,"SELECT MAX(revision_id) "
                           "FROM file "
                           "WHERE file_id = \'%i\'",
                           file_id);
        db_debug_rq(db_get_file_max_revision);
        PGresult *res=PQexec(pq_conn,pq_request);

        // Check to see that the something was returned
        if( PQresultStatus(res) != PGRES_TUPLES_OK ) return NULL;
        
        if( !PQntuples(res) ) return NULL;

        // The result should be in the first row of the first column
        int revision_id=atoi(PQgetvalue(res,0,0));

        PQclear(res);

        return revision_id;
}



int db_get_file_id( char *file_path ){
        char *file_name, *dir_name;
        db_split_file_name(file_path, &dir_name, &file_name);

        // Make the request
        char pq_request[BUFFER_SIZE];
        sprintf(pq_request,"SELECT file_id "
                           "FROM file WHERE file_name = \'%s\' "
                           "AND directory_path = \'%s\'",
                           file_name,dir_name);
        db_debug_rq(db_get_file_id);
        PGresult *res=PQexec(pq_conn,pq_request);

        // Check for returned data
        if( PQresultStatus(res) != PGRES_TUPLES_OK ) return NULL;

        if( !PQntuples(res) ) return NULL;

        // The result should be in the first row of the first column
        int file_id=atoi(PQgetvalue(res,0,0));
        
        free(dir_name);
        free(file_name);
        PQclear(res);

        return file_id;
}


file_t *db_get_file( int file_id ){
        file_t *stat=malloc(sizeof(file_t));

        // Make PQ request
        char pq_request[BUFFER_SIZE];
        sprintf(pq_request,"SELECT "
#define db_int(name)    #name ", "
#define db_long(name)   #name ", "
#define db_string(name) #name ", "
#include "file.db"
                           "file_uid "
                           "FROM file "
                           "WHERE file_id = \'%i\' "
                           "AND revision_id = (SELECT MAX(revision_id) FROM file WHERE file_Id = \'%i\')",
                           file_id, file_id);
        db_debug_rq(db_get_file);
        PGresult *res=PQexec(pq_conn,pq_request);

        db_parse_file_res(res, stat);

        PQclear(res);

        return stat;
}


file_t *db_get_file_rev( int file_id, int revision_id ){
        file_t *stat=malloc(sizeof(file_t));

        // Make PQ request
        char pq_request[BUFFER_SIZE];
        sprintf(pq_request,"SELECT "
#define db_int(name)    #name ", "
#define db_long(name)   #name ", "
#define db_string(name) #name ", "
#include "file.db"
                           "file_uid "
                           "FROM file "
                           "WHERE file_id = \'%i\' "
                           "AND revision_id = \'%i\'",
                           file_id, revision_id);
        PGresult *res=PQexec(pq_conn,pq_request);

        db_parse_file_res(res, stat);
        
        PQclear(res);

        return stat;
}

char *db_get_file_data( int file_id ){
        char pq_request[BUFFER_SIZE];
        sprintf(pq_request,"SELECT data "
                           "FROM file "
                           "WHERE file_id = \'%i\' "
                           "AND revision_id = (SELECT MAX(revision_id) FROM file WHERE file_id = \'%i\')",
                           file_id, file_id);
        db_debug_rq(db_get_file_data);
        PGresult *res=PQexec(pq_conn,pq_request);

        if( PQresultStatus(res) != PGRES_TUPLES_OK ) return NULL;

        int data_len=PQgetlength(res,0,0);
        char *data=malloc(data_len);
        memcpy(data,PQgetvalue(res,0,0),data_len);
        int udata_len;
        char *udata=PQunescapeBytea(data,&udata_len);

        free(data);
        PQclear(res);

        return udata;
}


char *db_get_file_rev_data( int file_id, int revision_id ){
        int i = db_get_file_max_revision(file_id);
        char *data, *diff, *temp;
        
        char pq_request[BUFFER_SIZE];
        sprintf(pq_request,"SELECT data "
                           "FROM file "
                           "WHERE file_id = \'%i\' "
                           "AND revision_id = \'%i\'",
                           file_id,i);
        PGresult *res=PQexec(pq_conn,pq_request);

        if( PQresultStatus(res) != PGRES_TUPLES_OK ) return NULL;

        int data_len=PQgetlength(res,0,0), diff_len, temp_len;
        data=malloc(data_len);
        memcpy(data,PQgetvalue(res,0,0),data_len);
        int udata_len;
        char *udata=PQunescapeBytea(data,&udata_len);
        free(data);

        PQclear(res);

        while( --i >= revision_id ){
                char pq_request[BUFFER_SIZE];
                sprintf(pq_request,"SELECT data "
                                   "FROM file "
                                   "WHERE file_id = \'%i\' "
                                   "AND revision_id = \'%i\'",
                                   file_id,i);
                db_debug_rq(db_get_file_rev_udata);
                PGresult *res=PQexec(pq_conn,pq_request);

                if( PQresultStatus(res) != PGRES_TUPLES_OK ) return NULL;

                diff_len=PQgetlength(res,0,0);
                diff=malloc(diff_len);
                memcpy(diff,PQgetvalue(res,0,0),diff_len);

                int udiff_len;
                char *udiff = PQunescapeBytea(diff,&udiff_len);

                temp=malloc(XD3_ALLOCSIZE);

                xd3_decode_memory(udiff, udiff_len,
                                  udata, udata_len,
                                  temp, &temp_len, XD3_ALLOCSIZE,
                                  0);
                
                free(diff);
                PQfreemem(udata);
                PQfreemem(udiff);
                PQclear(res);
                udata = temp;
                udata_len = temp_len;
        }

        return udata;
}


int db_get_dir_id( char *dir_path ){
        char *dir_name=db_normalize_dir_name(dir_path);

        // Make the request
        char pq_request[BUFFER_SIZE];
        sprintf(pq_request,"SELECT directory_id "
                           "FROM directory "
                           "WHERE directory_path = \'%s\'",
                           dir_name);
        PGresult *res=PQexec(pq_conn,pq_request);

        // Check to see that the file exists
        if( PQresultStatus(res) != PGRES_TUPLES_OK ) return NULL;
        
        if( !PQntuples(res) ) return NULL;

        // The result should be in the first row of the first column
        int dir_id=atoi(PQgetvalue(res,0,0));

        // Clean up and return
        free(dir_name);
        PQclear(res);

        return dir_id;
}


dir_t *db_get_dir( int dir_id ){
        dir_t *stat=malloc(sizeof(dir_t));

        char pq_request[BUFFER_SIZE];
        sprintf(pq_request,"SELECT * "
                           "FROM directory "
                           "WHERE directory_id = \'%i\' "
                           "AND revision_id = (SELECT MAX(revision_id) FROM directory WHERE directory_id = \'%i\')",
                           dir_id, dir_id);
        PGresult *res=PQexec(pq_conn,pq_request);

        db_parse_dir_res(res,stat);

        PQclear(res);

        return stat;
}


dir_t *db_get_dir_rev( int dir_id, int revision_id ){
        dir_t *stat=malloc(sizeof(dir_t));

        char pq_request[BUFFER_SIZE];
        sprintf(pq_request,"SELECT * "
                           "FROM directory "
                           "WHERE directory_id = \'%i\' "
                           "AND revision_id = \'%i\'",
                           dir_id, revision_id);
        PGresult *res=PQexec(pq_conn,pq_request);

        db_parse_dir_res( res, stat );

        PQclear(res);

        return stat;
}

int db_get_dir_max_revision( int dir_id ){
        // Make the request
        char pq_request[BUFFER_SIZE];
        sprintf(pq_request,"SELECT MAX(revision_id) "
                           "FROM directory "
                           "WHERE directory_id = \'%i\'",
                           dir_id);
        PGresult *res=PQexec(pq_conn,pq_request);

        if( PQresultStatus(res) != PGRES_TUPLES_OK ) return NULL;

        // The result should be in the first row of the first column
        int revision_id=atoi(PQgetvalue(res,0,0));

        PQclear(res);

        return revision_id;
}


int db_init(char *host, int port, char *dbname, char *username, char *password){
        char pq_request[BUFFER_SIZE];
        sprintf(pq_request,"host=%s port=%i dbname=%s user=%s password=%s", host, port, dbname, username, password);
        pq_conn=PQconnectdb(pq_request);
        
        NUM_FILE_FIELDS = 0;
        NUM_DIR_FIELDS = 0;
        NUM_STREAM_FIELDS = 0;

        if( PQstatus( pq_conn ) != CONNECTION_OK )
                return -1;
        else
                return 0;
}


int db_destroy(){
        PQfinish(pq_conn);
        return 0;
}


stream_t *db_get_stream( int stream_id ){
        stream_t *stat=malloc(sizeof(stream_t));

        char pq_request[BUFFER_SIZE];
        sprintf(pq_request,"SELECT * "
                           "FROM stream "
                           "WHERE stream_id = \'%i\'",
                           stream_id);
        PGresult *res=PQexec(pq_conn,pq_request);

        if( !NUM_STREAM_FIELDS ){
                NUM_STREAM_FIELDS = sizeof(stream_format)/4;

                if( PQnfields(res) != NUM_STREAM_FIELDS ){
                        NUM_STREAM_FIELDS = 0;
                        return NULL;
                }

        // Fill stream_format with column numbers
#define db_int(name)    stream_format.name = PQfnumber(res, #name );
#define db_long(name)   stream_format.name = PQfnumber(res, #name );
#define db_string(name) stream_format.name = PQfnumber(res, #name );
#include "stream.db"
        }

        if( PQresultStatus(res) != PGRES_TUPLES_OK ) return NULL;
        
        if( PQnfields(res) != NUM_STREAM_FIELDS ) return NULL;

        // Fill stat
#define db_int(name)    stat->name = atoi(PQgetvalue(res, 0, stream_format.name ));
#define db_long(name)   stat->name = atol(PQgetvalue(res, 0, stream_format.name ));
#define db_string(name) stat->name = strdup(PQgetvalue(res, 0, stream_format.name ));
#include "stream.db"
        
        PQclear(res);

        return stat;
}

int db_get_stream_max_id(){
        PGresult *res=PQexec(pq_conn,"SELECT MAX(stream_id) FROM stream");

        if( PQresultStatus(res) != PGRES_TUPLES_OK ) return NULL;

        int stream_id=atoi(PQgetvalue(res,0,0));

        PQclear(res);

        return stream_id;
}