← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/mod/irc.mod/tclirc.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/mod/irc.mod/tclirc.c
1
1
/*
2
2
 * tclirc.c -- part of irc.mod
3
3
 *
4
 
 * $Id: tclirc.c,v 1.31 2002/01/02 03:46:39 guppy Exp $
 
4
 * $Id: tclirc.c,v 1.45 2004/01/09 05:56:38 wcc Exp $
5
5
 */
6
6
/*
7
7
 * Copyright (C) 1997 Robey Pointer
8
 
 * Copyright (C) 1999, 2000, 2001, 2002 Eggheads Development Team
 
8
 * Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004 Eggheads Development Team
9
9
 *
10
10
 * This program is free software; you can redistribute it and/or
11
11
 * modify it under the terms of the GNU General Public License
26
26
 */
27
27
static int tcl_chanlist STDVAR
28
28
{
 
29
  char nuh[1024];
29
30
  int f;
30
31
  memberlist *m;
31
32
  struct chanset_t *chan;
32
 
  struct flag_record plus = {FR_CHAN | FR_GLOBAL | FR_BOT, 0, 0, 0, 0, 0},
33
 
                     minus = {FR_CHAN | FR_GLOBAL | FR_BOT, 0, 0, 0, 0, 0},
34
 
                     user = {FR_CHAN | FR_GLOBAL | FR_BOT, 0, 0, 0, 0, 0};
 
33
  struct flag_record plus = { FR_CHAN | FR_GLOBAL | FR_BOT, 0, 0, 0, 0, 0 },
 
34
                     minus = { FR_CHAN | FR_GLOBAL | FR_BOT, 0, 0, 0, 0, 0},
 
35
                     user = { FR_CHAN | FR_GLOBAL | FR_BOT, 0, 0, 0, 0, 0 };
35
36
 
36
37
  BADARGS(2, 3, " channel ?flags?");
 
38
 
37
39
  chan = findchan_by_dname(argv[1]);
38
40
  if (!chan) {
39
41
    Tcl_AppendResult(irp, "invalid channel: ", argv[1], NULL);
46
48
    return TCL_OK;
47
49
  }
48
50
  break_down_flags(argv[2], &plus, &minus);
49
 
  f = (minus.global || minus.udef_global ||
50
 
       minus.chan || minus.udef_chan || minus.bot);
 
51
  f = (minus.global || minus.udef_global || minus.chan || minus.udef_chan ||
 
52
       minus.bot);
51
53
  /* Return empty set if asked for flags but flags don't exist */
52
 
  if (!plus.global && !plus.udef_global &&
53
 
      !plus.chan && !plus.udef_chan && !plus.bot && !f)
 
54
  if (!plus.global &&!plus.udef_global && !plus.chan && !plus.udef_chan &&
 
55
      !plus.bot && !f)
54
56
    return TCL_OK;
55
57
  minus.match = plus.match ^ (FR_AND | FR_OR);
56
58
 
57
59
  for (m = chan->channel.member; m && m->nick[0]; m = m->next) {
 
60
    if (!m->user) {
 
61
      egg_snprintf(nuh, sizeof nuh, "%s!%s", m->nick, m->userhost);
 
62
      m->user = get_user_by_host(nuh);
 
63
    }
58
64
    get_user_flagrec(m->user, &user, argv[1]);
59
65
    user.match = plus.match;
60
66
    if (flagrec_eq(&plus, &user)) {
61
67
      if (!f || !flagrec_eq(&minus, &user))
62
 
        Tcl_AppendElement(irp, m->nick);
 
68
        Tcl_AppendElement(irp, m->nick);
63
69
    }
64
70
  }
65
71
  return TCL_OK;
70
76
  struct chanset_t *chan, *thechan = NULL;
71
77
 
72
78
  BADARGS(1, 2, " ?channel?");
 
79
 
73
80
  if (argc > 1) {
74
81
    chan = findchan_by_dname(argv[1]);
75
82
    thechan = chan;
78
85
      return TCL_ERROR;
79
86
    }
80
87
  } else
81
 
   chan = chanset;
82
 
   
 
88
    chan = chanset;
 
89
 
