UserNode.c

   1 #include "UserNode.h"
   2 #include "ChanUser.h"
   3
   4 static struct UserNode **userList;
   5
   6 void init_UserNode() {
   7     userList = calloc(VALID_NICK_CHARS_FIRST_LEN+1, sizeof(*userList));
   8 }
   9
  10 void free_UserNode() {
  11     //kamikaze free all users
  12     //chanusers will be destroyed in free_ChanNode()
  13     int i;
  14     struct UserNode *user, *next;
  15     for(i = 0; i < VALID_NICK_CHARS_FIRST_LEN+1; i++) {
  16         for(user = userList[i]; user; user = next) {
  17             next = user->next;
  18             free(user);
  19         }
  20     }
  21     free(userList);
  22 }
  23
  24 int is_valid_nick(const char *nick) {
  25     unsigned int i;
  26     //first char must be one of: a-zA-Z{|}~[\]^_`
  27     if (!strchr(VALID_NICK_CHARS_FIRST, *nick))
  28         return 0;
  29     //all other chars must be one of: a-zA-Z0-9{|}~[\]^_`
  30     for (i = 0; nick[i]; ++i)
  31         if (!strchr(VALID_NICK_CHARS, nick[i]))
  32             return 0;
  33     if (strlen(nick) > NICKLEN)
  34         return 0;
  35     return 1;
  36 }
  37
  38 static int get_nicklist_entry(int nick) {
  39     int i;
  40     char *valid_chars = VALID_NICK_CHARS_FIRST;
  41     for(i = 0; i < VALID_NICK_CHARS_FIRST_LEN; i++) {
  42         if(valid_chars[i] == nick)
  43             return i;
  44     }
  45     return -1; //ERROR!
  46 }
  47
  48 struct UserNode* getUserByNick(const char *nick) { //case sensitive
  49     int userListIndex = get_nicklist_entry(*nick);
  50     if(userListIndex == -1 || userList[userListIndex] == NULL)
  51         return NULL;
  52     struct UserNode *user;
  53     for(user = userList[userListIndex]; user; user = user->next) {
  54         if(!stricmp(nick, user->nick))
  55             return user;
  56     }
  57     return NULL;
  58 }
  59
  60 struct UserNode* getUserByMask(const char *mask) { //case sensitive
  61     char cmask[strlen(mask)+1];
  62     strcpy(cmask, mask);
  63     int i;
  64     struct UserNode *user = NULL;
  65     for(i = 0; i < strlen(mask); i++) {
  66         if(cmask[i] == '!') {
  67             cmask[i] = 0;
  68             user = getUserByNick(&cmask[0]);
  69             return user;
  70         } else if(cmask[i] == '.') {
  71             //it's a server
  72             return NULL;
  73         }
  74     }
  75     return NULL;
  76 }
  77
  78 struct UserNode* searchUserByNick(const char *nick) { //case insensitive
  79     if(!isalpha(*nick))
  80         return getUserByNick(nick);
  81
  82     int userListIndex;
  83     struct UserNode *user;
  84
  85     //search in the lower case "section"
  86     userListIndex = get_nicklist_entry(tolower(*nick));
  87     if(userListIndex != -1 && userList[userListIndex] != NULL) {
  88         for(user = userList[userListIndex]; user; user = user->next) {
  89             if(!stricmp(nick, user->nick))
  90                 return user;
  91         }
  92     }
  93     //search in the upper case "section"
  94     userListIndex = get_nicklist_entry(toupper(*nick));
  95     if(userListIndex != -1 && userList[userListIndex] != NULL) {
  96         for(user = userList[userListIndex]; user; user = user->next) {
  97             if(!stricmp(nick, user->nick))
  98                 return user;
  99         }
 100     }
 101     return NULL;
 102 }
 103
 104 struct UserNode* addUser(const char *nick) {
 105     int userListIndex = get_nicklist_entry(*nick);
 106     if(userListIndex == -1 || !is_valid_nick(nick))
 107         return NULL;
 108     struct UserNode *user = malloc(sizeof(*user));
 109     if (!user)
 110     {
 111         perror("malloc() failed");
 112         return NULL;
 113     }
 114     strcpy(user->nick, nick);
 115     user->created = time(0);
 116     user->ident[0] = 0;
 117     user->host[0] = 0;
 118     user->realname[0] = 0;
 119     user->flags = 0;
 120     user->channel = NULL;
 121     user->next = userList[userListIndex];
 122     userList[userListIndex] = user;
 123     return user;
 124 }
 125
 126 struct UserNode* addUserMask(const char *mask) {
 127     char cmask[strlen(mask)+1];
 128     strcpy(cmask, mask);
 129     int i, ii = 0;
 130     struct UserNode *user = NULL;
 131     for(i = 0; i < strlen(mask)+1; i++) {
 132         if(cmask[i] == '!') {
 133             cmask[i] = 0;
 134             user = addUser(cmask);
 135             if(user == NULL) return NULL;
 136             ii = i+1;
 137         } else if(cmask[i] == '.' && !user) {
 138             //it's a server
 139             return NULL;
 140         } else if(cmask[i] == '@') {
 141             if(user == NULL) return NULL;
 142             cmask[i] = 0;
 143             strcpy(user->ident, &cmask[ii]);
 144             ii = i+1;
 145         } else if(cmask[i] == '\0') {
 146             if(user == NULL) return NULL;
 147             strcpy(user->host, &cmask[ii]);
 148         }
 149     }
 150     return user;
 151 }
 152
 153 struct UserNode* createTempUser(const char *mask) {
 154     //note: it could also be a server we have to create a temponary user for...
 155     char cmask[strlen(mask)+1];
 156     strcpy(cmask, mask);
 157     int i, ii = 0;
 158     struct UserNode *user = NULL;
 159     for(i = 0; i < strlen(mask)+1; i++) {
 160         if(cmask[i] == '!') {
 161             cmask[i] = 0;
 162             user = malloc(sizeof(*user));
 163             if (!user)
 164             {
 165                 perror("malloc() failed");
 166                 return NULL;
 167             }
 168             strcpy(user->nick, cmask);
 169             user->created = time(0);
 170             user->ident[0] = 0;
 171             user->host[0] = 0;
 172             user->realname[0] = 0;
 173             user->flags = 0;
 174             user->channel = NULL;
 175             ii = i+1;
 176         } else if(cmask[i] == '.' && !user) {
 177             //it's a server
 178             user = malloc(sizeof(*user));
 179             if (!user)
 180             {
 181                 perror("malloc() failed");
 182                 return NULL;
 183             }
 184             strcpy(user->host, cmask);
 185             user->created = time(0);
 186             user->ident[0] = 0;
 187             user->host[0] = 0;
 188             user->realname[0] = 0;
 189             user->flags = USERFLAG_ISSERVER;
 190             user->channel = NULL;
 191             return user;
 192         } else if(cmask[i] == '@') {
 193             if(user == NULL) return NULL;
 194             cmask[i] = 0;
 195             strcpy(user->ident, &cmask[ii]);
 196             ii = i+1;
 197         } else if(cmask[i] == '\0') {
 198             if(user == NULL) {
 199                 //nick only
 200                 user = malloc(sizeof(*user));
 201                 if (!user)
 202                 {
 203                     perror("malloc() failed");
 204                     return NULL;
 205                 }
 206                 strcpy(user->nick, cmask);
 207                 user->created = time(0);
 208                 user->ident[0] = 0;
 209                 user->host[0] = 0;
 210                 user->realname[0] = 0;
 211                 user->flags = 0;
 212                 user->channel = NULL;
 213                 return user;
 214             }
 215             strcpy(user->host, &cmask[ii]);
 216         }
 217     }
 218     return user;
 219 }
 220
 221 int renameUser(struct UserNode* user, const char *new_nick) {
 222     if(!is_valid_nick(new_nick))
 223         return 0;
 224     if(user->nick[0] == *new_nick) {
 225         strcpy(user->nick, new_nick);
 226         return 1;
 227     }
 228     int userListIndex = get_nicklist_entry(*new_nick);
 229     delUser(user, 0);
 230     strcpy(user->nick, new_nick);
 231     user->next = userList[userListIndex];
 232     userList[userListIndex] = user;
 233     return 1;
 234 }
 235
 236 void delUser(struct UserNode* user, int freeUser) {
 237     int userListIndex = get_nicklist_entry(user->nick[0]);
 238     if(userListIndex == -1) return;
 239     struct UserNode *cuser, *last_user = NULL;
 240     for(cuser = userList[userListIndex]; cuser; cuser = cuser->next) {
 241         if(cuser == user) {
 242             if(last_user)
 243                 last_user->next = user->next;
 244             else
 245                 userList[userListIndex] = user->next;
 246             break;
 247         } else
 248             last_user = cuser;
 249     }
 250     if(user->channel) {
 251         struct ChanUser *chanUser, *next;
 252         for(chanUser = user->channel; chanUser; chanUser = next) {
 253             next = chanUser->next_chan;
 254             removeChanUserFromLists(chanUser, 1, 0, freeUser);
 255         }
 256     }
 257     if(freeUser)
 258         free(user);
 259     else
 260         user->next = NULL;
 261 }
 262
 263 void clearTempUsers() {
 264     int userListIndex = TEMPUSER_LIST_INDEX;
 265     struct UserNode *cuser, *last_user = NULL, *next;
 266     time_t now = time(0);
 267     for(cuser = userList[userListIndex]; cuser; cuser = next) {
 268         next = cuser->next;
 269         if(cuser->flags & USERFLAG_FREETMPUSER || now - cuser->created >= 300) {
 270             if(last_user)
 271                 last_user->next = cuser->next;
 272             else
 273                 userList[userListIndex] = cuser->next;
 274             break;
 275         } else
 276             last_user = cuser;
 277     }
 278 }