Fix buffer overrun during loadding opening names
[capablanca.git] / lasker-2.2.3 / src / lists.c
1 /*
2    This program is free software; you can redistribute it and/or modify
3    it under the terms of the GNU General Public License as published by
4    the Free Software Foundation; either version 2 of the License, or
5    (at your option) any later version.
6    
7    This program is distributed in the hope that it will be useful,
8    but WITHOUT ANY WARRANTY; without even the implied warranty of
9    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
10    GNU General Public License for more details.
11    
12    You should have received a copy of the GNU General Public License
13    along with this program; if not, write to the Free Software
14    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
15 */
16
17 /* lists.c
18  *  New global lists code
19  *
20  *
21  *  Added by Shaney, 29 May 1995  :)
22  *
23 */
24
25 #include "includes.h"
26
27 static struct List *firstGlobalList = NULL;
28
29 static ListTable ListArray[] =
30 {{P_HEAD, "admin"},
31  {P_GOD, "removedcom"},
32  {P_ADMIN, "filter"},
33  {P_ADMIN, "ban"},
34  {P_ADMIN, "abuser"},
35  {P_ADMIN, "muzzle"},
36  {P_ADMIN, "cmuzzle"},
37  {P_ADMIN, "c1muzzle"}, /* possible FICS trouble spots */
38  {P_ADMIN, "c24muzzle"}, /* would prefer two param addlist - DAV */
39  {P_ADMIN, "c46muzzle"}, /* is a temp solution */
40  {P_ADMIN, "c49muzzle"},
41  {P_ADMIN, "c50muzzle"},
42  {P_ADMIN, "c51muzzle"},
43  {P_PUBLIC, "fm"},
44  {P_PUBLIC, "im"},
45  {P_PUBLIC, "gm"},
46  {P_PUBLIC, "wgm"},
47  {P_PUBLIC, "blind"},
48  {P_PUBLIC, "teams"},
49  {P_PUBLIC, "computer"},
50  {P_PUBLIC, "td"},
51  {P_PERSONAL, "censor"},
52  {P_PERSONAL, "gnotify"},
53  {P_PERSONAL, "noplay"},
54  {P_PERSONAL, "notify"},
55  {P_PERSONAL, "channel"},
56  {P_PERSONAL, "follow"},
57  {P_PERSONAL, "remote"},
58  {0, NULL}};
59
60 /* free up memory used by lists */
61 void lists_close(void)
62 {
63         struct List *l;
64
65         for (l=firstGlobalList; l; ) {
66                 struct List *next = l->next;
67                 int i;
68                 for (i=0;i<l->numMembers;i++) {
69                         FREE(l->m_member[i]);
70                 }
71                 FREE(l->m_member);
72                 l->numMembers = 0;
73                 free(l);
74                 l = next;
75         }
76
77         firstGlobalList = NULL;
78 }
79
80
81 /* find a list.  does not load from disk */
82 static struct List *list_find1(int p, enum ListWhich l)
83 {
84         struct player *pp = &player_globals.parray[p];
85         struct List *prev, *tempList, **starter;
86         int personal;
87         
88         personal = ListArray[l].rights == P_PERSONAL;
89         starter = personal ? &(pp->lists) : &firstGlobalList;
90
91         for (prev = NULL, tempList = *starter; tempList != NULL; tempList = tempList->next) {
92                 if (l == tempList->which) {
93                         if (prev != NULL) {
94                                 prev->next = tempList->next;
95                                 tempList->next = *starter;
96                                 *starter = tempList;
97                         }
98                         return tempList;
99                 }
100                 if (tempList->which >= L_LASTLIST) {
101                         /* THIS SHOULD NEVER HAPPEN!  But has been in personal list: bugs! */
102                         d_printf( "fics: ERROR!! in lists code\n");
103                         abort();
104                 }
105                 prev = tempList;
106         }
107
108         return NULL;
109 }
110
111 /* find a list.  loads from disk if not in memory. */
112 static struct List *list_find(int p, enum ListWhich l)
113 {
114         struct List *lst;
115         FILE *fp;
116         char listmember[100];
117         int count=0;
118
119         lst = list_find1(p, l);
120         if (lst) {
121                 return lst;
122         }
123
124         /* create the base list */
125         list_add(p, l, NULL);
126
127         if (ListArray[l].rights == P_PERSONAL) {
128                 list_find1(p, l);
129         }
130
131         fp = fopen_p("%s/%s", "r", LISTS_DIR, ListArray[l].name);
132         if (!fp) {
133                 return NULL;
134         }
135         while (!feof(fp)) {
136                 if (fgets(listmember, sizeof(listmember), fp) != NULL) {
137                         if (list_add(p, l, listmember) == 0) {
138                                 count++;
139                         }
140                 }
141         }
142         fclose(fp);
143         
144         /* we've added some, retry */
145         if (count) {
146                 return list_find1(p, l);
147         }
148         
149         return NULL;
150 }
151
152
153 /* add item to list */
154 int list_add(int p, enum ListWhich l, const char *s)
155 {
156         struct player *pp = &player_globals.parray[p];
157         struct List *gl = list_find1(p, l);
158
159         if (!gl) {
160                 gl = calloc(1, sizeof(*gl));
161                 gl->which = l;
162                 if (ListArray[l].rights == P_PERSONAL) {
163                         gl->next = pp->lists;
164                         pp->lists = gl;
165                 } else {
166                         gl->next = firstGlobalList;
167                         firstGlobalList = gl;
168                 }
169         }
170
171         if (!s) return 0;
172
173         if (ListArray[l].rights == P_PERSONAL &&
174             gl->numMembers >= config_get_int("MAX_USER_LIST_SIZE", DEFAULT_MAX_USER_LIST_SIZE)) {
175                 return 1;
176         }
177
178         while (isspace(*s)) s++;
179             
180         gl->m_member = (char **)realloc(gl->m_member, sizeof(char *) * (gl->numMembers+1));
181         gl->m_member[gl->numMembers] = strndup(s, strcspn(s, " \t\r\n"));
182         gl->numMembers++;
183
184         return 0;
185 }
186
187 /* remove item from list */
188 static int list_sub(int p, enum ListWhich l, char *s)
189 {
190         struct List *gl = list_find(p, l);
191         int i;
192
193         if (!gl) {
194                 return 1;
195         }
196         for (i = 0; i < gl->numMembers; i++) {
197                 if (!strcasecmp(s, gl->m_member[i])) {
198                         break;
199                 }
200         }
201         if (i == gl->numMembers) {
202                 return 1;
203         }
204
205         FREE(gl->m_member[i]);
206
207         for (; i < (gl->numMembers - 1); i++) {
208                 gl->m_member[i] = gl->m_member[i+1];
209         }
210
211         gl->numMembers--;
212         gl->m_member = (char **)realloc(gl->m_member, sizeof(char *) * gl->numMembers);
213         return 0;
214 }
215
216 /* find list by name, doesn't have to be the whole name */
217 struct List *list_findpartial(int p, char *which, int gonnado)
218 {
219   struct player *pp = &player_globals.parray[p];
220   struct List *gl;
221   int i, foundit, slen;
222
223   slen = strlen(which);
224   for (i = 0, foundit = -1; ListArray[i].name != NULL; i++) {
225     if (!strncasecmp(ListArray[i].name, which, slen)) {
226       if (foundit == -1)
227         foundit = i;
228       else
229         return NULL;            /* ambiguous */
230     }
231   }
232
233   if (foundit != -1) {
234     int rights = ListArray[foundit].rights;
235     int youlose = 0;
236
237     switch (rights) {           /* check rights */
238     case P_HEAD:
239       if (gonnado && !player_ishead(p))
240         youlose = 1;
241       break;
242     case P_GOD:
243       if ((gonnado && (pp->adminLevel < ADMIN_GOD)) ||
244           (!gonnado && (pp->adminLevel < ADMIN_ADMIN)))
245         youlose = 1;
246       break;
247     case P_ADMIN:
248       if (pp->adminLevel < ADMIN_ADMIN)
249         youlose = 1;
250       break;
251     case P_PUBLIC:
252       if (gonnado && (pp->adminLevel < ADMIN_ADMIN))
253         youlose = 1;
254       break;
255     }
256     if (youlose) {
257       pprintf(p, "\"%s\" is not an appropriate list name or you have insufficient rights.\n", which);
258       return NULL;
259     }
260     gl = list_find(p, foundit);
261   } else {
262     pprintf(p, "\"%s\" does not match any list name.\n", which);
263     return NULL;
264   }
265   return gl;
266 }
267
268 /* see if something is in a list */
269 int in_list(int p, enum ListWhich which, char *member)
270 {
271         struct List *gl;
272         int i;
273         int filterList = (which == L_FILTER);
274
275         gl = list_find(p, which);
276         if ((gl == NULL) || (member == NULL))
277                 return 0;
278         for (i = 0; i < gl->numMembers; i++) {
279                 if (filterList) {
280                         if (!strncasecmp(member, gl->m_member[i], strlen(gl->m_member[i])))
281                                 return 1;
282                 } else {
283                         if (!strcasecmp(member, gl->m_member[i]))
284                                 return 1;
285                 }
286         }
287         return 0;
288 }
289
290 /* add or subtract something to/from a list */
291 int list_addsub(int p, char* list, char* who, int addsub)
292 {
293   struct player *pp = &player_globals.parray[p];
294   int p1, connected, loadme, personal, ch;
295   char *listname, *member, junkChar;
296   struct List *gl;
297   char *yourthe, *addrem;
298
299   gl = list_findpartial(p, list, addsub);
300   if (!gl)
301     return COM_OK;
302
303   personal = ListArray[gl->which].rights == P_PERSONAL;
304   loadme = (gl->which != L_FILTER) && (gl->which != L_REMOVEDCOM) && (gl->which != L_CHANNEL);
305   listname = ListArray[gl->which].name;
306   yourthe = personal ? "your" : "the";
307   addrem = (addsub == 1) ? "added to" : "removed from";
308
309   if (loadme) {
310     if (!FindPlayer(p, who, &p1, &connected)) {
311       if (addsub == 1)
312         return COM_OK;
313       member = who;             /* allow sub removed/renamed player */
314       loadme = 0;
315     } else
316       member = player_globals.parray[p1].name;
317   } else {
318     member = who;
319   }
320
321   if (addsub == 1) {            /* add to list */
322
323    if (gl->which == L_CHANNEL) {
324
325      if (sscanf (who,"%d%c",&ch, &junkChar) == 1 && ch >= 0 && ch < 255) {
326        if ((ch == 0) && (!in_list(p,L_ADMIN,pp->name))) {
327          pprintf(p, "Only admins may join channel 0.\n");
328          return COM_OK;
329        }
330      } else {
331          pprintf (p,"The channel to add must be a number between 0 and %d.\n",MAX_CHANNELS - 1);
332          return COM_OK;
333         }
334   }      
335   if (in_list(p, gl->which, member)) {
336      pprintf(p, "[%s] is already on %s %s list.\n", member, yourthe, listname);
337      if (loadme && !connected)
338        player_remove(p1);
339      return COM_OK;
340     }
341     if (list_add(p, gl->which, member)) {
342       pprintf(p, "Sorry, %s %s list is full.\n", yourthe, listname);
343       if (loadme && !connected)
344         player_remove(p1);
345       return COM_OK;
346     }
347   } else if (addsub == 2) {     /* subtract from list */
348     if (!in_list(p, gl->which, member)) {
349       pprintf(p, "[%s] is not in %s %s list.\n", member, yourthe, listname);
350       if (loadme && !connected)
351         player_remove(p1);
352       return COM_OK;
353     }
354     list_sub(p, gl->which, member);
355   }
356   pprintf(p, "[%s] %s %s %s list.\n", member, addrem, yourthe, listname);
357
358   if (!personal) {
359     FILE *fp;
360     char filename[MAX_FILENAME_SIZE];
361
362     switch (gl->which) {
363     case L_MUZZLE:
364     case L_CMUZZLE:
365     case L_C1MUZZLE:
366     case L_C24MUZZLE:
367     case L_C46MUZZLE:
368     case L_C49MUZZLE:
369     case L_C50MUZZLE:
370     case L_C51MUZZLE:
371     case L_ABUSER:
372     case L_BAN:
373       pprintf(p, "Please leave a comment to explain why %s was %s the %s list.\n", member, addrem, listname);
374       pcommand(p, "addcomment %s %s %s list.\n", member, addrem, listname);
375       break;
376     case L_COMPUTER:
377       if (player_globals.parray[p1].b_stats.rating > 0)
378         UpdateRank(TYPE_BLITZ, member, &player_globals.parray[p1].b_stats, member);
379       if (player_globals.parray[p1].s_stats.rating > 0)
380         UpdateRank(TYPE_STAND, member, &player_globals.parray[p1].s_stats, member);
381       if (player_globals.parray[p1].w_stats.rating > 0)
382         UpdateRank(TYPE_WILD, member, &player_globals.parray[p1].w_stats, member);
383       break;
384     case L_ADMIN:
385       if (addsub == 1) {        /* adding to list */
386         player_globals.parray[p1].adminLevel = 10;
387         pprintf(p, "%s has been given an admin level of 10 - change with asetadmin.\n", member);
388       } else {
389         player_globals.parray[p1].adminLevel = 0;
390       }
391       break;
392     case L_FILTER:
393     case L_REMOVEDCOM:
394     default:
395       break;
396     }
397
398     if (loadme && connected)
399         pprintf_prompt(p1, "You have been %s the %s list by %s.\n",
400                                     addrem, listname, pp->name);
401
402     sprintf(filename, "%s/%s", LISTS_DIR, listname);
403     fp = fopen_s(filename, "w");
404     if (fp == NULL) {
405       d_printf( "Couldn't save %s list.\n", listname);
406     } else {
407       int i;
408       for (i = 0; i < gl->numMembers; i++)
409         fprintf(fp, "%s\n", gl->m_member[i]);
410       fclose(fp);
411     }
412   }
413   if (loadme || (gl->which == L_ADMIN)) {
414     player_save(p1);
415   }
416   if (loadme && !connected) {
417     player_remove(p1);
418   }
419   return COM_OK;
420 }
421
422 int com_addlist(int p, param_list param)
423 {
424         return list_addsub(p, param[0].val.word, param[1].val.word, 1);
425 }
426
427 int com_sublist(int p,param_list param)
428 {
429         return list_addsub(p, param[0].val.word, param[1].val.word, 2);
430 }
431
432 /* toggle being in a list */
433 int com_togglelist(int p,param_list param)
434 {
435         char *list = param[0].val.word;
436         char *val = param[1].val.word;
437         struct List *gl = list_findpartial(p, list, 0);
438         if (!gl) {
439                 pprintf(p, "'%s' does not match any list name.\n", list);
440                 return COM_FAILED;
441         }
442         if (in_list(p, gl->which, val)) {
443                 return com_sublist(p, param);
444         }
445         return com_addlist(p, param);
446 }
447
448 int com_showlist(int p, param_list param)
449 {
450   struct player *pp = &player_globals.parray[p];
451   struct List *gl;
452   int i, rights;
453
454   char *rightnames[] = {"EDIT HEAD, READ ADMINS", "EDIT GODS, READ ADMINS", "READ/WRITE ADMINS", "PUBLIC", "PERSONAL"};
455
456   if (param[0].type == 0) {     /* Show all lists */
457     pprintf(p, "Lists:\n\n");
458     for (i = 0; ListArray[i].name != NULL; i++) {
459       rights = ListArray[i].rights;
460       if ((rights > P_ADMIN) || (pp->adminLevel >= ADMIN_ADMIN))
461         pprintf(p, "%-20s is %s\n", ListArray[i].name, rightnames[rights]);
462     }
463   } else {                      /* find match in index */
464     gl = list_findpartial(p, param[0].val.word, 0);
465     if (!gl) {
466       return COM_OK;
467     }
468     rights = ListArray[gl->which].rights;
469     /* display the list */
470     {
471       multicol *m = multicol_start(gl->numMembers);
472
473       pprintf(p, "-- %s list: %d %s --", ListArray[gl->which].name,
474       gl->numMembers,
475       ((!(strcmp(ListArray[gl->which].name,"filter"))) ? "ips" : (!(strcmp(ListArray[gl->which].name,"removedcom"))) ? "commands" : (!(strcmp(ListArray[gl->which].name,"channel"))) ? "channels" : "names"));
476       for (i = 0; i < gl->numMembers; i++)
477         multicol_store_sorted(m, gl->m_member[i]);
478       multicol_pprint(m, p, pp->d_width, 2);
479       multicol_end(m);
480     }
481   }
482   return COM_OK;
483 }
484
485 int list_channels(int p,int p1)
486 {
487   struct player *pp = &player_globals.parray[p];
488   struct List *gl;
489   int i, rights;
490
491     gl = list_findpartial(p1, "channel", 0);
492     if (!gl) {
493       return 1;
494     }
495     rights = ListArray[gl->which].rights;
496     /* display the list */
497     if (gl->numMembers == 0)
498       return 1;
499     {
500       multicol *m = multicol_start(gl->numMembers);
501
502       for (i = 0; i < gl->numMembers; i++)
503         multicol_store_sorted(m, gl->m_member[i]);
504       multicol_pprint(m, p, pp->d_width, 1);
505       multicol_end(m);
506     }
507   return 0;
508 }
509
510 /* free the memory used by a list */
511 void list_free(struct List * gl)
512 {
513         int i;
514         struct List *temp;
515
516         while (gl) {
517                 for (i = 0; i < gl->numMembers; i++) {
518                         FREE(gl->m_member[i]);
519                 }
520                 FREE(gl->m_member);
521                 temp = gl->next;
522                 free(gl);
523                 gl = temp;
524         }
525 }
526
527 /* check lists for validity - pure paranoia */
528 void lists_validate(int p)
529 {
530         struct player *pp = &player_globals.parray[p];
531         struct List *gl;
532
533         for (gl=pp->lists; gl; gl=gl->next) {
534                 if (gl->numMembers && !gl->m_member) {
535                         gl->numMembers = 0;
536                 }
537         }
538 }
539
540
541 int titled_player(int p,char* name)
542 {
543         if ((in_list(p, L_FM, name)) || 
544             (in_list(p, L_IM, name)) || 
545             (in_list(p, L_GM, name)) || 
546             (in_list(p, L_WGM, name))) {
547                 return 1;
548         }
549         return 0;
550 }
551