83
90
  while (chan && (thechan == NULL || thechan == chan)) {
84
91
    if (me_op(chan)) {
85
92
      Tcl_AppendResult(irp, "1", NULL);
91
98
  return TCL_OK;
92
99
}
93
100
 
 
101
static int tcl_botishalfop STDVAR
 
102
{
 
103
  struct chanset_t *chan, *thechan = NULL;
 
104
 
 
105
  BADARGS(1, 2, " ?channel?");
 
106
 
 
107
  if (argc > 1) {
 
108
    chan = findchan_by_dname(argv[1]);
 
109
    thechan = chan;
 
110
    if (!thechan) {
 
111
      Tcl_AppendResult(irp, "illegal channel: ", argv[1], NULL);
 
112
      return TCL_ERROR;
 
113
    }
 
114
  } else
 
115
    chan = chanset;
 
116
 
 
117
  while (chan && (thechan == NULL || thechan == chan)) {
 
118
    if (me_halfop(chan)) {
 
119
      Tcl_AppendResult(irp, "1", NULL);
 
120
      return TCL_OK;
 
121
    }
 
122
    chan = chan->next;
 
123
  }
 
124
  Tcl_AppendResult(irp, "0", NULL);
 
125
  return TCL_OK;
 
126
}
 
127
 
94
128
static int tcl_ischanjuped STDVAR
95
129
{
96
130
  struct chanset_t *chan;
97
131
 
98
132
  BADARGS(2, 2, " channel");
 
133
  
99
134
  chan = findchan_by_dname(argv[1]);
100
135
  if (chan == NULL) {
101
136
    Tcl_AppendResult(irp, "illegal channel: ", argv[1], NULL);
114
149
  memberlist *mx;
115
150
 
116
151
  BADARGS(1, 2, " ?channel?");
 
152
 
117
153
  if (argc > 1) {
118
154
    chan = findchan_by_dname(argv[1]);
119
155
    thechan = chan;
122
158
      return TCL_ERROR;
123
159
    }
124
160
  } else
125
 
   chan = chanset;
126
 
    
 
161
    chan = chanset;
 
162
 
127
163
  while (chan && (thechan == NULL || thechan == chan)) {
128
164
    if ((mx = ismember(chan, botname)) && chan_hasvoice(mx)) {
129
165
      Tcl_AppendResult(irp, "1", NULL);
140
176
  struct chanset_t *chan, *thechan = NULL;
141
177
 
142
178
  BADARGS(1, 2, " ?channel?");
 
179
 
143
180
  if (argc > 1) {
144
181
    chan = findchan_by_dname(argv[1]);
145
182
    thechan = chan;
148
185
      return TCL_ERROR;
149
186
    }
150
187
  } else
151
 
   chan = chanset;
 
188
    chan = chanset;
152
189
 
153
190
  while (chan && (thechan == NULL || thechan == chan)) {
154
191
    if (ismember(chan, botname)) {
157
194
    }
158
195
    chan = chan->next;
159
196
  }
160
 
  Tcl_AppendResult(irp, "0", NULL); 
 
197
  Tcl_AppendResult(irp, "0", NULL);
161
198
  return TCL_OK;
162
199
}
163
200
 
165
202
{
166
203
  struct chanset_t *chan, *thechan = NULL;
167
204
  memberlist *mx;
168
 
      
169
 
  BADARGS(2, 3, " ?nick channel?");
 
205
 
 
206
  BADARGS(2, 3, " nick ?channel?");
 
207
  
170
208
  if (argc > 2) {
171
209
    chan = findchan_by_dname(argv[2]);
172
210
    thechan = chan;
175
213
      return TCL_ERROR;
176
214
    }
177
215
  } else
178
 
   chan = chanset;
179
 
  
 
216
    chan = chanset;
 
217
 
180
218
  while (chan && (thechan == NULL || thechan == chan)) {
181
219
    if ((mx = ismember(chan, argv[1])) && chan_hasop(mx)) {
182
220
      Tcl_AppendResult(irp, "1", NULL);
188
226
  return TCL_OK;
189
227
}
190
228
 
 
229
static int tcl_ishalfop STDVAR
 
230
{
 
231
  struct chanset_t *chan, *thechan = NULL;
 
232
  memberlist *mx;
 
233
 
 
234
  BADARGS(2, 3, " nick ?channel?");
 
235
 
 
236
  if (argc > 2) {
 
237
    chan = findchan_by_dname(argv[2]);
 
238
    thechan = chan;
 
239
    if (!thechan) {
 
240
      Tcl_AppendResult(irp, "illegal channel: ", argv[2], NULL);
 
241
      return TCL_ERROR;
 
242
    }
 
243
  } else
 
244
    chan = chanset;
 
245
 
 
246
  while (chan && (thechan == NULL || thechan == chan)) {
 
247
    if ((mx = ismember(chan, argv[1])) && chan_hashalfop(mx)) {
 
248
      Tcl_AppendResult(irp, "1", NULL);
 
249
      return TCL_OK;
 
250
    }
 
251
    chan = chan->next;
 
252
  }
 
253
  Tcl_AppendResult(irp, "0", NULL);
 
254
  return TCL_OK;
 
255
}
 
256
 
191
257
static int tcl_isvoice STDVAR
192
258
{
193
259
  struct chanset_t *chan, *thechan = NULL;
194
260
  memberlist *mx;
195
261
 
196
 
  BADARGS(2, 3, " ?nick channel?");
 
262
  BADARGS(2, 3, " nick ?channel?");
 
263
 
197
264
  if (argc > 2) {
198
265
    chan = findchan_by_dname(argv[2]);
199
266
    thechan = chan;
202
269
      return TCL_ERROR;
203
270
    }
204
271
  } else
205
 
   chan = chanset;
206
 
    
 
272
    chan = chanset;
 
273
 
207
274
  while (chan && (thechan == NULL || thechan == chan)) {
208
275
    if ((mx = ismember(chan, argv[1])) && chan_hasvoice(mx)) {
209
276
      Tcl_AppendResult(irp, "1", NULL);
221
288
  memberlist *mx;
222
289
 
223
290
  BADARGS(3, 3, " nick channel");
 
291
  
224
292
  chan = findchan_by_dname(argv[2]);
225
293
  if (chan == NULL) {
226
294
    Tcl_AppendResult(irp, "illegal channel: ", argv[2], NULL);
233
301
  return TCL_OK;
234
302
}
235
303
 
 
304
static int tcl_washalfop STDVAR
 
305
{
 
306
  struct chanset_t *chan;
 
307
  memberlist *mx;
 
308
 
 
309
  BADARGS(3, 3, " nick channel");
 
310
  
 
311
  chan = findchan_by_dname(argv[2]);
 
312
  if (chan == NULL) {
 
313
    Tcl_AppendResult(irp, "illegal channel: ", argv[2], NULL);
 
314
    return TCL_ERROR;
 
315
  }
 
316
  if ((mx = ismember(chan, argv[1])) && chan_washalfop(mx))
 
317
    Tcl_AppendResult(irp, "1", NULL);
 
318
  else
 
319
    Tcl_AppendResult(irp, "0", NULL);
 
320
  return TCL_OK;
 
321
}
236
322
 
237
323
static int tcl_onchan STDVAR
238
324
{
239
325
  struct chanset_t *chan, *thechan = NULL;
240
326
 
241
327
  BADARGS(2, 3, " nickname ?channel?");
 
328
 
242
329
  if (argc > 2) {
243
330
    chan = findchan_by_dname(argv[2]);
244
331
    thechan = chan;
245
 
    if (!thechan) { 
 
332
    if (!thechan) {
246
333
      Tcl_AppendResult(irp, "illegal channel: ", argv[2], NULL);
247
334
      return TCL_ERROR;
248
335
    }
249
336
  } else
250
 
   chan = chanset;
 
337
    chan = chanset;
251
338
 
252
339
  while (chan && (thechan == NULL || thechan == chan)) {
253
340
    if (ismember(chan, argv[1])) {
262
349
 
263
350
static int tcl_handonchan STDVAR
264
351
{
 
352
  char nuh[1024];
265
353
  struct chanset_t *chan, *thechan = NULL;
266
354
  memberlist *m;
267
355
 
268
356
  BADARGS(2, 3, " handle ?channel?");
 
357
 
269
358
  if (argc > 2) {
270
359
    chan = findchan_by_dname(argv[2]);
271
360
    thechan = chan;
274
363
      return TCL_ERROR;
275
364
    }
276
365
  } else
277
 
   chan = chanset;
 
366
    chan = chanset;
278
367
 
279
368
  while (chan && (thechan == NULL || thechan == chan)) {
280
369
    for (m = chan->channel.member; m && m->nick[0]; m = m->next) {
 
370
      if (!m->user) {
 
371
        egg_snprintf(nuh, sizeof nuh, "%s!%s", m->nick, m->userhost);
 
372
        m->user = get_user_by_host(nuh);
 
373
      }
281
374
      if (m->user && !rfc_casecmp(m->user->handle, argv[1])) {
282
 
        Tcl_AppendResult(irp, "1", NULL);
283
 
        return TCL_OK;
 
375
        Tcl_AppendResult(irp, "1", NULL);
 
376
        return TCL_OK;
284
377
      }
285
378
    }
286
379
    chan = chan->next;
294
387
  struct chanset_t *chan;
295
388
 
296
389
  BADARGS(3, 3, " ban channel");
 
390
  
297
391
  chan = findchan_by_dname(argv[2]);
298
392
  if (chan == NULL) {
299
393
    Tcl_AppendResult(irp, "illegal channel: ", argv[2], NULL);
311
405
  struct chanset_t *chan;
312
406
 
313
407
  BADARGS(3, 3, " exempt channel");
 
408
  
314
409
  chan = findchan_by_dname(argv[2]);
315
410
  if (chan == NULL) {
316
411
    Tcl_AppendResult(irp, "illegal channel: ", argv[2], NULL);
328
423
  struct chanset_t *chan;
329
424
 
330
425
  BADARGS(3, 3, " invite channel");
 
426
  
331
427
  chan = findchan_by_dname(argv[2]);
332
428
  if (chan == NULL) {
333
429
    Tcl_AppendResult(irp, "illegal channel: ", argv[2], NULL);
345
441
  struct chanset_t *chan, *thechan = NULL;
346
442
  memberlist *m;
347
443
 
348
 
  BADARGS(2, 3, " nickname ?channel?"); /* drummer */
 
444
  BADARGS(2, 3, " nickname ?channel?");
 
445
 
349
446
  if (argc > 2) {
350
447
    chan = findchan_by_dname(argv[2]);
351
448
    thechan = chan;
353
450
      Tcl_AppendResult(irp, "illegal channel: ", argv[2], NULL);
354
451
      return TCL_ERROR;
355
452
    }
356
 
  } else 
 
453
  } else
357
454
    chan = chanset;
358
455
 
359
456
  while (chan && (thechan == NULL || thechan == chan)) {
373
470
  memberlist *m;
374
471
 
375
472
  BADARGS(2, 3, " nickname ?channel?");
 
473
  
376
474
  if (argc > 2) {
377
 
    chan = findchan_by_dname(argv[2]);   
 
475
    chan = findchan_by_dname(argv[2]);
378
476
    thechan = chan;
379
477
    if (!thechan) {
380
478
      Tcl_AppendResult(irp, "illegal channel: ", argv[2], NULL);
381
479
      return TCL_ERROR;
382
480
    }
383
481
  } else
384
 
   chan = chanset;
385
 
  
 
482
    chan = chanset;
 
483
 
386
484
  while (chan && (thechan == NULL || thechan == chan)) {
387
485
    m = ismember(chan, argv[1]);
388
486
    if (m && chan_issplit(m)) {
398
496
static int tcl_maskhost STDVAR
399
497
{
400
498
  char new[121];
 
499
 
401
500
  BADARGS(2, 2, " nick!user@host");
402
 
  maskhost(argv[1], new);
 
501
   
 
502
  maskban(argv[1], new);
403
503
  Tcl_AppendResult(irp, new, NULL);
404
504
  return TCL_OK;
405
505
}
412
512
  int x;
413
513
 
414
514
  BADARGS(3, 3, " nickname channel");
 
515
 
415
516
  if (!(chan = findchan_by_dname(argv[2]))) {
416
517
    Tcl_AppendResult(irp, "invalid channel: ", argv[2], NULL);
417
518
    return TCL_ERROR;
418
519
  }
419
520
  m = ismember(chan, argv[1]);
 
521
 
420
522
  if (m) {
421
523
    x = (now - (m->last)) / 60;
422
524
    simple_sprintf(s, "%d", x);
429
531
 
430
532
static inline int tcl_chanmasks(masklist *m, Tcl_Interp *irp)
431
533
{
432
 
  char *list[3], work[20], *p;
 
534
  char work[20], *p;
 
535
  EGG_CONST char *list[3];
433
536
 
434
537
  for (; m && m->mask && m->mask[0]; m = m->next) {
435
538
    list[0] = m->mask;
448
551
  struct chanset_t *chan;
449
552
 
450
553
  BADARGS(2, 2, " channel");
 
554
  
451
555
  chan = findchan_by_dname(argv[1]);
452
556
  if (chan == NULL) {
453
557
    Tcl_AppendResult(irp, "illegal channel: ", argv[2], NULL);
461
565
  struct chanset_t *chan;
462
566
 
463
567
  BADARGS(2, 2, " channel");
 
568
  
464
569
  chan = findchan_by_dname(argv[1]);
465
570
  if (chan == NULL) {
466
571
    Tcl_AppendResult(irp, "illegal channel: ", argv[2], NULL);
474
579
  struct chanset_t *chan;
475
580
 
476
581
  BADARGS(2, 2, " channel");
 
582
  
477
583
  chan = findchan_by_dname(argv[1]);
478
584
  if (chan == NULL) {
479
585
    Tcl_AppendResult(irp, "illegal channel: ", argv[2], NULL);
487
593
  struct chanset_t *chan;
488
594
 
489
595
  BADARGS(2, 2, " channel");
 
596
  
490
597
  chan = findchan_by_dname(argv[1]);
491
598
  if (chan == NULL) {
492
599
    Tcl_AppendResult(irp, "invalid channel: ", argv[1], NULL);
503
610
  memberlist *m;
504
611
 
505
612
  BADARGS(3, 3, " nick channel");
 
613
  
506
614
  chan = findchan_by_dname(argv[2]);
507
615
  if (chan == NULL) {
508
 
    Tcl_AppendResult(irp, "invalid cahnnel: ", argv[2], NULL);
 
616
    Tcl_AppendResult(irp, "invalid channel: ", argv[2], NULL);
509
617
    return TCL_ERROR;
510
618
  }
511
619
  m = ismember(chan, argv[1]);
 
620
 
512
621
  if (m == NULL) {
513
622
    Tcl_AppendResult(irp, argv[1], " is not on ", argv[2], NULL);
514
623
    return TCL_ERROR;
523
632
  struct chanset_t *chan;
524
633
 
525
634
  BADARGS(2, 2, " channel-name");
 
635
  
526
636
  chan = findchan(argv[1]);
527
637
  if (chan) {
528
 
      Tcl_AppendResult(irp, chan->dname, NULL);
529
 
      return TCL_OK;
 
638
    Tcl_AppendResult(irp, chan->dname, NULL);
 
639
    return TCL_OK;
530
640
  } else {
531
 
      Tcl_AppendResult(irp, "invalid channel-name: ", argv[1], NULL);
532
 
      return TCL_ERROR;
 
641
    Tcl_AppendResult(irp, "invalid channel-name: ", argv[1], NULL);
 
642
    return TCL_ERROR;
533
643
  }
534
644
}
535
645
 
538
648
  struct chanset_t *chan;
539
649
 
540
650
  BADARGS(2, 2, " channel-dname");
 
651
  
541
652
  chan = findchan_by_dname(argv[1]);
542
653
  if (chan) {
543
 
      Tcl_AppendResult(irp, chan->name, NULL);
544
 
      return TCL_OK;
 
654
    Tcl_AppendResult(irp, chan->name, NULL);
 
655
    return TCL_OK;
545
656
  } else {
546
 
      Tcl_AppendResult(irp, "invalid channel-dname: ", argv[1], NULL);
547
 
      return TCL_ERROR;
 
657
    Tcl_AppendResult(irp, "invalid channel-dname: ", argv[1], NULL);
 
658
    return TCL_ERROR;
548
659
  }
549
660
}
550
661
 
551
 
/* flushmode <chan> */
552
662
static int tcl_flushmode STDVAR
553
663
{
554
664
  struct chanset_t *chan;
555
665
 
556
666
  BADARGS(2, 2, " channel");
 
667
 
557
668
  chan = findchan_by_dname(argv[1]);
558
669
  if (chan == NULL) {
559
670
    Tcl_AppendResult(irp, "invalid channel: ", argv[1], NULL);
569
680
  char plus, mode;
570
681
 
571
682
  BADARGS(3, 4, " channel mode ?arg?");
 
683
  
572
684
  chan = findchan_by_dname(argv[1]);
573
685
  if (chan == NULL) {
574
686
    Tcl_AppendResult(irp, "invalid channel: ", argv[1], NULL);
575
687
    return TCL_ERROR;
576
688
  }
577
689
  plus = argv[2][0];
 
690
 
578
691
  mode = argv[2][1];
579
692
  if ((plus != '+') && (plus != '-')) {
580
693
    mode = plus;
592
705
  struct chanset_t *chan;
593
706
 
594
707
  BADARGS(2, 2, " channel");
 
708
  
595
709
  chan = findchan_by_dname(argv[1]);
596
710
  if (chan == NULL) {
597
711
    Tcl_AppendResult(irp, "invalid channel ", argv[1], NULL);
606
720
  struct chanset_t *chan;
607
721
 
608
722
  BADARGS(2, 2, " channel");
 
723
  
609
724
  chan = findchan_by_dname(argv[1]);
610
725
  if (chan == NULL) {
611
726
    Tcl_AppendResult(irp, "invalid channel ", argv[1], NULL);
620
735
  struct chanset_t *chan;
621
736
 
622
737
  BADARGS(2, 2, " channel");
 
738
  
623
739
  chan = findchan_by_dname(argv[1]);
624
740
  if (chan == NULL) {
625
741
    Tcl_AppendResult(irp, "invalid channel ", argv[1], NULL);
634
750
  struct chanset_t *chan;
635
751
 
636
752
  BADARGS(2, 2, " channel");
 
753
  
637
754
  chan = findchan_by_dname(argv[1]);
638
755
  if (chan == NULL) {
639
756
    Tcl_AppendResult(irp, "invalid channel ", argv[1], NULL);
648
765
  struct chanset_t *chan;
649
766
 
650
767
  BADARGS(2, 2, " channel");
 
768
  
651
769
  chan = findchan_by_dname(argv[1]);
652
770
  if (chan == NULL) {
653
771
    Tcl_AppendResult(irp, "invalid channel ", argv[1], NULL);
659
777
 
660
778
static int tcl_hand2nick STDVAR
661
779
{
 
780
  char nuh[1024];
662
781
  memberlist *m;
663
782
  struct chanset_t *chan, *thechan = NULL;
664
783
 
665
 
  BADARGS(2, 3, " handle ?channel?");   /* drummer */
 
784
  BADARGS(2, 3, " handle ?channel?");
 
785
 
666
786
  if (argc > 2) {
667
787
    chan = findchan_by_dname(argv[2]);
668
788
    thechan = chan;
675
795
 
676
796
  while (chan && (thechan == NULL || thechan == chan)) {
677
797
    for (m = chan->channel.member; m && m->nick[0]; m = m->next) {
 
798
      if (!m->user && !m->tried_getuser) {
 
799
        egg_snprintf(nuh, sizeof nuh, "%s!%s", m->nick, m->userhost);
 
800
        m->tried_getuser = 1;
 
801
        m->user = get_user_by_host(nuh);
 
802
      }
678
803
      if (m->user && !rfc_casecmp(m->user->handle, argv[1])) {
679
 
          Tcl_AppendResult(irp, m->nick, NULL);
680
 
          return TCL_OK;
681
 
        }
 
804
        Tcl_AppendResult(irp, m->nick, NULL);
 
805
        return TCL_OK;
682
806
      }
 
807
    }
683
808
    chan = chan->next;
684
809
  }
685
810
  return TCL_OK;
687
812
 
688
813
static int tcl_nick2hand STDVAR
689
814
{
 
815
  char nuh[1024];
690
816
  memberlist *m;
691
817
  struct chanset_t *chan, *thechan = NULL;
692
818
 
693
 
  BADARGS(2, 3, " nick ?channel?");     /* drummer */
 
819
  BADARGS(2, 3, " nick ?channel?");
 
820
 
694
821
  if (argc > 2) {
695
822
    chan = findchan_by_dname(argv[2]);
696
823
    thechan = chan;
704
831
  while (chan && (thechan == NULL || thechan == chan)) {
705
832
    m = ismember(chan, argv[1]);
706
833
    if (m) {
 
834
      if (!m->user) {
 
835
        egg_snprintf(nuh, sizeof nuh, "%s!%s", m->nick, m->userhost);
 
836
        m->user = get_user_by_host(nuh);
 
837
      }
707
838
      Tcl_AppendResult(irp, m->user ? m->user->handle : "*", NULL);
708
839
      return TCL_OK;
709
840
    }
710
841
    chan = chan->next;
711
842
  }
712
 
  Tcl_AppendResult(irp, "*", NULL);
713
843
  return TCL_OK;
714
844
}
715
845
 
716
 
/* Sends an optimal number of kicks per command (as defined by kick_method)
717
 
 * to the server, simialer to kick_all.
718
 
 */
719
846
static int tcl_putkick STDVAR
720
847
{
721
848
  struct chanset_t *chan;
724
851
  memberlist *m;
725
852
 
726
853
  BADARGS(3, 4, " channel nick?s? ?comment?");
 
854
  
727
855
  chan = findchan_by_dname(argv[1]);
728
856
  if (chan == NULL) {
729
857
    Tcl_AppendResult(irp, "illegal channel: ", argv[1], NULL);
733
861
    comment = argv[3];
734
862
  else
735
863
    comment = "";
736
 
  if (!me_op(chan)) {
737
 
    Tcl_AppendResult(irp, "need op", NULL);
 
864
  if (!me_op(chan) && !me_halfop(chan)) {
 
865
    Tcl_AppendResult(irp, "need op or halfop", NULL);
738
866
    return TCL_ERROR;
739
867
  }
740
868
 
741
869
  kicknick[0] = 0;
742
870
  p = argv[2];
743
871
  /* Loop through all given nicks */
744
 
  while(p) {
 
872
  while (p) {
745
873
    nick = p;
746
 
    p = strchr(nick, ',');      /* Search for beginning of next nick */
 
874
    p = strchr(nick, ',');      /* Search for beginning of next nick */
747
875
    if (p) {
748
876
      *p = 0;
749
877
      p++;
750
878
    }
751
879
 
752
880
    m = ismember(chan, nick);
 
881
    if (!me_op(chan) && !(me_halfop(chan) && !chan_hasop(m))) {
 
882
      Tcl_AppendResult(irp, "need op", NULL);
 
883
      return TCL_ERROR;
 
884
    }
753
885
    if (!m)
754
 
      continue;                 /* Skip non-existant nicks */
755
 
    m->flags |= SENTKICK;       /* Mark as pending kick */
 
886
      continue;                 /* Skip non-existant nicks */
 
887
    m->flags |= SENTKICK;       /* Mark as pending kick */
756
888
    if (kicknick[0])
757
889
      strcat(kicknick, ",");
758
 
    strcat(kicknick, nick);     /* Add to local queue */
 
890
    strcat(kicknick, nick);     /* Add to local queue */
759
891
    k++;
760
892
 
761
893
    /* Check if we should send the kick command yet */
772
904
  return TCL_OK;
773
905
}
774
906
 
775
 
static tcl_cmds tclchan_cmds[] =
776
 
{
777
 
  {"chanlist",          tcl_chanlist},
778
 
  {"botisop",           tcl_botisop},
779
 
  {"botisvoice",        tcl_botisvoice},
780
 
  {"isop",              tcl_isop},
781
 
  {"wasop",             tcl_wasop},
782
 
  {"isvoice",           tcl_isvoice},
783
 
  {"onchan",            tcl_onchan},
784
 
  {"handonchan",        tcl_handonchan},
785
 
  {"ischanban",         tcl_ischanban},
786
 
  {"ischanexempt",      tcl_ischanexempt},
787
 
  {"ischaninvite",      tcl_ischaninvite},
788
 
  {"ischanjuped",       tcl_ischanjuped},
789
 
  {"getchanhost",       tcl_getchanhost},
790
 
  {"onchansplit",       tcl_onchansplit},
791
 
  {"maskhost",          tcl_maskhost},
792
 
  {"getchanidle",       tcl_getchanidle},
793
 
  {"chanbans",          tcl_chanbans},
794
 
  {"chanexempts",       tcl_chanexempts},
795
 
  {"chaninvites",       tcl_chaninvites},
796
 
  {"hand2nick",         tcl_hand2nick},
797
 
  {"nick2hand",         tcl_nick2hand},
798
 
  {"getchanmode",       tcl_getchanmode},
799
 
  {"getchanjoin",       tcl_getchanjoin},
800
 
  {"flushmode",         tcl_flushmode},
801
 
  {"pushmode",          tcl_pushmode},
802
 
  {"resetbans",         tcl_resetbans},
803
 
  {"resetexempts",      tcl_resetexempts},
804
 
  {"resetinvites",      tcl_resetinvites},
805
 
  {"resetchan",         tcl_resetchan},
806
 
  {"topic",             tcl_topic},
807
 
  {"botonchan",         tcl_botonchan},
808
 
  {"putkick",           tcl_putkick},
809
 
  {"channame2dname",    tcl_channame2dname},
810
 
  {"chandname2name",    tcl_chandname2name},
811
 
  {NULL,                NULL}
 
907
static tcl_cmds tclchan_cmds[] = {
 
908
  {"chanlist",       tcl_chanlist},
 
909
  {"botisop",        tcl_botisop},
 
910
  {"botishalfop",    tcl_botishalfop},
 
911
  {"botisvoice",     tcl_botisvoice},
 
912
  {"isop",           tcl_isop},
 
913
  {"wasop",          tcl_wasop},
 
914
  {"ishalfop",       tcl_ishalfop},
 
915
  {"washalfop",      tcl_washalfop},
 
916
  {"isvoice",        tcl_isvoice},
 
917
  {"onchan",         tcl_onchan},
 
918
  {"handonchan",     tcl_handonchan},
 
919
  {"ischanban",      tcl_ischanban},
 
920
  {"ischanexempt",   tcl_ischanexempt},
 
921
  {"ischaninvite",   tcl_ischaninvite},
 
922
  {"ischanjuped",    tcl_ischanjuped},
 
923
  {"getchanhost",    tcl_getchanhost},
 
924
  {"onchansplit",    tcl_onchansplit},
 
925
  {"maskhost",       tcl_maskhost},
 
926
  {"getchanidle",    tcl_getchanidle},
 
927
  {"chanbans",       tcl_chanbans},
 
928
  {"chanexempts",    tcl_chanexempts},
 
929
  {"chaninvites",    tcl_chaninvites},
 
930
  {"hand2nick",      tcl_hand2nick},
 
931
  {"nick2hand",      tcl_nick2hand},
 
932
  {"getchanmode",    tcl_getchanmode},
 
933
  {"getchanjoin",    tcl_getchanjoin},
 
934
  {"flushmode",      tcl_flushmode},
 
935
  {"pushmode",       tcl_pushmode},
 
936
  {"resetbans",      tcl_resetbans},
 
937
  {"resetexempts",   tcl_resetexempts},
 
938
  {"resetinvites",   tcl_resetinvites},
 
939
  {"resetchan",      tcl_resetchan},
 
940
  {"topic",          tcl_topic},
 
941
  {"botonchan",      tcl_botonchan},
 
942
  {"putkick",        tcl_putkick},
 
943
  {"channame2dname", tcl_channame2dname},
 
944
  {"chandname2name", tcl_chandname2name},
 
945
  {NULL,             NULL}
812
946
};