← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/eggdrop/oneiric

« back to all changes in this revision

Viewing changes to src/tcluser.c

  • Committer: Bazaar Package Importer
  • Author(s): Guilherme de S. Pastore
  • Date: 2004-06-17 09:15:28 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20040617091528-64rrw1sa33lkfhmh
Tags: 1.6.16-2
http://bugs.debian.org/254824
* Fixed typo on README.Debian
* Fixed hyphens in manual page
* Converted debian/rules to CDBS
* Set path to binary on example config file
* Changed LANGDIR on src/eggdrop.h (Closes: #254824)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/tcluser.c
2
2
 * tcluser.c -- handles:
3
3
 *   Tcl stubs for the user-record-oriented commands
4
4
 *
5
 
 * $Id: tcluser.c,v 1.29 2002/01/02 03:46:36 guppy Exp $
 
5
 * $Id: tcluser.c,v 1.38 2004/04/06 06:56:38 wcc Exp $
6
6
 */
7
7
/*
8
8
 * Copyright (C) 1997 Robey Pointer
9
 
 * Copyright (C) 1999, 2000, 2001, 2002 Eggheads Development Team
 
9
 * Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004 Eggheads Development Team
10
10
 *
11
11
 * This program is free software; you can redistribute it and/or
12
12
 * modify it under the terms of the GNU General Public License
27
27
#include "users.h"
28
28
#include "chan.h"
29
29
#include "tandem.h"
 
30
#include "modules.h"
30
31
 
31
 
extern Tcl_Interp       *interp;
32
 
extern struct userrec   *userlist;
33
 
extern int               default_flags, dcc_total, ignore_time;
34
 
extern struct dcc_t     *dcc;
35
 
extern char              origbotname[], botnetnick[];
36
 
extern time_t            now;
 
32
extern Tcl_Interp *interp;
 
33
extern struct userrec *userlist;
 
34
extern int default_flags, dcc_total, ignore_time;
 
35
extern struct dcc_t *dcc;
 
36
extern char origbotname[], botnetnick[];
 
37
extern time_t now;
37
38
 
38
39
 
39
40
static int tcl_countusers STDVAR
40
41
{
41
42
  BADARGS(1, 1, "");
 
43
 
42
44
  Tcl_AppendResult(irp, int_to_base10(count_users(userlist)), NULL);
43
45
  return TCL_OK;
44
46
}
46
48
static int tcl_validuser STDVAR
47
49
{
48
50
  BADARGS(2, 2, " handle");
 
51
 
49
52
  Tcl_AppendResult(irp, get_user_by_handle(userlist, argv[1]) ? "1" : "0",
50
 
                   NULL);
 
53
                   NULL);
51
54
  return TCL_OK;
52
55
}
53
56
 
56
59
  struct userrec *u;
57
60
 
58
61
  BADARGS(2, 2, " nick!user@host");
 
62
 
59
63
  u = get_user_by_host(argv[1]);
60
64
  Tcl_AppendResult(irp, u ? u->handle : "*", NULL);
61
65
  return TCL_OK;
66
70
  struct userrec *u;
67
71
 
68
72
  BADARGS(3, 3, " handle passwd");
 
73
 
69
74
  Tcl_AppendResult(irp, ((u = get_user_by_handle(userlist, argv[1])) &&
70
 
                         u_pass_match(u, argv[2])) ? "1" : "0", NULL);
 
75
                   u_pass_match(u, argv[2])) ? "1" : "0", NULL);
71
76
  return TCL_OK;
72
77
}
73
78
 
78
83
  struct userrec *u;
79
84
 
80
85
  BADARGS(2, 4, " handle ?changes? ?channel?");
 
86
 
81
87
  if ((argv[1][0] == '*') || !(u = get_user_by_handle(userlist, argv[1]))) {
82
88
    Tcl_AppendResult(irp, "*", NULL);
83
89
    return TCL_OK;
88
94
    chg = argv[2];
89
95
  } else if (argc == 3 && argv[2][0]) {
90
96
    int ischan = (findchan_by_dname(argv[2]) != NULL);
91
 
    if (strchr(CHANMETA, argv[2][0]) && !ischan && argv[2][0] != '+' && argv[2][0] != '-') {
 
97
 
 
98
    if (strchr(CHANMETA, argv[2][0]) && !ischan && argv[2][0] != '+' &&
 
99
        argv[2][0] != '-') {
92
100
      Tcl_AppendResult(irp, "no such channel", NULL);
93
101
      return TCL_ERROR;
94
102
    } else if (ischan) {
121
129
    /* No-one can change these flags on-the-fly */
122
130
    pls.global &=~(USER_BOT);
123
131
    mns.global &=~(USER_BOT);
 
132
 
124
133
    if (chan) {
125
134
      pls.chan &= ~(BOT_SHARE);
126
135
      mns.chan &= ~(BOT_SHARE);
127
136
    }
128
137
    user.global = sanity_check((user.global |pls.global) &~mns.global);
 
138
 
129
139
    user.udef_global = (user.udef_global | pls.udef_global)
130
 
      & ~mns.udef_global;
 
140
                       & ~mns.udef_global;
131
141
    if (chan) {
132
142
      user.chan = chan_sanity_check((user.chan | pls.chan) & ~mns.chan,
133
 
                                    user.global);
 
143
                                    user.global);
134
144
      user.udef_chan = (user.udef_chan | pls.udef_chan) & ~mns.udef_chan;
135
145
    }
