1 /* UserNode.c - NeonServ v5.2
2 * Copyright (C) 2011 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/>.
21 static struct UserNode **userList;
23 void init_UserNode() {
24 userList = calloc(VALID_NICK_CHARS_FIRST_LEN+1, sizeof(*userList));
27 void free_UserNode() {
28 //kamikaze free all users
29 //chanusers will be destroyed in free_ChanNode()
31 struct UserNode *user, *next;
32 for(i = 0; i < VALID_NICK_CHARS_FIRST_LEN+1; i++) {
33 for(user = userList[i]; user; user = next) {
41 int is_valid_nick(const char *nick) {
43 //first char must be one of: a-zA-Z{|}~[\]^_`
44 if (!strchr(VALID_NICK_CHARS_FIRST, *nick))
46 //all other chars must be one of: a-zA-Z0-9{|}~[\]^_`
47 for (i = 0; nick[i]; ++i)
48 if (!strchr(VALID_NICK_CHARS, nick[i]))
50 if (strlen(nick) > NICKLEN)
55 static int get_nicklist_entry(int nick) {
57 char *valid_chars = VALID_NICK_CHARS_FIRST;
58 for(i = 0; i < VALID_NICK_CHARS_FIRST_LEN; i++) {
59 if(valid_chars[i] == nick)
65 struct UserNode* getUserByNick(const char *nick) { //case sensitive
66 int userListIndex = get_nicklist_entry(*nick);
67 if(userListIndex == -1 || userList[userListIndex] == NULL)
69 struct UserNode *user;
70 for(user = userList[userListIndex]; user; user = user->next) {
71 if(!stricmp(nick, user->nick))
77 struct UserNode* getUserByMask(const char *mask) { //case sensitive
78 char cmask[strlen(mask)+1];
81 struct UserNode *user = NULL;
82 for(i = 0; i < strlen(mask); i++) {
85 user = getUserByNick(&cmask[0]);
87 } else if(cmask[i] == '.') {
95 struct UserNode* searchUserByNick(const char *nick) { //case insensitive
97 return getUserByNick(nick);
100 struct UserNode *user;
102 //search in the lower case "section"
103 userListIndex = get_nicklist_entry(tolower(*nick));
104 if(userListIndex != -1 && userList[userListIndex] != NULL) {
105 for(user = userList[userListIndex]; user; user = user->next) {
106 if(!stricmp(nick, user->nick))
110 //search in the upper case "section"
111 userListIndex = get_nicklist_entry(toupper(*nick));
112 if(userListIndex != -1 && userList[userListIndex] != NULL) {
113 for(user = userList[userListIndex]; user; user = user->next) {
114 if(!stricmp(nick, user->nick))
121 int countUsersWithHost(char *host) {
123 struct UserNode *user;
124 for(i = 0; i < VALID_NICK_CHARS_FIRST_LEN+1; i++) {
125 for(user = userList[i]; user; user = user->next) {
126 if(!strcmp(user->host, host)) {
134 char *getAuthFakehost(char *auth) {
136 struct UserNode *user;
137 for(i = 0; i < VALID_NICK_CHARS_FIRST_LEN+1; i++) {
138 for(user = userList[i]; user; user = user->next) {
139 if((user->flags & USERFLAG_ISAUTHED) && !strcmp(user->auth, auth) && isFakeHost(user->host)) {
147 struct UserNode* getAllUsers(struct UserNode *last) {
148 if(last == NULL || last->next == NULL) {
153 cindex = get_nicklist_entry(last->nick[0]) + 1;
154 while(userList[cindex] == NULL && cindex <= VALID_NICK_CHARS_FIRST_LEN)
156 if(cindex > VALID_NICK_CHARS_FIRST_LEN) return NULL;
157 return userList[cindex];
162 struct UserNode* getUsersWithAuth(const char *auth, struct UserNode *last) {
163 int cindex = (last ? get_nicklist_entry(last->nick[0]) : 0);
164 struct UserNode *cuser = last;
165 while(cindex <= VALID_NICK_CHARS_FIRST_LEN) {
166 for(cuser = (cuser ? cuser->next : userList[cindex]); cuser; cuser = cuser->next) {
167 if((cuser->flags & USERFLAG_ISAUTHED) && !strcmp(cuser->auth, auth))
178 struct UserNode *user;
179 for(i = 0; i < VALID_NICK_CHARS_FIRST_LEN+1; i++) {
180 for(user = userList[i]; user; user = user->next) {
187 struct UserNode* addUser(const char *nick) {
188 int userListIndex = get_nicklist_entry(*nick);
189 if(userListIndex == -1 || !is_valid_nick(nick))
191 struct UserNode *user = malloc(sizeof(*user));
194 perror("malloc() failed");
197 strcpy(user->nick, nick);
198 user->created = time(0);
201 user->realname[0] = 0;
203 user->channel = NULL;
205 user->next = userList[userListIndex];
206 userList[userListIndex] = user;
210 struct UserNode* addUserMask(const char *mask) {
211 char cmask[strlen(mask)+1];
214 struct UserNode *user = NULL;
215 for(i = 0; i < strlen(mask)+1; i++) {
216 if(cmask[i] == '!') {
218 user = addUser(cmask);
219 if(user == NULL) return NULL;
221 } else if(cmask[i] == '.' && !user) {
224 } else if(cmask[i] == '@') {
225 if(user == NULL) return NULL;
227 strcpy(user->ident, &cmask[ii]);
229 } else if(cmask[i] == '\0') {
230 if(user == NULL) return NULL;
231 strcpy(user->host, &cmask[ii]);
237 struct UserNode* createTempUser(const char *mask) {
238 //note: it could also be a server we have to create a temponary user for...
239 char cmask[strlen(mask)+1];
242 struct UserNode *user = NULL;
243 for(i = 0; i < strlen(mask)+1; i++) {
244 if(cmask[i] == '!') {
246 user = malloc(sizeof(*user));
249 perror("malloc() failed");
252 strcpy(user->nick, cmask);
253 user->created = time(0);
256 user->realname[0] = 0;
258 user->channel = NULL;
261 } else if(cmask[i] == '.' && !user) {
263 user = malloc(sizeof(*user));
266 perror("malloc() failed");
269 strcpy(user->host, cmask);
270 user->created = time(0);
273 user->realname[0] = 0;
274 user->flags = USERFLAG_ISSERVER;
275 user->channel = NULL;
278 } else if(cmask[i] == '@') {
279 if(user == NULL) return NULL;
281 strcpy(user->ident, &cmask[ii]);
283 } else if(cmask[i] == '\0') {
286 user = malloc(sizeof(*user));
289 perror("malloc() failed");
292 strcpy(user->nick, cmask);
293 user->created = time(0);
296 user->realname[0] = 0;
298 user->channel = NULL;
302 strcpy(user->host, &cmask[ii]);
308 int renameUser(struct UserNode* user, const char *new_nick) {
309 if(!is_valid_nick(new_nick))
311 if(user->nick[0] == *new_nick) {
312 strcpy(user->nick, new_nick);
315 //delUser(user, 0); //EPIC FAIL! This deletes the user from the channel Userlist -.-
316 //manually remove the user from the old userList
317 int userListIndex = get_nicklist_entry(user->nick[0]);
318 if(userListIndex != -1) {
319 struct UserNode *cuser, *last_user = NULL;
320 for(cuser = userList[userListIndex]; cuser; cuser = cuser->next) {
323 last_user->next = user->next;
325 userList[userListIndex] = user->next;
331 userListIndex = get_nicklist_entry(*new_nick);
332 strcpy(user->nick, new_nick);
333 user->next = userList[userListIndex];
334 userList[userListIndex] = user;
338 void delUser(struct UserNode* user, int freeUser) {
339 int userListIndex = get_nicklist_entry(user->nick[0]);
340 if(userListIndex == -1) return;
341 struct UserNode *cuser, *last_user = NULL;
342 for(cuser = userList[userListIndex]; cuser; cuser = cuser->next) {
345 last_user->next = user->next;
347 userList[userListIndex] = user->next;
353 struct ChanUser *chanUser, *next;
354 for(chanUser = user->channel; chanUser; chanUser = next) {
355 next = chanUser->next_chan;
356 removeChanUserFromLists(chanUser, 1, 0, freeUser);
365 void clearTempUsers() {
366 int userListIndex = TEMPUSER_LIST_INDEX;
367 struct UserNode *cuser, *last_user = NULL, *next;
368 time_t now = time(0);
369 for(cuser = userList[userListIndex]; cuser; cuser = next) {
371 if(cuser->flags & USERFLAG_FREETMPUSER || now - cuser->created >= 300) {
373 last_user->next = cuser->next;
375 userList[userListIndex] = cuser->next;