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"
22 static struct UserNode **userList;
24 void init_UserNode() {
25 userList = calloc(VALID_NICK_CHARS_FIRST_LEN+1, sizeof(*userList));
28 void free_UserNode() {
29 //kamikaze free all users
30 //chanusers will be destroyed in free_ChanNode()
32 struct UserNode *user, *next;
33 for(i = 0; i < VALID_NICK_CHARS_FIRST_LEN+1; i++) {
34 for(user = userList[i]; user; user = next) {
42 int is_valid_nick(const char *nick) {
44 //first char must be one of: a-zA-Z{|}~[\]^_`
45 if (!strchr(VALID_NICK_CHARS_FIRST, *nick))
47 //all other chars must be one of: a-zA-Z0-9{|}~[\]^_`
48 for (i = 0; nick[i]; ++i)
49 if (!strchr(VALID_NICK_CHARS, nick[i]))
51 if (strlen(nick) > NICKLEN)
56 static int get_nicklist_entry(int nick) {
58 char *valid_chars = VALID_NICK_CHARS_FIRST;
59 for(i = 0; i < VALID_NICK_CHARS_FIRST_LEN; i++) {
60 if(valid_chars[i] == nick)
66 struct UserNode* getUserByNick(const char *nick) { //case sensitive
67 int userListIndex = get_nicklist_entry(*nick);
68 if(userListIndex == -1 || userList[userListIndex] == NULL)
70 struct UserNode *user;
71 for(user = userList[userListIndex]; user; user = user->next) {
72 if(!stricmp(nick, user->nick))
78 struct UserNode* getUserByMask(const char *mask) { //case sensitive
79 char cmask[strlen(mask)+1];
82 struct UserNode *user = NULL;
83 for(i = 0; i < strlen(mask); i++) {
86 user = getUserByNick(&cmask[0]);
88 } else if(cmask[i] == '.') {
96 struct UserNode* searchUserByNick(const char *nick) { //case insensitive
98 return getUserByNick(nick);
101 struct UserNode *user;
103 //search in the lower case "section"
104 userListIndex = get_nicklist_entry(tolower(*nick));
105 if(userListIndex != -1 && userList[userListIndex] != NULL) {
106 for(user = userList[userListIndex]; user; user = user->next) {
107 if(!stricmp(nick, user->nick))
111 //search in the upper case "section"
112 userListIndex = get_nicklist_entry(toupper(*nick));
113 if(userListIndex != -1 && userList[userListIndex] != NULL) {
114 for(user = userList[userListIndex]; user; user = user->next) {
115 if(!stricmp(nick, user->nick))
122 int countUsersWithHost(char *host) {
124 struct UserNode *user;
125 for(i = 0; i < VALID_NICK_CHARS_FIRST_LEN; i++) {
126 for(user = userList[i]; user; user = user->next) {
127 if(!strcmp(user->host, host)) {
135 char *getAuthFakehost(char *auth) {
137 struct UserNode *user;
138 for(i = 0; i < VALID_NICK_CHARS_FIRST_LEN; i++) {
139 for(user = userList[i]; user; user = user->next) {
140 if((user->flags & USERFLAG_ISAUTHED) && !strcmp(user->auth, auth) && isFakeHost(user->host)) {
148 struct UserNode* getAllUsers(struct UserNode *last) {
149 if(last == NULL || last->next == NULL) {
154 cindex = get_nicklist_entry(last->nick[0]) + 1;
155 while(userList[cindex] == NULL && cindex < VALID_NICK_CHARS_FIRST_LEN)
157 if(cindex > VALID_NICK_CHARS_FIRST_LEN) return NULL;
158 return userList[cindex];
163 struct UserNode* getUsersWithAuth(const char *auth, struct UserNode *last) {
164 int cindex = (last ? get_nicklist_entry(last->nick[0]) : 0);
165 struct UserNode *cuser = last;
166 while(cindex <= VALID_NICK_CHARS_FIRST_LEN) {
167 for(cuser = (cuser ? cuser->next : userList[cindex]); cuser; cuser = cuser->next) {
168 if((cuser->flags & USERFLAG_ISAUTHED) && !strcmp(cuser->auth, auth))
179 struct UserNode *user;
180 for(i = 0; i < VALID_NICK_CHARS_FIRST_LEN; i++) {
181 for(user = userList[i]; user; user = user->next) {
188 struct UserNode* addUser(const char *nick) {
189 int userListIndex = get_nicklist_entry(*nick);
190 if(userListIndex == -1 || !is_valid_nick(nick))
192 struct UserNode *user = malloc(sizeof(*user));
195 perror("malloc() failed");
198 strcpy(user->nick, nick);
199 user->created = time(0);
202 user->realname[0] = 0;
204 user->channel = NULL;
206 user->next = userList[userListIndex];
207 userList[userListIndex] = user;
211 struct UserNode* addUserMask(const char *mask) {
212 char cmask[strlen(mask)+1];
215 struct UserNode *user = NULL;
216 for(i = 0; i < strlen(mask)+1; i++) {
217 if(cmask[i] == '!') {
219 user = addUser(cmask);
220 if(user == NULL) return NULL;
222 } else if(cmask[i] == '.' && !user) {
225 } else if(cmask[i] == '@') {
226 if(user == NULL) return NULL;
228 strcpy(user->ident, &cmask[ii]);
230 } else if(cmask[i] == '\0') {
231 if(user == NULL) return NULL;
232 strcpy(user->host, &cmask[ii]);
238 struct UserNode* createTempUser(const char *nick) {
239 int already_on_list = 0;
240 struct UserNode *user = NULL;
241 if(!is_valid_nick(nick)) {
244 for(user = userList[TEMPUSER_LIST_INDEX]; user; user = user->next) {
245 if(!stricmp(user->nick, nick)) {
251 user = malloc(sizeof(*user));
253 perror("malloc() failed");
258 user->realname[0] = 0;
260 user->channel = NULL;
263 user->flags &= ~USERFLAG_FREETMPUSER;
264 user->created = time(0);
265 if(user->created - user->last_who > REWHO_TIMEOUT)
266 user->flags &= ~USERFLAG_ISAUTHED; //remove authed flag (security reasons)
267 strcpy(user->nick, nick);
268 if(!already_on_list) {
269 user->next = userList[TEMPUSER_LIST_INDEX];
270 userList[TEMPUSER_LIST_INDEX] = user;
275 struct UserNode* createTempUserMask(const char *mask) {
276 //note: it could also be a server we have to create a temponary user for...
277 char cmask[strlen(mask)+1];
280 int already_on_list = 0;
281 struct UserNode *user = NULL;
282 for(i = 0; i < strlen(mask)+1; i++) {
283 if(cmask[i] == '!') {
285 if(!is_valid_nick(cmask)) {
288 for(user = userList[TEMPUSER_LIST_INDEX]; user; user = user->next) {
289 if(!stricmp(user->nick, cmask)) {
295 user = malloc(sizeof(*user));
297 perror("malloc() failed");
302 user->realname[0] = 0;
304 user->channel = NULL;
307 user->flags &= ~USERFLAG_FREETMPUSER;
308 user->created = time(0);
309 if(user->created - user->last_who > REWHO_TIMEOUT)
310 user->flags &= ~USERFLAG_ISAUTHED; //remove authed flag (security reasons)
311 strcpy(user->nick, cmask);
313 } else if(cmask[i] == '.' && !user) {
315 user = malloc(sizeof(*user));
318 perror("malloc() failed");
321 strcpy(user->host, cmask);
322 user->created = time(0);
325 user->realname[0] = 0;
326 user->flags = USERFLAG_ISSERVER;
327 user->channel = NULL;
330 } else if(cmask[i] == '@') {
331 if(user == NULL) return NULL;
333 strcpy(user->ident, &cmask[ii]);
335 } else if(cmask[i] == '\0') {
338 user = malloc(sizeof(*user));
341 perror("malloc() failed");
344 strcpy(user->nick, cmask);
345 user->created = time(0);
348 user->realname[0] = 0;
350 user->channel = NULL;
354 strcpy(user->host, &cmask[ii]);
357 if(!already_on_list) {
358 user->next = userList[TEMPUSER_LIST_INDEX];
359 userList[TEMPUSER_LIST_INDEX] = user;
364 int renameUser(struct UserNode* user, const char *new_nick) {
365 if(!is_valid_nick(new_nick))
367 if(user->nick[0] == *new_nick) {
368 strcpy(user->nick, new_nick);
371 //delUser(user, 0); //EPIC FAIL! This deletes the user from the channel Userlist -.-
372 //manually remove the user from the old userList
373 int userListIndex = get_nicklist_entry(user->nick[0]);
374 if(userListIndex != -1) {
375 struct UserNode *cuser, *last_user = NULL;
376 for(cuser = userList[userListIndex]; cuser; cuser = cuser->next) {
379 last_user->next = user->next;
381 userList[userListIndex] = user->next;
387 userListIndex = get_nicklist_entry(*new_nick);
388 strcpy(user->nick, new_nick);
389 user->next = userList[userListIndex];
390 userList[userListIndex] = user;
394 void delUser(struct UserNode* user, int freeUser) {
395 int userListIndex = ((user->flags & USERFLAG_ISTMPUSER) ? TEMPUSER_LIST_INDEX : get_nicklist_entry(user->nick[0]));
396 if(userListIndex == -1) return;
397 event_freeuser(user);
398 struct UserNode *cuser, *last_user = NULL;
399 for(cuser = userList[userListIndex]; cuser; cuser = cuser->next) {
402 last_user->next = user->next;
404 userList[userListIndex] = user->next;
409 if(freeUser && (user->flags & USERFLAG_IS_ON_WHO_QUEUE)) {
410 user->flags |= USERFLAG_FREE_AFTER_WHO;
414 struct ChanUser *chanUser, *next;
415 for(chanUser = user->channel; chanUser; chanUser = next) {
416 next = chanUser->next_chan;
417 removeChanUserFromLists(chanUser, 1, 0, freeUser);
426 void clearTempUsers() {
427 int userListIndex = TEMPUSER_LIST_INDEX;
428 struct UserNode *cuser, *next;
429 time_t now = time(0);
430 for(cuser = userList[userListIndex]; cuser; cuser = next) {
432 if(cuser->flags & USERFLAG_FREETMPUSER || now - cuser->created >= 300) {