1 /* UserNode.c - NeonServ v5.3
2 * Copyright (C) 2011-2012 Philipp Kreil (pk910)
4 * This program is free software: you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published by
6 * the Free Software Foundation, either version 3 of the License, or
7 * (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 #include "IRCEvents.h"
23 static struct UserNode **userList;
25 void init_UserNode() {
26 userList = calloc(VALID_NICK_CHARS_FIRST_LEN+1, sizeof(*userList));
29 void free_UserNode() {
30 //kamikaze free all users
31 //chanusers will be destroyed in free_ChanNode()
33 struct UserNode *user, *next;
34 for(i = 0; i < VALID_NICK_CHARS_FIRST_LEN+1; i++) {
35 for(user = userList[i]; user; user = next) {
43 int is_valid_nick(const char *nick) {
45 //first char must be one of: a-zA-Z{|}~[\]^_`
46 if (!strchr(VALID_NICK_CHARS_FIRST, *nick))
48 //all other chars must be one of: a-zA-Z0-9{|}~[\]^_`
49 for (i = 0; nick[i]; ++i)
50 if (!strchr(VALID_NICK_CHARS, nick[i]))
52 if (strlen(nick) > NICKLEN)
57 static int get_nicklist_entry(int nick) {
59 char *valid_chars = VALID_NICK_CHARS_FIRST;
60 for(i = 0; i < VALID_NICK_CHARS_FIRST_LEN; i++) {
61 if(valid_chars[i] == nick)
67 struct UserNode* getUserByNick(const char *nick) { //case sensitive
68 int userListIndex = get_nicklist_entry(*nick);
69 if(userListIndex == -1 || userList[userListIndex] == NULL)
71 struct UserNode *user;
72 for(user = userList[userListIndex]; user; user = user->next) {
73 if(!stricmp(nick, user->nick))
79 struct UserNode* getUserByMask(const char *mask) { //case sensitive
80 char cmask[strlen(mask)+1];
83 struct UserNode *user = NULL;
84 for(i = 0; i < strlen(mask); i++) {
87 user = getUserByNick(&cmask[0]);
89 } else if(cmask[i] == '.') {
97 struct UserNode* searchUserByNick(const char *nick) { //case insensitive
99 return getUserByNick(nick);
102 struct UserNode *user;
104 //search in the lower case "section"
105 userListIndex = get_nicklist_entry(tolower(*nick));
106 if(userListIndex != -1 && userList[userListIndex] != NULL) {
107 for(user = userList[userListIndex]; user; user = user->next) {
108 if(!stricmp(nick, user->nick))
112 //search in the upper case "section"
113 userListIndex = get_nicklist_entry(toupper(*nick));
114 if(userListIndex != -1 && userList[userListIndex] != NULL) {
115 for(user = userList[userListIndex]; user; user = user->next) {
116 if(!stricmp(nick, user->nick))
123 int countUsersWithHost(char *host) {
125 struct UserNode *user;
126 for(i = 0; i < VALID_NICK_CHARS_FIRST_LEN; i++) {
127 for(user = userList[i]; user; user = user->next) {
128 if(!strcmp(user->host, host)) {
136 char *getAuthFakehost(char *auth) {
138 struct UserNode *user;
139 for(i = 0; i < VALID_NICK_CHARS_FIRST_LEN; i++) {
140 for(user = userList[i]; user; user = user->next) {
141 if((user->flags & USERFLAG_ISAUTHED) && !strcmp(user->auth, auth) && isFakeHost(user->host)) {
149 struct UserNode* getAllUsers(struct UserNode *last) {
150 if(last == NULL || last->next == NULL) {
155 cindex = get_nicklist_entry(last->nick[0]) + 1;
156 while(userList[cindex] == NULL && cindex < VALID_NICK_CHARS_FIRST_LEN)
158 if(cindex > VALID_NICK_CHARS_FIRST_LEN) return NULL;
159 return userList[cindex];
164 struct UserNode* getUsersWithAuth(const char *auth, struct UserNode *last) {
165 int cindex = (last ? get_nicklist_entry(last->nick[0]) : 0);
166 struct UserNode *cuser = last;
167 while(cindex <= VALID_NICK_CHARS_FIRST_LEN) {
168 for(cuser = (cuser ? cuser->next : userList[cindex]); cuser; cuser = cuser->next) {
169 if((cuser->flags & USERFLAG_ISAUTHED) && !strcmp(cuser->auth, auth))
180 struct UserNode *user;
181 for(i = 0; i < VALID_NICK_CHARS_FIRST_LEN; i++) {
182 for(user = userList[i]; user; user = user->next) {
189 struct UserNode* addUser(const char *nick) {
190 int userListIndex = get_nicklist_entry(*nick);
191 if(userListIndex == -1 || !is_valid_nick(nick))
193 struct UserNode *user = malloc(sizeof(*user));
196 perror("malloc() failed");
199 strcpy(user->nick, nick);
200 user->created = time(0);
204 user->realname[0] = 0;
206 user->channel = NULL;
208 user->next = userList[userListIndex];
209 userList[userListIndex] = user;
213 struct UserNode* addUserMask(const char *mask) {
214 char cmask[strlen(mask)+1];
217 struct UserNode *user = NULL;
218 for(i = 0; i < strlen(mask)+1; i++) {
219 if(cmask[i] == '!') {
221 user = addUser(cmask);
222 if(user == NULL) return NULL;
224 } else if(cmask[i] == '.' && !user) {
227 } else if(cmask[i] == '@') {
228 if(user == NULL) return NULL;
230 strcpy(user->ident, &cmask[ii]);
232 } else if(cmask[i] == '\0') {
233 if(user == NULL) return NULL;
234 strcpy(user->host, &cmask[ii]);
240 struct UserNode* createTempUser(const char *nick) {
241 int already_on_list = 0;
242 struct UserNode *user = NULL;
243 if(!is_valid_nick(nick)) {
246 for(user = userList[TEMPUSER_LIST_INDEX]; user; user = user->next) {
247 if(!stricmp(user->nick, nick)) {
253 user = malloc(sizeof(*user));
255 perror("malloc() failed");
261 user->realname[0] = 0;
263 user->channel = NULL;
266 user->flags &= ~USERFLAG_FREETMPUSER;
267 user->created = time(0);
268 if(user->created - user->last_who > REWHO_TIMEOUT)
269 user->flags &= ~USERFLAG_ISAUTHED; //remove authed flag (security reasons)
270 strcpy(user->nick, nick);
271 if(!already_on_list) {
272 user->next = userList[TEMPUSER_LIST_INDEX];
273 userList[TEMPUSER_LIST_INDEX] = user;
278 struct UserNode* createTempUserMask(const char *mask) {
279 //note: it could also be a server we have to create a temponary user for...
280 char cmask[strlen(mask)+1];
283 int already_on_list = 0;
284 struct UserNode *user = NULL;
285 for(i = 0; i < strlen(mask)+1; i++) {
286 if(cmask[i] == '!') {
288 if(!is_valid_nick(cmask)) {
291 for(user = userList[TEMPUSER_LIST_INDEX]; user; user = user->next) {
292 if(!stricmp(user->nick, cmask)) {
298 user = malloc(sizeof(*user));
300 perror("malloc() failed");
306 user->realname[0] = 0;
308 user->channel = NULL;
311 user->flags &= ~USERFLAG_FREETMPUSER;
312 user->created = time(0);
313 if(user->created - user->last_who > REWHO_TIMEOUT)
314 user->flags &= ~USERFLAG_ISAUTHED; //remove authed flag (security reasons)
315 strcpy(user->nick, cmask);
317 } else if(cmask[i] == '.' && !user) {
319 user = malloc(sizeof(*user));
322 perror("malloc() failed");
325 strcpy(user->host, cmask);
326 user->created = time(0);
330 user->realname[0] = 0;
331 user->flags = USERFLAG_ISSERVER;
332 user->channel = NULL;
335 } else if(cmask[i] == '@') {
336 if(user == NULL) return NULL;
338 strcpy(user->ident, &cmask[ii]);
340 } else if(cmask[i] == '\0') {
343 user = malloc(sizeof(*user));
346 perror("malloc() failed");
349 strcpy(user->nick, cmask);
350 user->created = time(0);
354 user->realname[0] = 0;
356 user->channel = NULL;
360 strcpy(user->host, &cmask[ii]);
363 if(!already_on_list) {
364 user->next = userList[TEMPUSER_LIST_INDEX];
365 userList[TEMPUSER_LIST_INDEX] = user;
370 int renameUser(struct UserNode* user, const char *new_nick) {
371 if(!is_valid_nick(new_nick))
373 if(user->nick[0] == *new_nick) {
374 strcpy(user->nick, new_nick);
377 //delUser(user, 0); //EPIC FAIL! This deletes the user from the channel Userlist -.-
378 //manually remove the user from the old userList
379 int userListIndex = get_nicklist_entry(user->nick[0]);
380 if(userListIndex != -1) {
381 struct UserNode *cuser, *last_user = NULL;
382 for(cuser = userList[userListIndex]; cuser; cuser = cuser->next) {
385 last_user->next = user->next;
387 userList[userListIndex] = user->next;
393 userListIndex = get_nicklist_entry(*new_nick);
394 strcpy(user->nick, new_nick);
395 user->next = userList[userListIndex];
396 userList[userListIndex] = user;
400 void delUser(struct UserNode* user, int freeUser) {
401 int userListIndex = ((user->flags & USERFLAG_ISTMPUSER) ? TEMPUSER_LIST_INDEX : get_nicklist_entry(user->nick[0]));
402 if(userListIndex == -1) return;
403 event_freeuser(user);
404 struct UserNode *cuser, *last_user = NULL;
405 for(cuser = userList[userListIndex]; cuser; cuser = cuser->next) {
408 last_user->next = user->next;
410 userList[userListIndex] = user->next;
415 if(freeUser && (user->flags & USERFLAG_IS_ON_WHO_QUEUE)) {
416 user->flags |= USERFLAG_FREE_AFTER_WHO;
420 struct ChanUser *chanUser, *next;
421 for(chanUser = user->channel; chanUser; chanUser = next) {
422 next = chanUser->next_chan;
423 removeChanUserFromLists(chanUser, 1, 0, freeUser);
428 freeIPNode(user->ip);
434 void clearTempUsers() {
435 int userListIndex = TEMPUSER_LIST_INDEX;
436 struct UserNode *cuser, *next;
437 time_t now = time(0);
438 for(cuser = userList[userListIndex]; cuser; cuser = next) {
440 if(cuser->flags & USERFLAG_FREETMPUSER || now - cuser->created >= 300) {