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) {
 201                 //nick only
 202                 user = malloc(sizeof(*user));
 203                 if (!user)
 204                 {
 205                     perror("malloc() failed");
 206                     return NULL;
 207                 }
 208                 strcpy(user->nick, cmask);
 209                 user->created = time(0);
 210                 user->ident[0] = 0;
 211                 user->host[0] = 0;
 212                 user->realname[0] = 0;
 213                 user->flags = 0;
 214                 user->channel = NULL;
 215                 return user;
 216             }
 217             strcpy(user->host, &cmask[ii]);
 218         }
 219     }
 220     return user;
 221 }
 222
 223 int renameUser(struct UserNode* user, const char *new_nick) {
 224     if(!is_valid_nick(new_nick))
 225         return 0;
 226     if(user->nick[0] == *new_nick) {
 227         strcpy(user->nick, new_nick);
 228         return 1;
 229     }
 230     int userListIndex = get_nicklist_entry(*new_nick);
 231     delUser(user, 0);
 232     strcpy(user->nick, new_nick);
 233     user->next = userList[userListIndex];
 234     userList[userListIndex] = user;
 235     return 1;
 236 }
 237
 238 void delUser(struct UserNode* user, int freeUser) {
 239     int userListIndex = get_nicklist_entry(user->nick[0]);
 240     if(userListIndex == -1) return;
 241     struct UserNode *cuser, *last_user = NULL;
 242     for(cuser = userList[userListIndex]; cuser; cuser = cuser->next) {
 243         if(cuser == user) {
 244             if(last_user)
 245                 last_user->next = user->next;
 246             else
 247                 userList[userListIndex] = user->next;
 248             break;
 249         } else
 250             last_user = cuser;
 251     }
 252     if(user->channel) {
 253         struct ChanUser *chanUser, *next;
 254         for(chanUser = user->channel; chanUser; chanUser = next) {
 255             next = chanUser->next_chan;
 256             removeChanUserFromLists(chanUser, 1, 0, freeUser);
 257         }
 258     }
 259     if(freeUser)
 260         free(user);
 261     else
 262         user->next = NULL;
 263 }
 264
 265 void clearTempUsers() {
 266     int userListIndex = TEMPUSER_LIST_INDEX;
 267     struct UserNode *cuser, *last_user = NULL, *next;
 268     time_t now = time(0);
 269     for(cuser = userList[userListIndex]; cuser; cuser = next) {
 270         next = cuser->next;
 271         if(cuser->flags & USERFLAG_FREETMPUSER || now - cuser->created >= 300) {
 272             if(last_user)
 273                 last_user->next = cuser->next;
 274             else
 275                 userList[userListIndex] = cuser->next;
 276             break;
 277         } else
 278             last_user = cuser;
 279     }
 280 }
 281
 282
 283 void load_user_settings(struct UserNode *user) {
 284     if(!(user->flags & USERFLAG_ISAUTHED) || (user->flags & USERFLAG_LOADED_SETTINGS))
 285         return;
 286     check_mysql();
 287     MYSQL_RES *res;
 288     MYSQL_ROW row;
 289     printf_mysql_query("SELECT `user_lang`, `user_reply_privmsg`, `user_god` FROM `users` WHERE `user_user` = '%s'", escape_string(user->auth));
 290     res = mysql_use();
 291     if ((row = mysql_fetch_row(res)) != NULL) {
 292         user->language = get_language_by_tag(row[0]);
 293         if(user->language == NULL) user->language = get_default_language();
 294         if(strcmp(row[1], "0"))
 295             user->flags |= USERFLAG_REPLY_PRIVMSG;
 296         if(strcmp(row[2], "0"))
 297             user->flags |= USERFLAG_GOD_MODE;
 298     } else
 299         user->language = get_default_language();
 300     user->flags |= USERFLAG_LOADED_SETTINGS;
 301 }
 302
 303 int isGodMode(struct UserNode *user) {
 304     load_user_settings(user);
 305     return (user->flags & USERFLAG_GOD_MODE);
 306 }