136
146
    set_user_flagrec(u, &user, chan);
148
158
  struct userrec *u;
149
159
 
150
160
  BADARGS(2, 4, " bot-handle ?changes? ?channel?");
 
161
 
151
162
  u = get_user_by_handle(userlist, argv[1]);
152
163
  if ((argv[1][0] == '*') || !u || !(u->flags & USER_BOT)) {
153
164
    Tcl_AppendResult(irp, "*", NULL);
157
168
    user.match = FR_BOT | FR_CHAN;
158
169
    chan = argv[3];
159
170
    chg = argv[2];
160
 
  } else if (argc == 3 && argv[2][0] &&
161
 
             strchr(CHANMETA, argv[2][0]) != NULL) {
 
171
  } else if (argc == 3 && argv[2][0] && strchr(CHANMETA, argv[2][0]) != NULL) {
162
172
    /* We need todo extra checking here to stop us mixing up +channel's
163
173
     * with flags. <cybah>
164
174
     */
168
178
       */
169
179
      Tcl_AppendResult(irp, "no such channel", NULL);
170
180
      return TCL_ERROR;
171
 
    } else if(findchan_by_dname(argv[2])) {
 
181
    } else if (findchan_by_dname(argv[2])) {
172
182
      /* Channel exists */
173
183
      user.match = FR_BOT | FR_CHAN;
174
184
      chan = argv[2];
185
195
    user.match = FR_BOT;
186
196
    chan = NULL;
187
197
    if (argc < 3)
188
 
    chg = NULL;
 
198
      chg = NULL;
189
199
    else
190
200
      chg = argv[2];
191
201
  }
223
233
  int ok = 0, f;
224
234
 
225
235
  BADARGS(3, 4, " handle flags ?channel?");
 
236
 
