diff --git a/CMakeLists.txt b/CMakeLists.txt index 59c33c5..1b9bed9 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -17,7 +17,7 @@ link_directories("/usr/local/lib") add_compile_options(-std=gnu99) message(STATUS "optional:-std=gnu99") -add_executable(simple-dict-server server.c dict.c crypto.c) +add_executable(simple-dict-server server.c crypto.c) add_executable(simple-dict-client client.c crypto.c) add_executable(cfgwriter cfgwriter.c) #add_executable(migrate migrate.c) diff --git a/dict.c b/dict.c deleted file mode 100644 index ee11c7f..0000000 --- a/dict.c +++ /dev/null @@ -1,128 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include "dict.h" -#include "server.h" - -static char* filepath; -static uint8_t dict_md5[16]; - -static FILE* fp = NULL; //fp for EX -static FILE* fp_read = NULL; //fp for md5 -static FILE* thread_fp[THREADCNT]; - -#ifdef CPUBIT64 - #define _dict_md5_2 ((uint64_t*)&dict_md5) -#else - #define _dict_md5_4 ((uint32_t*)&dict_md5) -#endif - -int fill_md5(pthread_rwlock_t* mu) { - size_t size = get_dict_size(mu); - if(!size) { - memset(dict_md5, 0, 16); - puts("Dict is empty, use all zero md5"); - return 0; - } - uint8_t* dict_buff = (uint8_t*)malloc(size); - if(dict_buff) { - if(pthread_rwlock_tryrdlock(mu)) { - perror("Readlock busy: "); - return 1; - } - rewind(fp_read); - if(fread(dict_buff, size, 1, fp_read) == 1) { - pthread_rwlock_unlock(mu); - md5(dict_buff, size, dict_md5); - free(dict_buff); - return 0; - } else { - pthread_rwlock_unlock(mu); - free(dict_buff); - perror("Read dict error: "); - return 2; - } - } else { - perror("Allocate memory error: "); - return 3; - } -} - -int init_dict(char* file_path, pthread_rwlock_t* mu) { - fp = fopen(file_path, "rb+"); - fp_read = fopen(file_path, "rb"); - if(fp) { - int err = pthread_rwlock_init(mu, NULL); - if(err) { - perror("Init lock error: "); - return 1; - } - filepath = file_path; - return fill_md5(mu); - } - perror("Open dict error: "); - return 2; -} - -FILE* open_dict(uint8_t lock_type, uint32_t index, pthread_rwlock_t* mu) { - if(lock_type & DICT_LOCK_EX) { - if(pthread_rwlock_trywrlock(mu)) { - puts("Open dict: Writelock busy"); - return NULL; - } - if(!fp) fp = fopen(filepath, "rb+"); - else rewind(fp); - return fp; - } - if(index >= THREADCNT) { - puts("Open dict: Index out of bounds"); - return NULL; - } - if(pthread_rwlock_tryrdlock(mu)) { - puts("Open dict: Readlock busy"); - return NULL; - } - if(!thread_fp[index]) thread_fp[index] = fopen(filepath, "rb"); - else rewind(thread_fp[index]); - return thread_fp[index]; -} - -FILE* get_dict_fp_wr() { - return fp; -} - -FILE* get_dict_fp_rd() { - rewind(fp_read); - return fp_read; -} - -void close_dict(uint8_t lock_type, uint32_t index, pthread_rwlock_t* mu) { - if(lock_type & DICT_LOCK_EX) fflush(fp); - pthread_rwlock_unlock(mu); - puts("Close dict"); -} - -off_t get_dict_size() { - struct stat statbuf; - if(stat(filepath, &statbuf)==0) { - return statbuf.st_size; - } - return -1; -} - -int is_md5_equal(uint8_t* digest) { - #ifdef CPUBIT64 - uint64_t* digest2 = (uint64_t*)digest; - return (digest2[0] == _dict_md5_2[0]) && - (digest2[1] == _dict_md5_2[1]); - #else - uint32_t* digest4 = (uint32_t*)digest; - return (digest4[0] == _dict_md5_4[0]) && - (digest4[1] == _dict_md5_4[1]) && - (digest4[2] == _dict_md5_4[2]) && - (digest4[3] == _dict_md5_4[3]); - #endif -} diff --git a/dict.h b/dict.h index 4fa140c..d6dc5d9 100644 --- a/dict.h +++ b/dict.h @@ -2,6 +2,14 @@ #define _DICT_H_ #include +#include +#include +#include +#include +#include +#include +#include "dict.h" +#include "server.h" #define DICTKEYSZ 127 #define DICTDATSZ 127 @@ -17,13 +25,124 @@ typedef struct DICT DICT; #define DICT_LOCK_EX 0x02 #define DICT_LOCKING_EX 0x04 -void close_dict(uint8_t lock_type, uint32_t index, pthread_rwlock_t* mu); -int fill_md5(pthread_rwlock_t* mu); -int init_dict(char* file_path, pthread_rwlock_t* mu); -int is_md5_equal(uint8_t* digest); -FILE* get_dict_fp_rd(); -FILE* get_dict_fp_wr(); -off_t get_dict_size(); -FILE* open_dict(uint8_t lock_type, uint32_t index, pthread_rwlock_t* mu); +static char* dict_filepath; +static uint8_t dict_md5[16]; + +static FILE* dict_fp = NULL; //fp for EX +static FILE* dict_fp_read = NULL; //fp for md5 +static FILE* dict_thread_fp[THREADCNT]; + +#ifdef CPUBIT64 + #define _dict_md5_2 ((uint64_t*)&dict_md5) +#else + #define _dict_md5_4 ((uint32_t*)&dict_md5) +#endif + +static off_t get_dict_size() { + struct stat statbuf; + if(stat(dict_filepath, &statbuf)==0) { + return statbuf.st_size; + } + return -1; +} + +static int fill_md5(pthread_rwlock_t* mu) { + size_t size = get_dict_size(); + if(!size) { + memset(dict_md5, 0, 16); + puts("Dict is empty, use all zero md5"); + return 0; + } + uint8_t* dict_buff = (uint8_t*)malloc(size); + if(dict_buff) { + if(pthread_rwlock_tryrdlock(mu)) { + perror("Readlock busy: "); + return 1; + } + rewind(dict_fp_read); + if(fread(dict_buff, size, 1, dict_fp_read) == 1) { + pthread_rwlock_unlock(mu); + md5(dict_buff, size, dict_md5); + free(dict_buff); + return 0; + } else { + pthread_rwlock_unlock(mu); + free(dict_buff); + perror("Read dict error: "); + return 2; + } + } else { + perror("Allocate memory error: "); + return 3; + } +} + +static int init_dict(char* file_path, pthread_rwlock_t* mu) { + dict_fp = fopen(file_path, "rb+"); + dict_fp_read = fopen(file_path, "rb"); + if(dict_fp) { + int err = pthread_rwlock_init(mu, NULL); + if(err) { + perror("Init lock error: "); + return 1; + } + dict_filepath = file_path; + return fill_md5(mu); + } + perror("Open dict error: "); + return 2; +} + +static FILE* open_dict(uint8_t lock_type, uint32_t index, pthread_rwlock_t* mu) { + if(lock_type & DICT_LOCK_EX) { + if(pthread_rwlock_trywrlock(mu)) { + puts("Open dict: Writelock busy"); + return NULL; + } + if(!dict_fp) dict_fp = fopen(dict_filepath, "rb+"); + else rewind(dict_fp); + return dict_fp; + } + if(index >= THREADCNT) { + puts("Open dict: Index out of bounds"); + return NULL; + } + if(pthread_rwlock_tryrdlock(mu)) { + puts("Open dict: Readlock busy"); + return NULL; + } + if(!dict_thread_fp[index]) dict_thread_fp[index] = fopen(dict_filepath, "rb"); + else rewind(dict_thread_fp[index]); + return dict_thread_fp[index]; +} + +static FILE* get_dict_fp_wr() { + return dict_fp; +} + +static FILE* get_dict_fp_rd() { + rewind(dict_fp_read); + return dict_fp_read; +} + +static void close_dict(uint8_t lock_type, uint32_t index, pthread_rwlock_t* mu) { + if(lock_type & DICT_LOCK_EX) fflush(dict_fp); + pthread_rwlock_unlock(mu); + puts("Close dict"); +} + +static inline int is_md5_equal(uint8_t* digest) { + #ifdef CPUBIT64 + uint64_t* digest2 = (uint64_t*)digest; + return (digest2[0] == _dict_md5_2[0]) && + (digest2[1] == _dict_md5_2[1]); + #else + uint32_t* digest4 = (uint32_t*)digest; + return (digest4[0] == _dict_md5_4[0]) && + (digest4[1] == _dict_md5_4[1]) && + (digest4[2] == _dict_md5_4[2]) && + (digest4[3] == _dict_md5_4[3]); + #endif +} #endif \ No newline at end of file diff --git a/server.c b/server.c index 47ff1d0..9cd3c1e 100644 --- a/server.c +++ b/server.c @@ -65,7 +65,7 @@ static void handle_int(int signo); static void handle_pipe(int signo); static void handle_quit(int signo); static void init_dict_pool(FILE *fp); -static void kill_thread(THREADTIMER* timer); +static void cleanup_thread(THREADTIMER* timer); static uint32_t last_nonnull(char* p, uint32_t max_size); static int listen_socket(); static int send_all(THREADTIMER *timer); @@ -304,10 +304,9 @@ static int s3_set_data(THREADTIMER *timer) { if(!set_pb(get_dict_fp_wr(), items_len, sizeof(DICT), setdict)) { fprintf(stderr, "Error set data: dict[%s]=%s\n", setdict->key, timer->dat); return close_and_send(timer, ACKERRO, "erro", 4); - } else { - printf("Set data: dict[%s]=%s\n", setdict->key, timer->dat); - return close_and_send(timer, ACKSUCC, "succ", 4); } + printf("Set data: dict[%s]=%s\n", setdict->key, timer->dat); + return close_and_send(timer, ACKSUCC, "succ", 4); } static enum SERVERACK del(FILE *fp, char* key, int len, char ret[4]) { @@ -413,8 +412,8 @@ static void accept_timer(void *p) { } } -static void kill_thread(THREADTIMER* timer) { - puts("Start killing"); +static void cleanup_thread(THREADTIMER* timer) { + puts("Start cleaning"); accept_threads[timer->index] = 0; if(timer->accept_fd) { close(timer->accept_fd); @@ -427,7 +426,7 @@ static void kill_thread(THREADTIMER* timer) { puts("Free data"); } if(timer->lock_type) close_dict(timer->lock_type, timer->index, &mu); - puts("Finish killing"); + puts("Finish cleaning"); } static void handle_int(int signo) { @@ -445,11 +444,11 @@ static void handle_accept(void *p) { pthread_t thread; if (pthread_create(&thread, &attr, (void *)&accept_timer, p)) { perror("Error creating timer thread: "); - kill_thread(timer_pointer_of(p)); + cleanup_thread(timer_pointer_of(p)); return; } puts("Creating timer thread succeeded"); - pthread_cleanup_push((void*)&kill_thread, p); + pthread_cleanup_push((void*)&cleanup_thread, p); int accept_fd = timer_pointer_of(p)->accept_fd; uint32_t index = timer_pointer_of(p)->index; char *buff = malloc(BUFSIZ*sizeof(char)); @@ -569,6 +568,7 @@ static void accept_client() { } signal(SIGINT, handle_int); signal(SIGQUIT, handle_quit); + signal(SIGKILL, exit); signal(SIGPIPE, handle_pipe); pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); @@ -612,7 +612,7 @@ static void accept_client() { reset_seq(p); if (pthread_create(accept_threads + p, &attr, (void *)&handle_accept, timer)) { perror("Error creating thread: "); - kill_thread(timer); + cleanup_thread(timer); continue; } puts("Creating thread succeeded");