UserNode.c

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