hash.h

  1. #ifndef HASH_H 
  2. #define HASH_H              1 
  3.  
  4. #include <stdio.h> 
  5. #include <time.h> 
  6. #include <string.h> 
  7. #include <malloc.h> 
  8. #include <list.h> 
  9.  
  10. #define NMN_USER_HASH_LIST_MAX      1024 
  11.  
  12. struct user { 
  13.     struct hlist_node   sibling; 
  14.     char            username[32]; 
  15. /* 
  16.  *  char            userpwd[NMN_VALUE_MAX_LEN]; 
  17.  */ 
  18.     time_t          starttime; 
  19.     time_t          endtime; 
  20. }; 
  21.  
  22. extern int user_count; 
  23. extern int hash_test[NMN_USER_HASH_LIST_MAX]; 
  24. extern struct hlist_head hash_listhead[NMN_USER_HASH_LIST_MAX]; 
  25. /* 
  26. int str2user(struct user *user_entry, const char *username, const char *userpwd); 
  27. int user2str(char *buf, int buf_len, const struct user *user_entry); 
  28. //*/ 
  29. int read_users_list(const char *file_path); 
  30. struct user *user_hash_get(const char *username); 
  31. //#undef HASH_LIST_MAX 
  32.  
  33.  
  34.  
  35. #endif /* HASH_H */ 

hash.c

  1. #include <hash.h> 
  2. struct hlist_head hash_listhead[NMN_USER_HASH_LIST_MAX]; 
  3. int user_count; 
  4. static unsigned int bkdrhash(const char *str) 
  5. { 
  6.     unsigned int seed = 1313; //13 131 1313 13131 131313 etc... 
  7.     unsigned int hash = 0; 
  8.     while(*str) { 
  9.         hash = hash * seed + (unsigned int)(*str++); 
  10.     } 
  11.     return hash & 0x7FFFFFFF; 
  12. } 
  13. static int get_name_hash_index(const char *username) 
  14. { 
  15.     unsigned int key = bkdrhash(username); 
  16.     int index = key & (NMN_USER_HASH_LIST_MAX-1); 
  17.     return index; 
  18. } 
  19. static int user_hash_push(struct user *entry) 
  20. { 
  21.     int index = get_name_hash_index(entry->username); 
  22.     hlist_add_head(&entry->sibling, &hash_listhead[index]); 
  23.     return 0; 
  24. } 
  25. /* 
  26. static int user_cmp(const struct user *a, const struct user *b) 
  27. { 
  28.     return strcmp(a->username, b->username); 
  29. } 
  30. //*/ 
  31. struct user *user_hash_get(const char *username) 
  32. { 
  33.     struct user *tpos; 
  34.     struct user *ret = NULL; 
  35.     struct hlist_node *pos; 
  36.     int index = get_name_hash_index(username); 
  37.     hlist_for_each_entry(tpos, pos, &hash_listhead[index], sibling) { 
  38.         fprintf(stdout, "username=%s...\n", tpos->username); 
  39.         if(0==strcmp(username, tpos->username)) { 
  40.             ret = tpos; 
  41.             break; 
  42.         } 
  43.     } 
  44.     return ret; 
  45. } 
  46. /* 
  47. static int line2user(struct user *entry, const char *line) 
  48. { 
  49.     sscanf(line, "%s Cleartext-Password := \"%[^\"]%*[ #\"]%ld-%ld", 
  50.                  entry->username, entry->userpwd, &entry->starttime, &entry->endtime); 
  51.     return 0; 
  52. } 
  53. //*/ 
  54. /* without userpwd */ 
  55. static int line2user(struct user *entry, const char *line) 
  56. { 
  57.     return sscanf(line, "%s Cleartext-Password := \"%*[^\"]%*[ #\"]%ld-%ld", 
  58.                  entry->username, &entry->starttime, &entry->endtime); 
  59. } 
  60. int read_users_list(const char *dir_path) 
  61. { 
  62.     int ret = 0; 
  63.     user_count = 0; 
  64.     char file_path[1024]; 
  65.     snprintf(file_path, sizeof(file_path), "%s", dir_path); 
  66.     FILE *fp = fopen(file_path, "r"); 
  67.     if(NULL==fp) { 
  68.         return -1; 
  69.     } 
  70.     char line[1024]; 
  71.     struct user *entry; 
  72.     while(NULL != (fgets(line, sizeof(line), fp))) { 
  73.         if(('#'==*line) || (!strstr(line, "Cleartext-Password"))) { 
  74.             continue; 
  75.         } 
  76.         entry = (struct user *)malloc(sizeof(struct user)); 
  77.         if(!entry) { 
  78.             ret = -1; 
  79.             break; 
  80.         } 
  81.         line2user(entry, line); 
  82.         user_hash_push(entry); 
  83.         ++user_count; 
  84.     } 
  85.     fclose(fp); 
  86.     return ret; 
  87. } 
  88. /* no free hash list method */