226
237
  if ((u = get_user_by_handle(userlist, argv[1]))) {
227
238
    user.match = FR_GLOBAL | (argc == 4 ? FR_CHAN : 0) | FR_BOT;
228
239
    get_user_flagrec(u, &user, argv[3]);
229
240
    plus.match = user.match;
230
241
    break_down_flags(argv[2], &plus, &minus);
231
 
    f = (minus.global || minus.udef_global || minus.chan ||
232
 
         minus.udef_chan || minus.bot);
 
242
    f = (minus.global ||minus.udef_global || minus.chan || minus.udef_chan ||
 
243
         minus.bot);
233
244
    if (flagrec_eq(&plus, &user)) {
234
245
      if (!f)
235
 
        ok = 1;
 
246
        ok = 1;
236
247
      else {
237
 
        minus.match = plus.match ^ (FR_AND | FR_OR);
238
 
        if (!flagrec_eq(&minus, &user))
239
 
          ok = 1;
 
248
        minus.match = plus.match ^ (FR_AND | FR_OR);
 
249
        if (!flagrec_eq(&minus, &user))
 
250
          ok = 1;
240
251
      }
241
252
    }
242
253
  }
247
258
static int tcl_adduser STDVAR
248
259
{
249
260
  BADARGS(2, 3, " handle ?hostmask?");
 
261
 
250
262
  if (strlen(argv[1]) > HANDLEN)
251
263
    argv[1][HANDLEN] = 0;
252
264
  if ((argv[1][0] == '*') || get_user_by_handle(userlist, argv[1]))
264
276
  char *p, *q;
265
277
 
266
278
  BADARGS(3, 3, " handle address");
 
279
 
267
280
  if (strlen(argv[1]) > HANDLEN)
268
 
     argv[1][HANDLEN] = 0;
 
281
    argv[1][HANDLEN] = 0;
269
282
  if (get_user_by_handle(userlist, argv[1]))
270
 
     Tcl_AppendResult(irp, "0", NULL);
 
283
    Tcl_AppendResult(irp, "0", NULL);
271
284
  else if (argv[1][0] == '*')
272
 
     Tcl_AppendResult(irp, "0", NULL);
 
285
    Tcl_AppendResult(irp, "0", NULL);
273
286
  else {
274
287
    userlist = adduser(userlist, argv[1], "none", "-", USER_BOT);
275
288
    bi = user_malloc(sizeof(struct bot_addr));
287
300
      bi->telnet_port = atoi(p);
288
301
      q = strchr(p, '/');
289
302
      if (!q)
290
 
        bi->relay_port = bi->telnet_port;
 
303
        bi->relay_port = bi->telnet_port;
291
304
      else
292
 
        bi->relay_port = atoi(q + 1);
 
305
        bi->relay_port = atoi(q + 1);
293
306
    }
294
307
    set_user(&USERENTRY_BOTADDR, get_user_by_handle(userlist, argv[1]), bi);
295
308
    Tcl_AppendResult(irp, "1", NULL);
300
313
static int tcl_deluser STDVAR
301
314
{
302
315
  BADARGS(2, 2, " handle");
 
316
 
303
317
  Tcl_AppendResult(irp, (argv[1][0] == '*') ? "0" :
304
 
                   int_to_base10(deluser(argv[1])), NULL);
 
318
                   int_to_base10(deluser(argv[1])), NULL);
305
319
  return TCL_OK;
306
320
}
307
321
 
308
322
static int tcl_delhost STDVAR
309
323
{
310
324
  BADARGS(3, 3, " handle hostmask");
 
325
 
311
326
  if ((!get_user_by_handle(userlist, argv[1])) || (argv[1][0] == '*')) {
312
327
    Tcl_AppendResult(irp, "non-existent user", NULL);
313
328
    return TCL_ERROR;
314
329
  }
315
 
  Tcl_AppendResult(irp, delhost_by_handle(argv[1], argv[2]) ? "1" : "0",
316
 
                   NULL);
 
330
  Tcl_AppendResult(irp, delhost_by_handle(argv[1], argv[2]) ? "1" : "0", NULL);
317
331
  return TCL_OK;
318
332
}
319
333
 
324
338
  int ok = 1, f = 0;
325
339
 
326
340
  BADARGS(1, 3, " ?flags ?channel??");
 
341
 
