Debian Codegraph @

innd/cc.c

raw ◀ ▶
Source reconstructed at patch state 0 of 7 — not the installed (fully patched) source.
7 Debian patches touch this file
1 /* $Revision: 1.53 $
2 **
3 ** Routines for the control channel. Create a Unix-domain datagram socket
4 ** that processes on the local server send messages to. The control
5 ** channel is used only by ctlinnd to tell the server to perform
6 ** special functions. We use datagrams so that we don't need to do an
7 ** accept() and tie up another descriptor. Recvfrom seems to be broken on
8 ** several systems, so the client passes in the socket name.
9 **
10 ** This module completely rips away all pretense of software layering.
11 */
12 #include <stdio.h>
13 #include <sys/types.h>
14 #include "configdata.h"
15
16 #if defined(DO_PERL)
17 #include <EXTERN.h>
18 #include <perl.h>
19 #include <XSUB.h>
20 #endif
21
22 #include "clibrary.h"
23 #include "innd.h"
24 #include "inndcomm.h"
25 #if defined(DO_HAVE_UNIX_DOMAIN)
26 #include <sys/un.h>
27 #endif /* defined(DO_HAVE_UNIX_DOMAIN) */
28 #include <systemd/sd-daemon.h>
29
30
31 /*
32 ** An entry in the dispatch table. The name, and implementing function,
33 ** of every command we support.
34 */
35 typedef struct _CCDISPATCH {
36 char Name;
37 int argc;
38 STRING (*Function)();
39 } CCDISPATCH;
40
41
42 STATIC STRING CCaddhist();
43 STATIC STRING CCallow();
44 STATIC STRING CCbegin();
45 STATIC STRING CCchgroup();
46 STATIC STRING CCdrop();
47 STATIC STRING CCfeedinfo();
48 STATIC STRING CCflush();
49 STATIC STRING CCflushlogs();
50 STATIC STRING CCgo();
51 STATIC STRING CChangup();
52 STATIC STRING CCreserve();
53 STATIC STRING CClogmode();
54 STATIC STRING CCmode();
55 STATIC STRING CCname();
56 STATIC STRING CCnewgroup();
57 STATIC STRING CCparam();
58 STATIC STRING CCpause();
59 STATIC STRING CCreaders();
60 STATIC STRING CCrefile();
61 STATIC STRING CCreject();
62 STATIC STRING CCreload();
63 STATIC STRING CCrenumber();
64 STATIC STRING CCrmgroup();
65 STATIC STRING CCsend();
66 STATIC STRING CCshutdown();
67 STATIC STRING CCsignal();
68 STATIC STRING CCthrottle();
69 STATIC STRING CCtrace();
70 STATIC STRING CCxabort();
71 STATIC STRING CCxexec();
72 #if defined(DO_TCL)
73 STATIC STRING CCfilter();
74 #endif /* defined(DO_TCL) */
75 #if defined(DO_PERL)
76 STATIC STRING CCperl();
77 #endif /* defined(DO_PERL) */
78
79 STATIC char CCpath[] = _PATH_NEWSCONTROL;
80 STATIC char **CCargv;
81 STATIC char CCnosite[] = "1 No such site";
82 STATIC char CCwrongtype[] = "1 Wrong site type";
83 STATIC char CCnogroup[] = "1 No such group";
84 STATIC char CCnochannel[] = "1 No such channel";
85 STATIC char CCnoreason[] = "1 Empty reason";
86 STATIC char CCbigreason[] = "1 Reason too long";
87 STATIC char CCnotrunning[] = "1 Must be running";
88 STATIC BUFFER CCreply;
89 STATIC CHANNEL *CCchan;
90 STATIC int CCwriter;
91 STATIC CCDISPATCH CCcommands[] = {
92 { SC_ADDHIST, 5, CCaddhist },
93 { SC_ALLOW, 1, CCallow },
94 { SC_BEGIN, 1, CCbegin },
95 { SC_CANCEL, 1, CCcancel },
96 { SC_CHANGEGROUP, 2, CCchgroup },
97 { SC_CHECKFILE, 0, CCcheckfile },
98 { SC_DROP, 1, CCdrop },
99 { SC_FEEDINFO, 1, CCfeedinfo },
100 #if defined(DO_TCL)
101 { SC_FILTER, 1, CCfilter },
102 #endif /* defined(DO_TCL) */
103 #if defined(DO_PERL)
104 { SC_PERL, 1, CCperl },
105 #endif /* defined(DO_PERL) */
106 { SC_FLUSH, 1, CCflush },
107 { SC_FLUSHLOGS, 0, CCflushlogs },
108 { SC_GO, 1, CCgo },
109 { SC_HANGUP, 1, CChangup },
110 { SC_LOGMODE, 0, CClogmode },
111 { SC_MODE, 0, CCmode },
112 { SC_NAME, 1, CCname },
113 { SC_NEWGROUP, 3, CCnewgroup },
114 { SC_PARAM, 2, CCparam },
115 { SC_PAUSE, 1, CCpause },
116 { SC_READERS, 2, CCreaders },
117 { SC_REFILE, 2, CCrefile },
118 { SC_REJECT, 1, CCreject },
119 { SC_RENUMBER, 1, CCrenumber },
120 { SC_RELOAD, 2, CCreload },
121 { SC_RESERVE, 1, CCreserve },
122 { SC_RMGROUP, 1, CCrmgroup },
123 { SC_SEND, 2, CCsend },
124 { SC_SHUTDOWN, 1, CCshutdown },
125 { SC_SIGNAL, 2, CCsignal },
126 { SC_THROTTLE, 1, CCthrottle },
127 { SC_TRACE, 2, CCtrace },
128 { SC_XABORT, 1, CCxabort },
129 { SC_XEXEC, 1, CCxexec }
130 };
131
132 STATIC SIGHANDLER CCresetup();
133
134
135 void
136 CCcopyargv(av)
137 char *av[];
138 {
139 register char **v;
140 register int i;
141
142 /* Get the vector size. */
143 for (i = 0; av[i]; i++)
144 continue;
145
146 /* Get the vector, copy each element. */
147 for (v = CCargv = NEW(char*, i + 1); *av; av++)
148 *v++ = COPY(*av);
149 *v = NULL;
150 }
151
152
153 /*
154 ** Return a string representing our operating mode.
155 */
156 STATIC STRING
157 CCcurrmode()
158 {
159 static char buff[32];
160
161 /* Server's mode. */
162 switch (Mode) {
163 default:
164 (void)sprintf(buff, "Unknown %d", Mode);
165 return buff;
166 case OMrunning:
167 return "running";
168 case OMpaused:
169 return "paused";
170 case OMthrottled:
171 return "throttled";
172 }
173 }
174
175 /*
176 ** Notify systemd of the current operating modes.
177 */
178 STATIC void
179 CCsdnotify()
180 {
181 char *buff, *p;
182
183 /* bug: statically allocated buffer, but CCmode does this too */
184 p = buff = NEW(char, BUFSIZ);
185 p += strlen(strcpy(buff, "STATUS=Server "));
186
187 /* Server's mode. */
188 switch (Mode) {
189 default:
190 (void)sprintf(p, "Unknown %d", Mode);
191 p += strlen(p);
192 break;
193 case OMrunning:
194 p += strlen(strcpy(p, "running"));
195 break;
196 case OMpaused:
197 p += strlen(strcpy(p, "paused "));
198 p += strlen(strcpy(p, ModeReason));
199 break;
200 case OMthrottled:
201 p += strlen(strcpy(p, "throttled "));
202 p += strlen(strcpy(p, ModeReason));
203 break;
204 }
205
206 p += strlen(strcpy(p, ". "));
207 if (RejectReason) {
208 p += strlen(strcpy(p, "Rejecting "));
209 p += strlen(strcpy(p, RejectReason));
210 }
211 else
212 p += strlen(strcpy(p, "Allowing remote connections"));
213
214 /* Newsreaders. */
215 p += strlen(strcpy(p, ". "));
216 p += strlen(strcpy(p, "Readers "));
217 if (NNRPFollows)
218 p += strlen(strcpy(p, "follow "));
219 else
220 p += strlen(strcpy(p, "separate "));
221 if (NNRPReason == NULL)
222 p += strlen(strcpy(p, "enabled"));
223 else {
224 (void)sprintf(p, "disabled %s", NNRPReason);
225 p += strlen(p);
226 }
227 *p++ = '.';
228 *p++ = '\0';
229
230 sd_notify(0, buff);
231 DISPOSE(buff);
232 }
233
234 /*
235 ** Add <> around Message-ID if needed.
236 */
237 STATIC STRING
238 CCgetid(p, store)
239 char *p;
240 char **store;
241 {
242 static char NULLMESGID[] = "1 Empty Message-ID";
243 static BUFFER Save;
244 int i;
245
246 if (*p == '\0')
247 return NULLMESGID;
248 if (*p == '<') {
249 if (p[1] == '\0' || p[1] == '>')
250 return NULLMESGID;
251 *store = p;
252 return NULL;
253 }
254
255 /* Make sure the Message-ID buffer has room. */
256 i = 1 + strlen(p) + 1 + 1;
257 if (Save.Data == NULL) {
258 Save.Size = i;
259 Save.Data = NEW(char, Save.Size);
260 }
261 else if (Save.Size < i) {
262 Save.Size = i;
263 RENEW(Save.Data, char, Save.Size);
264 }
265 *store = Save.Data;
266 (void)sprintf(*store, "<%s>", p);
267 return NULL;
268 }
269
270
271 /*
272 ** Abort and dump core.
273 */
274 STATIC STRING
275 CCxabort(av)
276 char *av[];
277 {
278 syslog(L_FATAL, "%s abort %s", LogName, av[0]);
279 abort();
280 syslog(L_FATAL, "%s cant abort %m", LogName);
281 CleanupAndExit(1, av[0]);
282 /* NOTREACHED */
283 }
284
285
286 /*
287 ** Do the work needed to add a history entry.
288 */
289 STATIC STRING
290 CCaddhist(av)
291 char *av[];
292 {
293 static char DIGITS[] = "0123456789";
294 ARTDATA Data;
295 STRING p;
296 BOOL ok;
297
298 /* Check the fields. */
299 if ((p = CCgetid(av[0], &Data.MessageID)) != NULL)
300 return p;
301
302 /* If throttled, don't try to use the history database. */
303 if (Mode == OMthrottled)
304 return "1 Server throttled";
305
306 /* If paused, briefly open the history database. */
307 if (Mode != OMrunning)
308 HISsetup();
309
310 if (HIShavearticle(Data.MessageID)) {
311 if (Mode != OMrunning) HISclose();
312 return "1 Duplicate";
313 }
314 if (strspn(av[1], DIGITS) != strlen(av[1]))
315 return "1 Bad arrival date";
316 Data.Arrived = atol(av[1]);
317 if (strspn(av[2], DIGITS) != strlen(av[2]))
318 return "1 Bad expiration date";
319 Data.Expires = atol(av[2]);
320 if (strspn(av[3], DIGITS) != strlen(av[3]))
321 return "1 Bad posted date";
322 Data.Posted = atol(av[3]);
323
324 ok = HISwrite(&Data, av[4]);
325 if (Mode != OMrunning)
326 HISclose();
327
328 return ok ? NULL : "1 Write failed";
329 }
330
331
332 /*
333 ** Do the work to allow foreign connectiosn.
334 */
335 STATIC STRING
336 CCallow(av)
337 char *av[];
338 {
339 char *p;
340
341 if (RejectReason == NULL)
342 return "1 Already allowed";
343 p = av[0];
344 if (*p && !EQ(p, RejectReason))
345 return "1 Wrong reason";
346 DISPOSE(RejectReason);
347 RejectReason = NULL;
348 CCsdnotify();
349 return NULL;
350 }
351
352
353 /*
354 ** Do the work needed to start feeding a (new) site.
355 */
356 STATIC STRING
357 CCbegin(av)
358 char *av[];
359 {
360 SITE *sp;
361 register int i;
362 register int length;
363 register STRING p;
364 register char **strings;
365 register NEWSGROUP *ngp;
366 STRING error;
367 char *subbed;
368 char *poison;
369
370 /* If site already exists, drop it. */
371 if (SITEfind(av[0]) != NULL && (p = CCdrop(av)) != NULL)
372 return p;
373
374 /* Find the named site. */
375 length = strlen(av[0]);
376 for (strings = SITEreadfile(TRUE), i = 0; (p = strings[i]) != NULL; i++)
377 if ((p[length] == NF_FIELD_SEP || p[length] == NF_SUBFIELD_SEP)
378 && caseEQn(p, av[0], length)) {
379 p = COPY(p);
380 break;
381 }
382 if (p == NULL)
383 return CCnosite;
384
385 if (p[0] == 'M' && p[1] == 'E' && p[2] == NF_FIELD_SEP)
386 sp = &ME;
387 else {
388 /* Get space for the new site entry, and space for it in all
389 * the groups. */
390 for (i = nSites, sp = Sites; --i >= 0; sp++)
391 if (sp->Name == NULL)
392 break;
393 if (i < 0) {
394 nSites++;
395 RENEW(Sites, SITE, nSites);
396 sp = &Sites[nSites - 1];
397 sp->Next = sp->Prev = NOSITE;
398 for (i = nGroups, ngp = Groups; --i >= 0; ngp++) {
399 RENEW(ngp->Sites, int, nSites);
400 RENEW(ngp->Poison, int, nSites);
401 }
402 }
403 }
404
405 /* Parse. */
406 subbed = NEW(char, nGroups);
407 poison = NEW(char, nGroups);
408 error = SITEparseone(p, sp, subbed, poison);
409 DISPOSE(subbed);
410 DISPOSE(poison);
411 if (error != NULL) {
412 DISPOSE(p);
413 syslog(L_ERROR, "%s bad_newsfeeds %s", av[0], error);
414 return "1 Parse error";
415 }
416
417 if (sp != &ME && (!SITEsetup(sp) || !SITEfunnelpatch()))
418 return "1 Startup error";
419 SITEforward(sp, "begin");
420 return NULL;
421 }
422
423
424 /*
425 ** Common code to change a group's flags.
426 */
427 STATIC STRING
428 CCdochange(ngp, Rest)
429 register NEWSGROUP *ngp;
430 char *Rest;
431 {
432 int length;
433 char *p;
434
435 if (ngp->Rest[0] == Rest[0]) {
436 length = strlen(Rest);
437 if (ngp->Rest[length] == '\n' && EQn(ngp->Rest, Rest, length))
438 return "0 Group status unchanged";
439 }
440 if (Mode != OMrunning)
441 return CCnotrunning;
442
443 p = COPY(ngp->Name);
444 if (!ICDchangegroup(ngp, Rest)) {
445 syslog(L_NOTICE, "%s cant change_group %s to %s", LogName, p, Rest);
446 DISPOSE(p);
447 return "1 Change failed (probably can't write active?)";
448 }
449 syslog(L_NOTICE, "%s change_group %s to %s", LogName, p, Rest);
450 DISPOSE(p);
451 return NULL;
452 }
453
454
455 /*
456 ** Change the mode of a newsgroup.
457 */
458 STATIC STRING
459 CCchgroup(av)
460 char *av[];
461 {
462 NEWSGROUP *ngp;
463 char *Rest;
464
465 if ((ngp = NGfind(av[0])) == NULL)
466 return CCnogroup;
467 Rest = av[1];
468 if (Rest[0] != NF_FLAG_ALIAS) {
469 Rest[1] = '\0';
470 if (CTYPE(isupper, Rest[0]))
471 Rest[0] = tolower(Rest[0]);
472 }
473 return CCdochange(ngp, Rest);
474 }
475
476
477 /*
478 ** Cancel a message.
479 */
480 STRING
481 CCcancel(av)
482 char *av[];
483 {
484 ARTDATA Data;
485 STRING p;
486
487 Data.Posted = Data.Arrived = Now.time;
488 Data.Expires = 0;
489 Data.Feedsite = "?";
490 if ((p = CCgetid(av[0], &Data.MessageID)) != NULL)
491 return p;
492 if (Mode == OMrunning)
493 ARTcancel(&Data, Data.MessageID, TRUE);
494 else {
495 /* Possible race condition, but documented in ctlinnd manpage. */
496 HISsetup();
497 ARTcancel(&Data, Data.MessageID, TRUE);
498 HISclose();
499 }
500 #if defined(DO_LOG_CANCEL_COMMANDS)
501 syslog(L_NOTICE, "%s cancelled %s", LogName, Data.MessageID);
502 #endif /* defined(DO_LOG_CANCEL_COMMANDS) */
503 return NULL;
504 }
505
506
507 /*
508 ** Syntax-check the newsfeeds file.
509 */
510 /* ARGSUSED */
511 STRING
512 CCcheckfile(av)
513 char *av[];
514 {
515 register char **strings;
516 register char *p;
517 register int i;
518 register int errors;
519 STRING error;
520 SITE fake;
521
522 /* Parse all site entries. */
523 strings = SITEreadfile(FALSE);
524 fake.Buffer.Size = 0;
525 fake.Buffer.Data = NULL;
526 for (errors = 0, i = 0; (p = strings[i]) != NULL; i++) {
527 if ((error = SITEparseone(p, &fake, (char *)NULL, (char *)NULL)) != NULL) {
528 syslog(L_ERROR, "%s bad_newsfeeds %s", MaxLength(p, p), error);
529 errors++;
530 }
531 SITEfree(&fake);
532 }
533 DISPOSE(strings);
534
535 if (errors == 0)
536 return NULL;
537
538 if (CCreply.Data == NULL) {
539 /* If we got the "-s" flag, then CCsetup hasn't been called yet. */
540 CCreply.Size = SMBUF;
541 CCreply.Data = NEW(char, CCreply.Size);
542 }
543 else if (CCreply.Size < SMBUF) {
544 CCreply.Size = SMBUF;
545 RENEW(CCreply.Data, char, CCreply.Size);
546 }
547
548 (void)sprintf(CCreply.Data, "1 Found %d errors -- see syslog", errors);
549 return CCreply.Data;
550 }
551
552
553 /*
554 ** Drop a site.
555 */
556 STATIC STRING
557 CCdrop(av)
558 char *av[];
559 {
560 SITE *sp;
561 register NEWSGROUP *ngp;
562 register int *ip;
563 register int idx;
564 register int i;
565 register int j;
566
567 if ((sp = SITEfind(av[0])) == NULL)
568 return CCnosite;
569
570 SITEdrop(sp);
571
572 /* Loop over all groups, and if the site is in a group, clobber it. */
573 for (idx = sp - Sites, i = nGroups, ngp = Groups; --i >= 0; ngp++) {
574 for (j = ngp->nSites, ip = ngp->Sites; --j >= 0; ip++)
575 if (*ip == idx)
576 *ip = NOSITE;
577 for (j = ngp->nPoison, ip = ngp->Poison; --j >= 0; ip++)
578 if (*ip == idx)
579 *ip = NOSITE;
580 }
581
582 return NULL;
583 }
584
585 /*
586 ** Return info on the feeds for one, or all, sites
587 */
588 STATIC STRING
589 CCfeedinfo(av)
590 char *av[];
591 {
592 register SITE *sp;
593 register char *p;
594 register int i;
595
596 BUFFset(&CCreply, "0 ", 2);
597 p = av[0];
598 if (*p != '\0') {
599 if ((sp = SITEfind(p)) == NULL)
600 return "1 No such site";
601
602 SITEinfo(&CCreply, sp, TRUE);
603 while ((sp = SITEfindnext(p, sp)) != NULL)
604 SITEinfo(&CCreply, sp, TRUE);
605 }
606 else
607 for (i = nSites, sp = Sites; --i >= 0; sp++)
608 if (sp->Name)
609 SITEinfo(&CCreply, sp, FALSE);
610
611 BUFFappend(&CCreply, "", 1);
612 return CCreply.Data;
613 }
614
615
616 #if defined(DO_TCL)
617 STATIC STRING
618 CCfilter(av)
619 char *av[];
620 {
621 char *p;
622
623 switch (av[0][0]) {
624 default:
625 return "1 Bad flag";
626 case 'y':
627 if (TCLFilterActive)
628 return "1 tcl filter already enabled";
629 TCLfilter(TRUE);
630 break;
631 case 'n':
632 if (!TCLFilterActive)
633 return "1 tcl filter already disabled";
634 TCLfilter(FALSE);
635 break;
636 }
637 return NULL;
638 }
639 #endif /* defined(DO_TCL) */
640
641
642 #if defined(DO_PERL)
643
644 extern CV *perl_filter_cv ;
645
646 STATIC STRING
647 CCperl(av)
648 char *av[];
649 {
650 char *p;
651 extern int PerlFilterActive;
652
653 switch (av[0][0]) {
654 default:
655 return "1 Bad flag";
656 case 'y':
657 if (PerlFilterActive)
658 return "1 Perl filter already enabled";
659 else if (perl_filter_cv == NULL)
660 return "1 Perl filter not defined" ;
661 PerlFilter(TRUE);
662 break;
663 case 'n':
664 if (!PerlFilterActive)
665 return "1 Perl filter already disabled";
666 PerlFilter(FALSE);
667 break;
668 }
669 return NULL;
670 }
671 #endif /* defined(DO_PERL) */
672
673
674 /*
675 ** Flush all sites or one site.
676 */
677 STATIC STRING
678 CCflush(av)
679 char *av[];
680 {
681 register SITE *sp;
682 register int i;
683 register char *p;
684
685 p = av[0];
686 if (*p == '\0') {
687 ICDwrite();
688 for (sp = Sites, i = nSites; --i >= 0; sp++)
689 SITEflush(sp, TRUE);
690 syslog(L_NOTICE, "%s flush_all", LogName);
691 }
692 else {
693 if ((sp = SITEfind(p)) == NULL)
694 return CCnosite;
695 syslog(L_NOTICE, "%s flush", sp->Name);
696 SITEflush(sp, TRUE);
697 }
698 return NULL;
699 }
700
701
702 /*
703 ** Flush the log files.
704 */
705 /* ARGSUSED0 */
706 STATIC STRING
707 CCflushlogs(av)
708 char *av[];
709 {
710 if (Debug)
711 return "1 In debug mode";
712
713 ICDwrite();
714 syslog(L_NOTICE, "%s flushlogs %s", LogName, CCcurrmode());
715 ReopenLog(Log);
716 ReopenLog(Errlog);
717 return NULL;
718 }
719
720
721 /*
722 ** Leave paused or throttled mode.
723 */
724 STATIC STRING
725 CCgo(av)
726 char *av[];
727 {
728 static char YES[] = "y";
729 char *p;
730
731 p = av[0];
732 if (Reservation && EQ(p, Reservation)) {
733 DISPOSE(Reservation);
734 Reservation = NULL;
735 }
736 if (RejectReason && EQ(p, RejectReason)) {
737 DISPOSE(RejectReason);
738 RejectReason = NULL;
739 }
740
741 if (Mode == OMrunning)
742 return "1 Already running";
743 if (*p && !EQ(p, ModeReason))
744 return "1 Wrong reason";
745
746 #if defined(DO_PERL)
747 PerlMode(Mode, OMrunning, p);
748 #endif /* defined(DO_PERL) */
749
750 DISPOSE(ModeReason);
751 ModeReason = NULL;
752 Mode = OMrunning;
753
754 if (NNRPReason && NNRPFollows) {
755 av[0] = YES;
756 av[1] = p;
757 (void)CCreaders(av);
758 }
759 if (ErrorCount < 0)
760 ErrorCount = IO_ERROR_COUNT;
761 HISsetup();
762 syslog(L_NOTICE, "%s running", LogName);
763 CCsdnotify();
764 if (ICDneedsetup)
765 ICDsetup(TRUE);
766 SCHANwakeup((POINTER)&Mode);
767 return NULL;
768 }
769
770
771 /*
772 ** Hangup a channel.
773 */
774 STATIC STRING
775 CChangup(av)
776 char *av[];
777 {
778 register CHANNEL *cp;
779 register int fd;
780 register char *p;
781 int i;
782
783 /* Parse the argument, a channel number. */
784 for (p = av[0], fd = 0; *p; p++) {
785 if (!CTYPE(isdigit, *p))
786 return "1 Bad channel number";
787 fd = fd * 10 + *p - '0';
788 }
789
790 /* Loop over all channels for the desired one. */
791 for (i = 0; (cp = CHANiter(&i, CTany)) != NULL; )
792 if (cp->fd == fd) {
793 p = CHANname(cp);
794 switch (cp->Type) {
795 default:
796 (void)sprintf(CCreply.Data, "1 Can't close %s", p);
797 return CCreply.Data;
798 case CTexploder:
799 case CTprocess:
800 case CTfile:
801 case CTnntp:
802 case CTreject:
803 syslog(L_NOTICE, "%s hangup", p);
804 CHANclose(cp, p);
805 return NULL;
806 }
807 }
808 return "1 Not active";
809 }
810
811 extern unsigned long HIScachehits;
812 extern unsigned long HIScachelookups;
813 extern unsigned long NCprecomhits;
814 extern unsigned long NCprecomlookups;
815
816 /*
817 ** Return our operating mode.
818 */
819 /* ARGSUSED */
820 STATIC STRING
821 CCmode(av)
822 char *av[];
823 {
824 #if defined(DO_PERL)
825 dSP;
826 #endif
827 register char *p;
828 register int i;
829 int h;
830 char buff[BUFSIZ];
831 #if defined(DO_PERL)
832 extern int PerlFilterActive;
833 #endif /* defined(DO_PERL) */
834
835 /* nb: We assume here that BUFSIZ is >= 512, and that none of
836 * ModeReason RejectReason Reservation or NNRPReason is longer than
837 * MAX_REASON_LEN bytes (or actually, the average of their lengths is
838 * <= MAX_REASON_LEN). If this is not true, the sprintf's/strcpy's
839 * below are likely to overflow buff with somewhat nasty
840 * consequences...
841 */
842
843 p = buff;
844 p += strlen(strcpy(buff, "0 Server "));
845
846 /* Server's mode. */
847 switch (Mode) {
848 default:
849 (void)sprintf(p, "Unknown %d", Mode);
850 p += strlen(p);
851 break;
852 case OMrunning:
853 p += strlen(strcpy(p, "running"));
854 break;
855 case OMpaused:
856 p += strlen(strcpy(p, "paused "));
857 p += strlen(strcpy(p, ModeReason));
858 break;
859 case OMthrottled:
860 p += strlen(strcpy(p, "throttled "));
861 p += strlen(strcpy(p, ModeReason));
862 break;
863 }
864 *p++ = '\n';
865 if (RejectReason) {
866 p += strlen(strcpy(p, "Rejecting "));
867 p += strlen(strcpy(p, RejectReason));
868 }
869 else
870 p += strlen(strcpy(p, "Allowing remote connections"));
871
872 /* Server parameters. */
873 for (i = 0, h = 0; CHANiter(&h, CTnntp) != NULL; )
874 i++;
875 *p++ = '\n';
876 (void)sprintf(p, "Parameters c %ld i %d (%d) l %ld o %d t %ld H %d T %d X %d %s %s",
877 (long)Cutoff / (24L * 60L * 60L),
878 MaxIncoming, i,
879 LargestArticle, MaxOutgoing, (long)TimeOut.tv_sec,
880 RemoteLimit, RemoteTotal, (int) RemoteTimer,
881 AmSlave ? "slave" : "normal",
882 AnyIncoming ? "any" : "specified");
883 p += strlen(p);
884
885 /* Reservation. */
886 *p++ = '\n';
887 if (Reservation) {
888 (void)sprintf(p, "Reserved %s", Reservation);
889 p += strlen(p);
890 }
891 else
892 p += strlen(strcpy(p, "Not reserved"));
893
894 /* Newsreaders. */
895 *p++ = '\n';
896 p += strlen(strcpy(p, "Readers "));
897 if (NNRPFollows)
898 p += strlen(strcpy(p, "follow "));
899 else
900 p += strlen(strcpy(p, "separate "));
901 if (NNRPReason == NULL)
902 p += strlen(strcpy(p, "enabled"));
903 else {
904 (void)sprintf(p, "disabled %s", NNRPReason);
905 p += strlen(p);
906 }
907
908 #if defined(DO_TCL)
909 *p++ = '\n';
910 p += strlen(strcpy(p, "Tcl filtering "));
911 if (TCLFilterActive)
912 p += strlen(strcpy(p, "enabled"));
913 else
914 p += strlen(strcpy(p, "disabled"));
915 #endif /* defined(DO_TCL) */
916 #if defined(DO_PERL)
917 *p++ = '\n';
918 p += strlen(strcpy(p, "Perl filtering "));
919 if (PerlFilterActive)
920 p += strlen(strcpy(p, "enabled"));
921 else
922 p += strlen(strcpy(p, "disabled"));
923
924 /* perl filter status */
925
926 if (perl_get_cv("filter_stats", FALSE) != NULL) {
927 char *argv[] = { NULL };
928
929 *p++ = '\n';
930 p += strlen(strcpy(p, "Perl filter stats: "));
931
932 ENTER ;
933 SAVETMPS;
934
935 perl_call_argv("filter_stats", G_EVAL|G_NOARGS, argv);
936
937 SPAGAIN;
938
939 p += strlen(strcpy(p, POPp));
940
941 PUTBACK;
942 FREETMPS;
943 LEAVE;
944 }
945
946 #endif /* defined(DO_PERL) */
947
948 *p++ = '\n';
949 sprintf(p, "History cache: %lu lookups, %lu hits", HIScachelookups, HIScachehits);
950 p += strlen(p);
951 *p++ = '\n';
952 sprintf(p, "Precommit cache: %lu lookups, %lu hits", NCprecomlookups, NCprecomhits);
953 p += strlen(p);
954
955 i = strlen(buff);
956 if (CCreply.Size <= i) {
957 CCreply.Size = i;
958 RENEW(CCreply.Data, char, CCreply.Size + 1);
959 }
960 (void)strcpy(CCreply.Data, buff);
961 return CCreply.Data;
962 }
963
964
965 /*
966 ** Log our operating mode (via syslog).
967 */
968 /* ARGSUSED */
969 STATIC STRING
970 CClogmode(av)
971 char *av[];
972 {
973 syslog(L_NOTICE, "%s servermode %s", LogName, CCcurrmode());
974 return NULL;
975 }
976
977
978 /*
979 ** Name the channels. ("Name the bats -- simple names.")
980 */
981 STATIC STRING
982 CCname(av)
983 char *av[];
984 {
985 static char NL[] = "\n";
986 static char NIL[] = "\0";
987 register CHANNEL *cp;
988 register char *p;
989 register int count;
990 int i;
991
992 p = av[0];
993 if (*p != '\0') {
994 if ((cp = CHANfromdescriptor(atoi(p))) == NULL)
995 return COPY(CCnochannel);
996 (void)sprintf(CCreply.Data, "0 %s", CHANname(cp));
997 return CCreply.Data;
998 }
999 BUFFset(&CCreply, "0 ", 2);
1000 for (count = 0, i = 0; (cp = CHANiter(&i, CTany)) != NULL; ) {
1001 if (cp->Type == CTfree)
1002 continue;
1003 if (++count > 1)
1004 BUFFappend(&CCreply, NL, 1);
1005 p = CHANname(cp);
1006 BUFFappend(&CCreply, p, strlen(p));
1007 }
1008 BUFFappend(&CCreply, NIL, 1);
1009 return CCreply.Data;
1010 }
1011
1012
1013 /*
1014 ** Create a newsgroup.
1015 */
1016 STATIC STRING
1017 CCnewgroup(av)
1018 char *av[];
1019 {
1020 static char TIMES[] = _PATH_ACTIVETIMES;
1021 static char WHEN[] = "updating active.times";
1022 register int fd;
1023 register char *p;
1024 NEWSGROUP *ngp;
1025 char *Name;
1026 char *Rest;
1027 STRING who;
1028 char *buff;
1029 int oerrno;
1030
1031 Name = av[0];
1032 if (Name[0] == '.' || strspn(Name, "0123456789") == strlen(Name))
1033 return "1 Illegal newsgroup name";
1034 for (p = Name; *p; p++)
1035 if (*p == '.') {
1036 if (p[1] == '.' || p[1] == '\0')
1037 return "1 Double or trailing period in newsgroup name";
1038 }
1039 else if (ISWHITE(*p) || *p == ':' || *p == '!' || *p == '/')
1040 return "1 Illegal character in newsgroup name";
1041
1042 Rest = av[1];
1043 if (Rest[0] != NF_FLAG_ALIAS) {
1044 Rest[1] = '\0';
1045 if (CTYPE(isupper, Rest[0]))
1046 Rest[0] = tolower(Rest[0]);
1047 }
1048 if (strlen(Name) + strlen(Rest) > (SIZE_T)(SMBUF - 24))
1049 return "1 Name too long";
1050
1051 if ((ngp = NGfind(Name)) != NULL)
1052 return CCdochange(ngp, Rest);
1053
1054 /* Update the log of groups created. Don't use stdio because SunOS
1055 * 4.1 has broken libc which can't handle fd's greater than 127. */
1056 if ((fd = open(TIMES, O_WRONLY | O_APPEND | O_CREAT, 0664)) < 0) {
1057 oerrno = errno;
1058 syslog(L_ERROR, "%s cant fopen %s %m", LogName, TIMES);
1059 IOError(WHEN, oerrno);
1060 }
1061 else {
1062 who = av[2];
1063 if (*who == '\0')
1064 who = NEWSMASTER;
1065
1066 /* %s + ' ' + %ld + ' ' + %s + '\n' + terminator */
1067 buff = NEW(char, strlen(Name) + 1 + 20 + 1 + strlen(who) + 1 + 1);
1068
1069 (void)sprintf(buff, "%s %ld %s\n", Name, Now.time, who);
1070 if (xwrite(fd, buff, strlen(buff)) < 0) {
1071 oerrno = errno;
1072 syslog(L_ERROR, "%s cant write %s %m", LogName, TIMES);
1073 IOError(WHEN, oerrno);
1074 }
1075 if (close(fd) < 0) {
1076 oerrno = errno;
1077 syslog(L_ERROR, "%s cant close %s %m", LogName, TIMES);
1078 IOError(WHEN, oerrno);
1079 }
1080
1081 DISPOSE(buff);
1082
1083 if (AmRoot)
1084 xchown(TIMES);
1085 }
1086
1087 /* Update the in-core data. */
1088 if (!ICDnewgroup(Name, Rest))
1089 return "1 Failed";
1090 syslog(L_NOTICE, "%s newgroup %s as %s", LogName, Name, Rest);
1091
1092 if (*Rest != NF_FLAG_ALIAS) {
1093 /* Create the spool directory. */
1094 for (p = Name; *p; p++)
1095 if (*p == '.')
1096 *p = '/';
1097 if (!MakeSpoolDirectory(Name))
1098 syslog(L_NOTICE, "%s cant mkdir %s %m", LogName, Name);
1099 }
1100 return NULL;
1101 }
1102
1103
1104 /*
1105 ** Parse and set a boolean flag.
1106 */
1107 STATIC BOOL
1108 CCparsebool(name, bp, value)
1109 char name;
1110 BOOL *bp;
1111 char value;
1112 {
1113 switch (value) {
1114 default:
1115 return FALSE;
1116 case 'y':
1117 *bp = FALSE;
1118 break;
1119 case 'n':
1120 *bp = TRUE;
1121 break;
1122 }
1123 syslog(L_NOTICE, "%s changed -%c %c", LogName, name, value);
1124 return TRUE;
1125 }
1126
1127
1128 /*
1129 ** Change a running parameter.
1130 */
1131 STATIC STRING
1132 CCparam(av)
1133 char *av[];
1134 {
1135 static char BADVAL[] = "1 Bad value";
1136 char *p;
1137
1138 p = av[1];
1139 switch (av[0][0]) {
1140 default:
1141 return "1 Unknown parameter";
1142 case 'a':
1143 if (!CCparsebool('a', &AnyIncoming, *p))
1144 return BADVAL;
1145 break;
1146 case 'c':
1147 Cutoff = atoi(p) * 24 * 60 * 60;
1148 syslog(L_NOTICE, "%s changed -c %ld", LogName, Cutoff);
1149 break;
1150 case 'i':
1151 MaxIncoming = atoi(p);
1152 syslog(L_NOTICE, "%s changed -i %d", LogName, MaxIncoming);
1153 break;
1154 case 'l':
1155 LargestArticle = atol(p);
1156 syslog(L_NOTICE, "%s changed -l %ld", LogName, LargestArticle);
1157 break;
1158 case 'n':
1159 if (!CCparsebool('n', &NNRPFollows, *p))
1160 return BADVAL;
1161 CCsdnotify();
1162 break;
1163 case 'o':
1164 MaxOutgoing = atoi(p);
1165 syslog(L_NOTICE, "%s changed -o %d", LogName, MaxOutgoing);
1166 break;
1167 case 't':
1168 TimeOut.tv_sec = atol(p);
1169 syslog(L_NOTICE, "%s changed -t %ld", LogName, (long)TimeOut.tv_sec);
1170 break;
1171 case 'H':
1172 RemoteLimit = atoi(p);
1173 syslog(L_NOTICE, "%s changed -H %d", LogName, RemoteLimit);
1174 break;
1175 case 'T':
1176 RemoteTotal = atoi(p);
1177 if (RemoteTotal > REMOTETABLESIZE)
1178 RemoteTotal = REMOTETABLESIZE;
1179 syslog(L_NOTICE, "%s changed -T %d", LogName, RemoteTotal);
1180 break;
1181 case 'X':
1182 RemoteTimer = (time_t) atoi(p);
1183 syslog(L_NOTICE, "%s changed -X %d", LogName, (int) RemoteTimer);
1184 break;
1185 }
1186 return NULL;
1187 }
1188
1189
1190 /*
1191 ** Common code to implement a pause or throttle.
1192 */
1193 STRING
1194 CCblock(NewMode, reason)
1195 OPERATINGMODE NewMode;
1196 char *reason;
1197 {
1198 static char NO[] = "n";
1199 STRING av[2];
1200
1201 if (*reason == '\0')
1202 return CCnoreason;
1203
1204 if (strlen(reason) > MAX_REASON_LEN) /* MAX_REASON_LEN is as big as is safe */
1205 return CCbigreason;
1206
1207 if (Reservation) {
1208 if (!EQ(reason, Reservation)) {
1209 (void)sprintf(CCreply.Data, "1 Reserved \"%s\"", Reservation);
1210 return CCreply.Data;
1211 }
1212 DISPOSE(Reservation);
1213 Reservation = NULL;
1214 }
1215
1216 #if defined(DO_PERL)
1217 PerlMode(Mode, NewMode, reason);
1218 #endif /* defined(DO_PERL) */
1219
1220 ICDwrite();
1221 HISclose();
1222 Mode = NewMode;
1223 if (ModeReason)
1224 DISPOSE(ModeReason);
1225 ModeReason = COPY(reason);
1226 if (NNRPReason == NULL && NNRPFollows) {
1227 av[0] = NO;
1228 av[1] = ModeReason;
1229 (void)CCreaders(av);
1230 }
1231 syslog(L_NOTICE, "%s %s %s",
1232 LogName, NewMode == OMpaused ? "paused" : "throttled", reason);
1233 CCsdnotify();
1234 return NULL;
1235 }
1236
1237
1238 /*
1239 ** Enter paused mode.
1240 */
1241 STATIC STRING
1242 CCpause(av)
1243 char *av[];
1244 {
1245 switch (Mode) {
1246 case OMrunning:
1247 return CCblock(OMpaused, av[0]);
1248 case OMpaused:
1249 return "1 Already paused";
1250 case OMthrottled:
1251 return "1 Already throttled";
1252 }
1253 return "1 Unknown mode";
1254 }
1255
1256
1257 /*
1258 ** Allow or disallow newsreaders.
1259 */
1260 STATIC STRING
1261 CCreaders(av)
1262 char *av[];
1263 {
1264 char *p;
1265
1266 switch (av[0][0]) {
1267 default:
1268 return "1 Bad flag";
1269 case 'y':
1270 if (NNRPReason == NULL)
1271 return "1 Already allowing readers";
1272 p = av[1];
1273 if (*p && !EQ(p, NNRPReason))
1274 return "1 Wrong reason";
1275 DISPOSE(NNRPReason);
1276 NNRPReason = NULL;
1277 break;
1278 case 'n':
1279 if (NNRPReason)
1280 return "1 Already not allowing readers";
1281 p = av[1];
1282 if (*p == '\0')
1283 return CCnoreason;
1284 if (strlen(p) > MAX_REASON_LEN) /* MAX_REASON_LEN is as big as is safe */
1285 return CCbigreason;
1286 NNRPReason = COPY(p);
1287 break;
1288 }
1289 CCsdnotify();
1290 return NULL;
1291 }
1292
1293
1294 /*
1295 ** Re-exec ourselves.
1296 */
1297 STATIC STRING
1298 CCxexec(av)
1299 char *av[];
1300 {
1301 static char INND[] = _PATH_INND;
1302 static char INNDSTART[] = _PATH_INNDSTART;
1303 char *p;
1304
1305 if (CCargv == NULL)
1306 return "1 no argv!";
1307
1308 /* Get the pathname. */
1309 p = av[0];
1310 if (*p == '\0')
1311 CCargv[0] = AmRoot ? INND : INNDSTART;
1312 else if (EQ(p, "innd"))
1313 CCargv[0] = INND;
1314 else if (EQ(p, "inndstart"))
1315 CCargv[0] = INNDSTART;
1316 else
1317 return "1 Bad value";
1318
1319 JustCleanup();
1320 syslog(L_NOTICE, "%s execv %s", LogName, CCargv[0]);
1321 (void)execv(CCargv[0], CCargv);
1322 syslog(L_FATAL, "%s cant execv %s %m", LogName, CCargv[0]);
1323 _exit(1);
1324 /* NOTREACHED */
1325 }
1326
1327
1328 /*
1329 ** Refile an article.
1330 */
1331 STATIC STRING
1332 CCrefile(av)
1333 char *av[];
1334 {
1335 char *head;
1336
1337 /* xxx multiple groups? */
1338 if (NGfind(av[1]) == NULL)
1339 return CCnogroup;
1340
1341 head = ARTreadheader(av[0]);
1342 if (head == NULL)
1343 return "1 No such article";
1344
1345 return "1 Not yet implemented";
1346 }
1347
1348
1349 /*
1350 ** Reject remote readers.
1351 */
1352 STATIC STRING
1353 CCreject(av)
1354 char *av[];
1355 {
1356 if (RejectReason)
1357 return "1 Already rejecting";
1358 if (strlen(av[0]) > MAX_REASON_LEN) /* MAX_REASON_LEN is as big as is safe */
1359 return CCbigreason;
1360 RejectReason = COPY(av[0]);
1361 return NULL;
1362 }
1363
1364
1365 /*
1366 ** Re-read all in-core data.
1367 */
1368 STATIC STRING
1369 CCreload(av)
1370 char *av[];
1371 {
1372 static char BADSCHEMA[] = "1 Can't read schema";
1373 #if defined(DO_PERL)
1374 static char BADPERLRELOAD[] = "1 Failed to define filter_art" ;
1375 #endif /* defined(DO_PERL) */
1376 STRING p;
1377
1378 p = av[0];
1379 if (*p == '\0' || EQ(p, "all")) {
1380 SITEflushall(FALSE);
1381 HISclose();
1382 RCreadlist();
1383 HISsetup();
1384 ICDwrite();
1385 ICDsetup(TRUE);
1386 if (!ARTreadschema())
1387 return BADSCHEMA;
1388 #if defined(DO_TCL)
1389 TCLreadfilter();
1390 #endif /* defined(DO_TCL) */
1391 #if defined(DO_PERL)
1392 PERLreadfilter (_PATH_PERL_FILTER_INND,"filter_art") ;
1393 #endif /* defined(DO_PERL) */
1394 p = "all";
1395 }
1396 else if (EQ(p, "active") || EQ(p, "newsfeeds")) {
1397 SITEflushall(FALSE);
1398 ICDwrite();
1399 ICDsetup(TRUE);
1400 }
1401 else if (EQ(p, "history")) {
1402 HISclose();
1403 HISsetup();
1404 }
1405 else if (EQ(p, "hosts.nntp"))
1406 RCreadlist();
1407 else if (EQ(p, "overview.fmt")) {
1408 if (!ARTreadschema())
1409 return BADSCHEMA;
1410 }
1411 #if defined(DO_TCL)
1412 else if (EQ(p, "filter.tcl")) {
1413 TCLreadfilter();
1414 }
1415 #endif /* defined(DO_TCL) */
1416 #if defined(DO_PERL)
1417 else if (EQ(p, "filter.perl")) {
1418 if (!PERLreadfilter (_PATH_PERL_FILTER_INND,"filter_art"))
1419 return BADPERLRELOAD ;
1420 }
1421 #endif /* defined(DO_PERL) */
1422 else
1423 return "1 Unknown reload type";
1424
1425 syslog(L_NOTICE, "%s reload %s %s", LogName, p, av[1]);
1426 return NULL;
1427 }
1428
1429
1430 /*
1431 ** Renumber the active file.
1432 */
1433 STATIC STRING
1434 CCrenumber(av)
1435 char *av[];
1436 {
1437 static char CANTRENUMBER[] = "1 Failed (see syslog)";
1438 char *p;
1439 NEWSGROUP *ngp;
1440
1441 if (Mode != OMrunning)
1442 return CCnotrunning;
1443 if (ICDneedsetup)
1444 return "1 Must first reload newsfeeds";
1445 p = av[0];
1446 if (*p) {
1447 if ((ngp = NGfind(p)) == NULL)
1448 return CCnogroup;
1449 if (!NGrenumber(ngp))
1450 return CANTRENUMBER;
1451 }
1452 else if (!ICDrenumberactive())
1453 return CANTRENUMBER;
1454 return NULL;
1455 }
1456
1457
1458 /*
1459 ** Reserve a lock.
1460 */
1461 STATIC STRING
1462 CCreserve(av)
1463 char *av[];
1464 {
1465 char *p;
1466
1467 if (Mode != OMrunning)
1468 return CCnotrunning;
1469 p = av[0];
1470 if (*p) {
1471 /* Trying to make a reservation. */
1472 if (Reservation)
1473 return "1 Already reserved";
1474 if (strlen(p) > MAX_REASON_LEN) /* MAX_REASON_LEN is as big as is safe */
1475 return CCbigreason;
1476 Reservation = COPY(p);
1477 }
1478 else {
1479 /* Trying to remove a reservation. */
1480 if (Reservation == NULL)
1481 return "1 Not reserved";
1482 DISPOSE(Reservation);
1483 Reservation = NULL;
1484 }
1485 return NULL;
1486 }
1487
1488
1489 /*
1490 ** Remove a newsgroup.
1491 */
1492 STATIC STRING
1493 CCrmgroup(av)
1494 char *av[];
1495 {
1496 NEWSGROUP *ngp;
1497
1498 if ((ngp = NGfind(av[0])) == NULL)
1499 return CCnogroup;
1500
1501 /*
1502 * See FAQ Q 6.3: INN shreds the active file when doing multiple
1503 * rmgroups if the server is throttled. So disallow that for now.
1504 */
1505 if (Mode == OMthrottled)
1506 return "1 server throttled";
1507
1508 /* Update the in-core data. */
1509 if (!ICDrmgroup(ngp))
1510 return "1 Failed";
1511 syslog(L_NOTICE, "%s rmgroup %s", LogName, av[0]);
1512 return NULL;
1513 }
1514
1515
1516 /*
1517 ** Send a command line to an exploder.
1518 */
1519 STATIC STRING
1520 CCsend(av)
1521 char *av[];
1522 {
1523 SITE *sp;
1524
1525 if ((sp = SITEfind(av[0])) == NULL)
1526 return CCnosite;
1527 if (sp->Type != FTexploder)
1528 return CCwrongtype;
1529 SITEwrite(sp, av[1]);
1530 return NULL;
1531 }
1532
1533
1534 /*
1535 ** Shut down the system.
1536 */
1537 STATIC STRING
1538 CCshutdown(av)
1539 char *av[];
1540 {
1541 syslog(L_NOTICE, "%s shutdown %s", LogName, av[0]);
1542 CleanupAndExit(0, av[0]);
1543 /* NOTREACHED */
1544 }
1545
1546
1547 /*
1548 ** Send a signal to a site's feed.
1549 */
1550 STATIC STRING
1551 CCsignal(av)
1552 char *av[];
1553 {
1554 register SITE *sp;
1555 register char *p;
1556 int s;
1557 int oerrno;
1558
1559 /* Parse the signal. */
1560 p = av[0];
1561 if (*p == '-')
1562 p++;
1563 if (caseEQ(p, "HUP"))
1564 s = SIGHUP;
1565 else if (caseEQ(p, "INT"))
1566 s = SIGINT;
1567 else if (caseEQ(p, "TERM"))
1568 s = SIGTERM;
1569 else if ((s = atoi(p)) <= 0)
1570 return "1 Invalid signal";
1571
1572 /* Parse the site. */
1573 p = av[1];
1574 if ((sp = SITEfind(p)) == NULL)
1575 return CCnosite;
1576 if (sp->Type != FTchannel && sp->Type != FTexploder)
1577 return CCwrongtype;
1578 if (sp->Process < 0)
1579 return "1 Site has no process";
1580
1581 /* Do it. */
1582 if (kill(sp->pid, s) < 0) {
1583 oerrno = errno;
1584 syslog(L_ERROR, "%s cant kill %ld %d site %s, %m", LogName,
1585 (long) sp->pid, s, p);
1586 (void)sprintf(CCreply.Data, "1 Can't signal process %ld, %s",
1587 (long) sp->pid, strerror(oerrno));
1588 return CCreply.Data;
1589 }
1590
1591 return NULL;
1592 }
1593
1594
1595 /*
1596 ** Enter throttled mode.
1597 */
1598 STATIC STRING
1599 CCthrottle(av)
1600 char *av[];
1601 {
1602 char *p;
1603
1604 p = av[0];
1605 switch (Mode) {
1606 case OMpaused:
1607 if (*p && !EQ(p, ModeReason))
1608 return "1 Already paused";
1609 /* FALLTHROUGH */
1610 case OMrunning:
1611 return CCblock(OMthrottled, p);
1612 case OMthrottled:
1613 return "1 Already throttled";
1614 }
1615 return "1 unknown mode";
1616 }
1617
1618
1619 /*
1620 ** Add or remove tracing.
1621 */
1622 STATIC STRING
1623 CCtrace(av)
1624 char *av[];
1625 {
1626 char *p;
1627 BOOL Flag;
1628 STRING word;
1629 CHANNEL *cp;
1630
1631 /* Parse the flag. */
1632 p = av[1];
1633 switch (p[0]) {
1634 default: return "1 Bad trace flag";
1635 case 'y': case 'Y': Flag = TRUE; word = "on"; break;
1636 case 'n': case 'N': Flag = FALSE; word = "off"; break;
1637 }
1638
1639 /* Parse what's being traced. */
1640 p = av[0];
1641 switch (*p) {
1642 default:
1643 return "1 Bad trace item";
1644 case 'i': case 'I':
1645 Tracing = Flag;
1646 syslog(L_NOTICE, "%s trace innd %s", LogName, word);
1647 break;
1648 case 'n': case 'N':
1649 NNRPTracing = Flag;
1650 syslog(L_NOTICE, "%s trace nnrpd %s", LogName, word);
1651 break;
1652 case '0': case '1': case '2': case '3': case '4':
1653 case '5': case '6': case '7': case '8': case '9':
1654 if ((cp = CHANfromdescriptor(atoi(p))) == NULL)
1655 return CCnochannel;
1656 CHANtracing(cp, Flag);
1657 break;
1658 }
1659 return NULL;
1660 }
1661
1662
1663
1664 /*
1665 ** Split up the text into fields and stuff them in argv. Return the
1666 ** number of elements or -1 on error.
1667 */
1668 STATIC int
1669 CCargsplit(p, end, argv, size)
1670 register char *p;
1671 register char *end;
1672 register char **argv;
1673 register int size;
1674 {
1675 char **save;
1676
1677 for (save = argv, *argv++ = p, size--; p < end; p++)
1678 if (*p == SC_SEP) {
1679 if (--size <= 0)
1680 return -1;
1681 *p = '\0';
1682 *argv++ = p + 1;
1683 }
1684 *argv = NULL;
1685 return argv - save;
1686 }
1687
1688
1689 /*
1690 ** Read function. Read and process the message.
1691 */
1692 STATIC FUNCTYPE
1693 CCreader(cp)
1694 CHANNEL *cp;
1695 {
1696 static char TOOLONG[] = "0 Reply too long for server to send";
1697 register CCDISPATCH *dp;
1698 register STRING p;
1699 register char *q;
1700 ICC_MSGLENTYPE bufflen;
1701 ICC_PROTOCOLTYPE protocol ;
1702 #if defined(DO_HAVE_UNIX_DOMAIN)
1703 struct sockaddr_un client;
1704 #else
1705 int written;
1706 #endif /* defined(DO_HAVE_UNIX_DOMAIN) */
1707 int i;
1708 char buff[BIG_BUFFER + 2];
1709 char copy[BIG_BUFFER + 2];
1710 char *argv[SC_MAXFIELDS + 2];
1711 int argc;
1712 int len;
1713 char *tbuff ;
1714
1715 if (cp != CCchan) {
1716 syslog(L_ERROR, "%s internal CCreader wrong channel %p not %p",
1717 LogName, cp, CCchan);
1718 return;
1719 }
1720
1721 #if defined (DO_HAVE_UNIX_DOMAIN)
1722
1723 i = RECVorREAD(CCchan->fd, buff, BIG_BUFFER) ;
1724 if (i < 0) {
1725 syslog(L_ERROR, "%s cant recv CCreader %m", LogName);
1726 return;
1727 } else if (i == 0) {
1728 syslog(L_ERROR, "%s cant recv CCreader empty", LogName);
1729 return;
1730 } else if (i < HEADER_SIZE) {
1731 syslog(L_ERROR, "%s cant recv CCreader header-length %m", LogName);
1732 return;
1733 }
1734
1735 memcpy (&protocol,buff,sizeof (protocol)) ;
1736 memcpy (&bufflen,buff + sizeof (protocol),sizeof (bufflen)) ;
1737 bufflen = ntohs (bufflen) ;
1738
1739 if (i != bufflen) {
1740 syslog(L_ERROR, "%s cant recv CCreader short-read %m", LogName);
1741 return;
1742 }
1743
1744 i -= HEADER_SIZE ;
1745 memmove (buff,buff + HEADER_SIZE,i) ;
1746 buff[i] = '\0';
1747
1748 if (protocol != ICC_PROTOCOL_1) {
1749 syslog(L_ERROR, "%s CCreader protocol mismatch", LogName) ;
1750 return ;
1751 }
1752
1753 #else /* defined (DO_HAVE_UNIX_DOMAIN) */
1754
1755 i = RECVorREAD(CCchan->fd, buff, HEADER_SIZE) ;
1756 if (i < 0) {
1757 syslog(L_ERROR, "%s cant read CCreader header %m", LogName);
1758 return;
1759 } else if (i == 0) {
1760 syslog(L_ERROR, "%s cant read CCreader header empty", LogName);
1761 return;
1762 } else if (i != HEADER_SIZE) {
1763 syslog(L_ERROR, "%s cant read CCreader header-length %m", LogName);
1764 return;
1765 }
1766
1767 memcpy (&protocol,buff,sizeof (protocol)) ;
1768 memcpy (&bufflen,buff + sizeof (protocol),sizeof (bufflen)) ;
1769 bufflen = ntohs (bufflen) - HEADER_SIZE ;
1770
1771 i = RECVorREAD(CCchan->fd, buff, bufflen) ;
1772
1773 if (i < 0) {
1774 syslog(L_ERROR, "%s cant read CCreader buffer %m", LogName);
1775 return;
1776 } else if (i == 0) {
1777 syslog(L_ERROR, "%s cant read CCreader buffer empty", LogName);
1778 return;
1779 } else if (i != bufflen) {
1780 syslog(L_ERROR, "%s cant read CCreader buffer-length %m", LogName);
1781 return;
1782 }
1783
1784 buff[i] = '\0';
1785
1786 if (protocol != ICC_PROTOCOL_1) {
1787 syslog(L_ERROR, "%s CCreader protocol mismatch", LogName) ;
1788 return ;
1789 }
1790
1791 #endif /* defined (DO_HAVE_UNIX_DOMAIN) */
1792
1793 /* Copy to a printable buffer, and log. */
1794 (void)strcpy(copy, buff);
1795 for (p = NULL, q = copy; *q; q++)
1796 if (*q == SC_SEP) {
1797 *q = ':';
1798 if (p == NULL)
1799 p = q + 1;
1800 }
1801 syslog(L_CC_CMD, "%s", p ? p : copy);
1802
1803 /* Split up the fields, get the command letter. */
1804 if ((argc = CCargsplit(buff, &buff[i], argv, SIZEOF(argv))) < 2
1805 || argc == SIZEOF(argv)) {
1806 syslog(L_ERROR, "%s bad_fields CCreader", LogName);
1807 return;
1808 }
1809 p = argv[1];
1810 i = *p;
1811
1812 /* Dispatch to the command function. */
1813 for (argc -= 2, dp = CCcommands; dp < ENDOF(CCcommands); dp++)
1814 if (i == dp->Name) {
1815 if (argc != dp->argc)
1816 p = "1 Wrong number of parameters";
1817 else
1818 p = (*dp->Function)(&argv[2]);
1819 break;
1820 }
1821 if (dp == ENDOF(CCcommands)) {
1822 syslog(L_NOTICE, "%s bad_message %c", LogName, i);
1823 p = "1 Bad command";
1824 }
1825 else if (p == NULL)
1826 p = "0 Ok";
1827
1828 /* Build the reply address and send the reply. */
1829 len = strlen(p) + HEADER_SIZE ;
1830 tbuff = NEW(char,len + 1);
1831
1832 protocol = ICC_PROTOCOL_1 ;
1833 memcpy (tbuff,&protocol,sizeof (protocol)) ;
1834 tbuff += sizeof (protocol) ;
1835
1836 bufflen = htons (len) ;
1837 memcpy (tbuff,&bufflen,sizeof (bufflen)) ;
1838 tbuff += sizeof (bufflen) ;
1839
1840 strcpy (tbuff,p) ;
1841 tbuff -= HEADER_SIZE ;
1842
1843 #if defined(DO_HAVE_UNIX_DOMAIN)
1844 (void)memset((POINTER)&client, 0, sizeof client);
1845 client.sun_family = AF_UNIX;
1846 (void)strcpy(client.sun_path, argv[0]);
1847 if (sendto(CCwriter, tbuff, len, 0,
1848 (struct sockaddr *)&client, AF_UNIX_SOCKSIZE(client)) < 0) {
1849 i = errno;
1850 syslog(i == ENOENT ? L_NOTICE : L_ERROR,
1851 "%s cant sendto CCreader bytes %d %m", LogName, len);
1852 if (i == EMSGSIZE)
1853 (void)sendto(CCwriter, TOOLONG, STRLEN(TOOLONG), 0,
1854 (struct sockaddr *)&client, AF_UNIX_SOCKSIZE(client));
1855 }
1856 #else
1857 if ((i = open(argv[0], O_WRONLY | O_NDELAY)) < 0)
1858 syslog(L_ERROR, "%s cant open %s %m", LogName, argv[0]);
1859 else {
1860 if ((written = write(i, tbuff, len)) != len)
1861 if (written < 0)
1862 syslog(L_ERROR, "%s cant write %s %m", LogName, argv[0]);
1863 else
1864 syslog(L_ERROR, "%s cant write %s", LogName, argv[0]);
1865 if (close(i) < 0)
1866 syslog(L_ERROR, "%s cant close %s %m", LogName, argv[0]);
1867 }
1868 #endif /* defined(DO_HAVE_UNIX_DOMAIN) */
1869 DISPOSE (tbuff) ;
1870 }
1871
1872
1873 /*
1874 ** Called when a write-in-progress is done on the channel. Shouldn't happen.
1875 */
1876 STATIC FUNCTYPE
1877 CCwritedone()
1878 {
1879 syslog(L_ERROR, "%s internal CCwritedone", LogName);
1880 }
1881
1882
1883 /*
1884 ** Create the channel.
1885 */
1886 void
1887 CCsetup()
1888 {
1889 int i;
1890 #if defined(DO_HAVE_UNIX_DOMAIN)
1891 struct sockaddr_un server;
1892 #endif /* defined(DO_HAVE_UNIX_DOMAIN) */
1893
1894 /* Remove old detritus. */
1895 if (unlink(CCpath) < 0 && errno != ENOENT) {
1896 syslog(L_FATAL, "%s cant unlink %s %m", LogName, CCpath);
1897 exit(1);
1898 }
1899
1900 #if defined(DO_HAVE_UNIX_DOMAIN)
1901 /* Create a socket and name it. */
1902 if ((i = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) {
1903 syslog(L_FATAL, "%s cant socket %s %m", LogName, CCpath);
1904 exit(1);
1905 }
1906 (void)memset((POINTER)&server, 0, sizeof server);
1907 server.sun_family = AF_UNIX;
1908 (void)strcpy(server.sun_path, CCpath);
1909 if (bind(i, (struct sockaddr *)&server, AF_UNIX_SOCKSIZE(server)) < 0) {
1910 syslog(L_FATAL, "%s cant bind %s %m", LogName, CCpath);
1911 exit(1);
1912 }
1913
1914 /* Create an unbound socket to reply on. */
1915 if ((CCwriter = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) {
1916 syslog(L_FATAL, "%s cant socket unbound %m", LogName);
1917 exit(1);
1918 }
1919 #else
1920 /* Create a named pipe and open it. */
1921 if (mkfifo(CCpath, 0666) < 0) {
1922 syslog(L_FATAL, "%s cant mkfifo %s %m", LogName, CCpath);
1923 exit(1);
1924 }
1925 if ((i = open(CCpath, O_RDWR)) < 0) {
1926 syslog(L_FATAL, "%s cant open %s %m", LogName, CCpath);
1927 exit(1);
1928 }
1929 #endif /* defined(DO_HAVE_UNIX_DOMAIN) */
1930
1931 CCchan = CHANcreate(i, CTcontrol, CSwaiting, CCreader, CCwritedone);
1932 syslog(L_NOTICE, "%s ccsetup %s", LogName, CHANname(CCchan));
1933 RCHANadd(CCchan);
1934
1935 if (CCreply.Size == 0) {
1936 CCreply.Size = SMBUF;
1937 CCreply.Data = NEW(char, CCreply.Size);
1938 }
1939
1940 /*
1941 * Catch SIGUSR1 so that we can recreate the control channel when
1942 * needed (i.e. something has deleted our named socket.
1943 */
1944 #if defined(SIGUSR1)
1945 (void)signal(SIGUSR1, CCresetup);
1946 #endif /* defined(SIGUSR1) */
1947
1948 CCsdnotify();
1949 }
1950
1951
1952 /*
1953 ** Cleanly shut down the channel.
1954 */
1955 void
1956 CCclose()
1957 {
1958 CHANclose(CCchan, CHANname(CCchan));
1959 CCchan = NULL;
1960 if (unlink(CCpath) < 0)
1961 syslog(L_ERROR, "%s cant unlink %s %m", LogName, CCpath);
1962 #if defined(DO_HAVE_UNIX_DOMAIN)
1963 if (close(CCwriter) < 0)
1964 syslog(L_ERROR, "%s cant close unbound %m", LogName);
1965 #endif /* defined(DO_HAVE_UNIX_DOMAIN) */
1966 }
1967
1968
1969 /*
1970 ** Restablish the control channel.
1971 */
1972 STATIC SIGHANDLER
1973 CCresetup(s)
1974 int s;
1975 {
1976 (void)signal(s, CCresetup);
1977 CCclose();
1978 CCsetup();
1979 }