327
342
  if (argc == 3 && !findchan_by_dname(argv[2])) {
328
343
    Tcl_AppendResult(irp, "Invalid channel: ", argv[2], NULL);
329
344
    return TCL_ERROR;
331
346
  if (argc >= 2) {
332
347
    plus.match = FR_GLOBAL | FR_CHAN | FR_BOT;
333
348
    break_down_flags(argv[1], &plus, &minus);
334
 
    f = (minus.global || minus.udef_global || minus.chan ||
335
 
         minus.udef_chan || minus.bot);
 
349
    f = (minus.global ||minus.udef_global || minus.chan || minus.udef_chan ||
 
350
         minus.bot);
336
351
  }
337
352
  minus.match = plus.match ^ (FR_AND | FR_OR);
338
353
  for (u = userlist; u; u = u->next) {
339
354
    if (argc >= 2) {
340
355
      user.match = FR_GLOBAL | FR_CHAN | FR_BOT | (argc == 3 ? 0 : FR_ANYWH);
341
 
      if (argc == 3) 
342
 
              get_user_flagrec(u, &user, argv[2]);
 
356
      if (argc == 3)
 
357
        get_user_flagrec(u, &user, argv[2]);
343
358
      else
344
 
              get_user_flagrec(u, &user, NULL);
345
 
 
 
359
        get_user_flagrec(u, &user, NULL);
346
360
      if (flagrec_eq(&plus, &user) && !(f && flagrec_eq(&minus, &user)))
347
 
        ok = 1;
 
361
        ok = 1;
348
362
      else
349
 
        ok = 0;
 
363
        ok = 0;
350
364
    }
351
365
    if (ok)
352
366
      Tcl_AppendElement(interp, u->handle);
373
387
  int x = 1, i;
374
388
 
375
389
  BADARGS(3, 3, " oldnick newnick");
 
390
 
376
391
  u = get_user_by_handle(userlist, argv[1]);
377
392
  if (!u)
378
 
     x = 0;
 
393
    x = 0;
379
394
  else {
380
395
    strncpyz(newhand, argv[2], sizeof newhand);
381
396
    for (i = 0; i < strlen(newhand); i++)
382
397
      if ((newhand[i] <= 32) || (newhand[i] >= 127) || (newhand[i] == '@'))
383
 
        newhand[i] = '?';
 
398
        newhand[i] = '?';
384
399
    if (strchr(BADHANDCHARS, newhand[0]) != NULL)
385
400
      x = 0;
386
401
    else if (strlen(newhand) < 1)
387
402
      x = 0;
388
403
    else if (get_user_by_handle(userlist, newhand))
389
404
      x = 0;
390
 
    else if (!egg_strcasecmp(botnetnick, newhand) &&
391
 
             (!(u->flags & USER_BOT) || nextbot (argv [1]) != -1))
 
405
    else if (!egg_strcasecmp(botnetnick, newhand) && (!(u->flags & USER_BOT) ||
 
406
             nextbot(argv[1]) != -1))
392
407
      x = 0;
393
408
    else if (newhand[0] == '*')
394
409
      x = 0;
395
410
  }
396
411
  if (x)
397
 
     x = change_handle(u, newhand);
 
412
    x = change_handle(u, newhand);
 
413
 
398
414
  Tcl_AppendResult(irp, x ? "1" : "0", NULL);
399
415
  return TCL_OK;
400
416
}
404
420
  int i;
405
421
 
406
422
  BADARGS(1, 1, "");
 
423
 
407
424
  for (i = 0; i < dcc_total; i++) {
408
425
    if (dcc[i].type == &DCC_BOT && dcc[i].status & STAT_GETTING) {
409
426
      Tcl_AppendResult(irp, "1", NULL);
417
434
static int tcl_isignore STDVAR
418
435
{
419
436
  BADARGS(2, 2, " nick!user@host");
 
437
 
420
438
  Tcl_AppendResult(irp, match_ignore(argv[1]) ? "1" : "0", NULL);
421
439
  return TCL_OK;
422
440
}
427
445
  char ign[UHOSTLEN], cmt[66], from[HANDLEN + 1];
428
446
 
429
447
  BADARGS(4, 5, " hostmask creator comment ?lifetime?");
 
448
 
430
449
  strncpyz(ign, argv[1], sizeof ign);
431
450
  strncpyz(from, argv[2], sizeof from);
432
451
  strncpyz(cmt, argv[3], sizeof cmt);
 
452
 
433
453
  if (argc == 4)
434
 
     expire_time = now + (60 * ignore_time);
 
454
    expire_time = now + (60 * ignore_time);
435
455
  else {
436
456
    if (argc == 5 && atol(argv[4]) == 0)
437
457
      expire_time = 0L;
445
465
static int tcl_killignore STDVAR
446
466
{
447
467
  BADARGS(2, 2, " hostmask");
 
468
 
448
469
  Tcl_AppendResult(irp, delignore(argv[1]) ? "1" : "0", NULL);
449
470
  return TCL_OK;
450
471
}
451
472
 
452
 
/* { hostmask note expire-time create-time creator }
453
 
 */
454
473
static int tcl_ignorelist STDVAR
455
474
{
 
475
  char expire[11], added[11], *p;
 
476
  EGG_CONST char *list[5];
456
477
  struct igrec *i;
457
 
  char expire[11], added[11], *list[5], *p;
458
478
 
459
479
  BADARGS(1, 1, "");
 
480
 
460
481
  for (i = global_ign; i; i = i->next) {
461
482
    list[0] = i->igmask;
462
483
    list[1] = i->msg;
479
500
  struct user_entry *e;
480
501
 
481
502
  BADARGS(3, 999, " handle type");
 
503
 
482
504
  if (!(et = find_entry_type(argv[2])) && egg_strcasecmp(argv[2], "HANDLE")) {
483
505
    Tcl_AppendResult(irp, "No such info type: ", argv[2], NULL);
484
506
    return TCL_ERROR;
488
510
      Tcl_AppendResult(irp, "No such user.", NULL);
489
511
      return TCL_ERROR;
490
512
    } else
491
 
      return TCL_OK;            /* silently ignore user * */
 
513
      return TCL_OK; /* silently ignore user */
492
514
  }
493
 
  if (!egg_strcasecmp(argv[2], "HANDLE")) {
494
 
    Tcl_AppendResult(irp,u->handle, NULL);
495
 
  } else {
496
 
  e = find_user_entry(et, u);
497
 
  if (e)
498
 
    return et->tcl_get(irp, u, e, argc, argv);
 
515
  if (!egg_strcasecmp(argv[2], "HANDLE"))
 
516
    Tcl_AppendResult(irp, u->handle, NULL);
 
517
  else {
 
518
    e = find_user_entry(et, u);
 
519
    if (e)
 
520
      return et->tcl_get(irp, u, e, argc, argv);
499
521
  }
500
522
  return TCL_OK;
501
523
}
506
528
  struct userrec *u;
507
529
  struct user_entry *e;
508
530
  int r;
 
531
  module_entry *me;
509
532
 
510
533
  BADARGS(3, 999, " handle type ?setting....?");
 
534
 
511
535
  if (!(et = find_entry_type(argv[2]))) {
512
536
    Tcl_AppendResult(irp, "No such info type: ", argv[2], NULL);
513
537
    return TCL_ERROR;
517
541
      Tcl_AppendResult(irp, "No such user.", NULL);
518
542
      return TCL_ERROR;
519
543
    } else
520
 
      return TCL_OK;            /* Silently ignore user * */
 
544
      return TCL_OK; /* Silently ignore user * */
 
545
  }
 
546
  me = module_find("irc", 0, 0);
 
547
  if (me && !strcmp(argv[2], "hosts") && argc == 3) {
 
548
    Function *func = me->funcs;
 
549
 
 
550
    (func[IRC_CHECK_THIS_USER]) (argv[1], 1, NULL);
521
551
  }
522
552
  if (!(e = find_user_entry(et, u))) {
523
553
    e = user_malloc(sizeof(struct user_entry));
528
558
  }
529
559
  r = et->tcl_set(irp, u, e, argc, argv);
530
560
  /* Yeah... e is freed, and we read it... (tcl: setuser hand HOSTS none) */
531
 
  if (!e->u.list) {
532
 
    if (list_delete((struct list_type **) &(u->entries),
533
 
                    (struct list_type *) e))
534
 
      nfree(e);
 
561
  if ((!e->u.list) && (list_delete((struct list_type **) &(u->entries),
 
562
      (struct list_type *) e)))
 
563
    nfree(e);
535
564
    /* else maybe already freed... (entry_type==HOSTS) <drummer> */
 
565
  if (me && !strcmp(argv[2], "hosts") && argc == 4) {
 
566
    Function *func = me->funcs;
 
567
 
 
568
    (func[IRC_CHECK_THIS_USER]) (argv[1], 0, NULL);
536
569
  }
537
570
  return r;
538
571
}
539
572
 
540
 
tcl_cmds tcluser_cmds[] =
541
 
{
542
 
  {"countusers",        tcl_countusers},
543
 
  {"validuser",         tcl_validuser},
544
 
  {"finduser",          tcl_finduser},
545
 
  {"passwdok",          tcl_passwdOk},
546
 
  {"chattr",            tcl_chattr},
547
 
  {"botattr",           tcl_botattr},
548
 
  {"matchattr",         tcl_matchattr},
549
 
  {"matchchanattr",     tcl_matchattr},
550
 
  {"adduser",           tcl_adduser},
551
 
  {"addbot",            tcl_addbot},
552
 
  {"deluser",           tcl_deluser},
553
 
  {"delhost",           tcl_delhost},
554
 
  {"userlist",          tcl_userlist},
555
 
  {"save",              tcl_save},
556
 
  {"reload",            tcl_reload},
557
 
  {"chhandle",          tcl_chhandle},
558
 
  {"chnick",            tcl_chhandle},
559
 
  {"getting-users",     tcl_getting_users},
560
 
  {"isignore",          tcl_isignore},
561
 
  {"newignore",         tcl_newignore},
562
 
  {"killignore",        tcl_killignore},
563
 
  {"ignorelist",        tcl_ignorelist},
564
 
  {"getuser",           tcl_getuser},
565
 
  {"setuser",           tcl_setuser},
566
 
  {NULL,                NULL}
 
573
tcl_cmds tcluser_cmds[] = {
 
574
  {"countusers",       tcl_countusers},
 
575
  {"validuser",         tcl_validuser},
 
576
  {"finduser",           tcl_finduser},
 
577
  {"passwdok",           tcl_passwdOk},
 
578
  {"chattr",               tcl_chattr},
 
579
  {"botattr",             tcl_botattr},
 
580
  {"matchattr",         tcl_matchattr},
 
581
  {"matchchanattr",     tcl_matchattr},
 
582
  {"adduser",             tcl_adduser},
 
583
  {"addbot",               tcl_addbot},
 
584
  {"deluser",             tcl_deluser},
 
585
  {"delhost",             tcl_delhost},
 
586
  {"userlist",           tcl_userlist},
 
587
  {"save",                   tcl_save},
 
588
  {"reload",               tcl_reload},
 
589
  {"chhandle",           tcl_chhandle},
 
590
  {"chnick",             tcl_chhandle},
 
591
  {"getting-users", tcl_getting_users},
 
592
  {"isignore",           tcl_isignore},
 
593
  {"newignore",         tcl_newignore},
 
594
  {"killignore",       tcl_killignore},
 
595
  {"ignorelist",       tcl_ignorelist},
 
596
  {"getuser",             tcl_getuser},
 
597
  {"setuser",             tcl_setuser},
 
598
  {NULL,                         NULL}
567
599
};