chiark / gitweb /
Fix memory management of argument to open_input_file
[inn-innduct.git] / frontends / ovdb_server.c
1 /*
2  * ovdb_server.c
3  * ovdb read server
4  */
5
6 #include "config.h"
7 #include "clibrary.h"
8 #include "portable/mmap.h"
9 #include "portable/time.h"
10 #include "portable/setproctitle.h"
11 #include "portable/socket.h"
12 #include "portable/wait.h"
13 #include <errno.h>
14 #include <fcntl.h>
15 #include <signal.h>
16 #ifdef HAVE_SYS_SELECT_H
17 # include <sys/select.h>
18 #endif
19 #include <syslog.h>
20
21 #ifdef HAVE_UNIX_DOMAIN_SOCKETS
22 # include <sys/un.h>
23 #endif
24
25 #include "inn/innconf.h"
26 #include "inn/messages.h"
27 #include "libinn.h"
28 #include "paths.h"
29 #include "storage.h"
30 #include "ov.h"
31
32 #include "../storage/ovdb/ovdb.h"
33 #include "../storage/ovdb/ovdb-private.h"
34
35 #ifndef USE_BERKELEY_DB
36
37 int
38 main(int argc UNUSED, char **argv UNUSED)
39 {
40     die("BerkeleyDB support not compiled");
41 }
42
43 #else /* USE_BERKELEY_DB */
44
45
46 #define SELECT_TIMEOUT 15
47
48
49 /* This will work unless user sets a larger clienttimeout
50    in readers.conf */
51 #define CLIENT_TIMEOUT (innconf->clienttimeout + 60)
52 /*#define CLIENT_TIMEOUT 3600*/
53
54
55 static int listensock;
56
57 #define MODE_READ   0
58 #define MODE_WRITE  1
59 #define MODE_CLOSED 2
60 #define STATE_READCMD 0
61 #define STATE_READGROUP 1
62 struct reader {
63     int fd;
64     int mode;
65     int state;
66     int buflen;
67     int bufpos;
68     void *buf;
69     time_t lastactive;
70     void *currentsearch;
71 };
72
73 static struct reader *readertab;
74 static int readertablen;
75 static int numreaders;
76 static time_t now;
77 static pid_t parent;
78
79 struct child {
80     pid_t pid;
81     int num;
82     time_t started;
83 };
84 static struct child *children;
85 #define wholistens (children[ovdb_conf.numrsprocs].num)
86
87 static int signalled = 0;
88 static void
89 sigfunc(int sig UNUSED)
90 {
91     signalled = 1;
92 }
93
94 static int updated = 0;
95 static void
96 childsig(int sig UNUSED)
97 {
98     updated = 1;
99 }
100
101 static void
102 parentsig(int sig UNUSED)
103 {
104     int i, which, smallest;
105     if(wholistens < 0) {
106         which = smallest = -1;
107         for(i = 0; i < ovdb_conf.numrsprocs; i++) {
108             if(children[i].pid == -1)
109                 continue;
110             if(!ovdb_conf.maxrsconn || children[i].num <= ovdb_conf.maxrsconn) {
111                 if(smallest == -1 || children[i].num < smallest) {
112                     smallest = children[i].num;
113                     which = i;
114                 }
115             }
116         }
117         if(which != -1) {
118             wholistens = which;
119             kill(children[which].pid, SIGUSR1);
120         } else {
121             wholistens = -2;
122         }
123         updated = 1;
124     }
125 }
126
127 static int putpid(const char *path)
128 {
129     char buf[30];
130     int fd = open(path, O_WRONLY|O_TRUNC|O_CREAT, 0664);
131     if(fd == -1) {
132         syswarn("cannot open %s", path);
133         return -1;
134     }
135     snprintf(buf, sizeof(buf), "%d\n", getpid());
136     if(write(fd, buf, strlen(buf)) < 0) {
137         syswarn("cannot write to %s", path);
138         close(fd);
139         return -1;
140     }
141     close(fd);
142     return 0;
143 }
144
145 static void
146 do_groupstats(struct reader *r)
147 {
148     struct rs_groupstats *reply;
149     char *group = (char *)(r->buf) + sizeof(struct rs_cmd);
150     reply = xmalloc(sizeof(struct rs_groupstats));
151
152     /*syslog(LOG_DEBUG, "OVDB: rs: do_groupstats '%s'", group);*/
153     if(ovdb_groupstats(group, &reply->lo, &reply->hi, &reply->count, &reply->flag)) {
154         reply->status = CMD_GROUPSTATS;
155         reply->aliaslen = 0;
156     } else {
157         reply->status = CMD_GROUPSTATS | RPLY_ERROR;
158     }
159     free(r->buf);
160     r->buf = reply;
161     r->buflen = sizeof(struct rs_groupstats);
162     r->bufpos = 0;
163     r->mode = MODE_WRITE;
164 }
165
166 static void
167 do_opensrch(struct reader *r)
168 {
169     struct rs_cmd *cmd = r->buf;
170     struct rs_opensrch *reply;
171     char *group = (char *)(r->buf) + sizeof(struct rs_cmd);
172     reply = xmalloc(sizeof(struct rs_opensrch));
173
174     /*syslog(LOG_DEBUG, "OVDB: rs: do_opensrch '%s' %d %d", group, cmd->artlo, cmd->arthi);*/
175
176     if(r->currentsearch != NULL) {
177         /* can only open one search at a time */
178         reply->status = CMD_OPENSRCH | RPLY_ERROR;
179     } else {
180         reply->handle = ovdb_opensearch(group, cmd->artlo, cmd->arthi);
181         if(reply->handle == NULL) {
182             reply->status = CMD_OPENSRCH | RPLY_ERROR;
183         } else {
184             reply->status = CMD_OPENSRCH;
185         }
186         r->currentsearch = reply->handle;
187     }
188     free(r->buf);
189     r->buf = reply;
190     r->buflen = sizeof(struct rs_opensrch);
191     r->bufpos = 0;
192     r->mode = MODE_WRITE;
193 }
194
195 static void
196 do_srch(struct reader *r)
197 {
198     struct rs_cmd *cmd = r->buf;
199     struct rs_srch *reply;
200     ARTNUM artnum;
201     TOKEN token;
202     time_t arrived;
203     int len;
204     char *data;
205
206     if(ovdb_search(cmd->handle, &artnum, &data, &len, &token, &arrived)) {
207         reply = xmalloc(sizeof(struct rs_srch) + len);
208         reply->status = CMD_SRCH;
209         reply->artnum = artnum;
210         reply->token = token;
211         reply->arrived = arrived;
212         reply->len = len;
213         memcpy((char *)reply + sizeof(struct rs_srch), data, len);
214         r->buflen = sizeof(struct rs_srch) + len;
215     } else {
216         reply = xmalloc(sizeof(struct rs_srch));
217         reply->status = CMD_SRCH | RPLY_ERROR;
218         r->buflen = sizeof(struct rs_srch);
219     }
220     free(r->buf);
221     r->buf = reply;
222     r->bufpos = 0;
223     r->mode = MODE_WRITE;
224 }
225
226 static void
227 do_closesrch(struct reader *r)
228 {
229     struct rs_cmd *cmd = r->buf;
230
231     ovdb_closesearch(cmd->handle);
232     free(r->buf);
233     r->buf = NULL;
234     r->bufpos = r->buflen = 0;
235     r->mode = MODE_READ;
236     r->currentsearch = NULL;
237 }
238
239 static void
240 do_artinfo(struct reader *r)
241 {
242     struct rs_cmd *cmd = r->buf;
243     struct rs_artinfo *reply;
244     char *group = (char *)(r->buf) + sizeof(struct rs_cmd);
245     TOKEN token;
246
247     /*syslog(LOG_DEBUG, "OVDB: rs: do_artinfo: '%s' %d", group, cmd->artlo);*/
248     if(ovdb_getartinfo(group, cmd->artlo, &token)) {
249         reply = xmalloc(sizeof(struct rs_artinfo));
250         reply->status = CMD_ARTINFO;
251         reply->token = token;
252         r->buflen = sizeof(struct rs_artinfo);
253     } else {
254         reply = xmalloc(sizeof(struct rs_artinfo));
255         reply->status = CMD_ARTINFO | RPLY_ERROR;
256         r->buflen = sizeof(struct rs_artinfo);
257     }
258     free(r->buf);
259     r->buf = reply;
260     r->bufpos = 0;
261     r->mode = MODE_WRITE;
262 }
263
264
265 static int
266 process_cmd(struct reader *r)
267 {
268     struct rs_cmd *cmd = r->buf;
269
270     if(r->state == STATE_READCMD) {
271         switch(cmd->what) {
272         case CMD_GROUPSTATS:
273         case CMD_OPENSRCH:
274         case CMD_ARTINFO:
275             r->state = STATE_READGROUP;
276             if(cmd->grouplen == 0) {
277                 /* shoudn't happen... */
278                 r->mode = MODE_CLOSED;
279                 close(r->fd);
280                 free(r->buf);
281                 r->buf = NULL;
282                 return 0;
283             }
284             r->buflen += cmd->grouplen;
285             r->buf = xrealloc(r->buf, r->buflen);
286             return 1;
287         }
288     }
289
290     switch(cmd->what) {
291     case CMD_GROUPSTATS:
292         ((char *)r->buf)[r->buflen - 1] = 0;    /* make sure group is null-terminated */
293         do_groupstats(r);
294         break;
295     case CMD_OPENSRCH:
296         ((char *)r->buf)[r->buflen - 1] = 0;
297         do_opensrch(r);
298         break;
299     case CMD_SRCH:
300         do_srch(r);
301         break;
302     case CMD_CLOSESRCH:
303         do_closesrch(r);
304         break;
305     case CMD_ARTINFO:
306         ((char *)r->buf)[r->buflen - 1] = 0;
307         do_artinfo(r);
308         break;
309     default:
310         r->mode = MODE_CLOSED;
311         close(r->fd);
312         free(r->buf);
313         r->buf = NULL;
314         break;
315     }
316
317     return 0;
318 }
319
320 static void
321 handle_read(struct reader *r)
322 {
323     int n;
324     r->lastactive = now;
325
326     if(r->buf == NULL) {
327         r->state = STATE_READCMD;
328         r->buf = xmalloc(sizeof(struct rs_cmd));
329         r->buflen = sizeof(struct rs_cmd);
330         r->bufpos = 0;
331     }
332 again:
333     n = read(r->fd, (char *)(r->buf) + r->bufpos, r->buflen - r->bufpos);
334     if(n <= 0) {
335         if(n < 0 && (errno == EAGAIN || errno == EINTR || errno == EWOULDBLOCK))
336             return;
337         r->mode = MODE_CLOSED;
338         close(r->fd);
339         free(r->buf);
340         r->buf = NULL;
341     }
342     r->bufpos += n;
343
344     if(r->bufpos >= r->buflen)
345         if(process_cmd(r))
346             goto again;
347 }
348
349 static void
350 handle_write(struct reader *r)
351 {
352     int n;
353     r->lastactive = now;
354
355     if(r->buf == NULL)  /* shouldn't happen */
356         return;
357
358     n = write(r->fd, (char *)(r->buf) + r->bufpos, r->buflen - r->bufpos);
359     if(n <= 0) {
360         if(n < 0 && (errno == EAGAIN || errno == EINTR || errno == EWOULDBLOCK))
361             return;
362         r->mode = MODE_CLOSED;
363         close(r->fd);
364         free(r->buf);
365         r->buf = NULL;
366     }
367     r->bufpos += n;
368
369     if(r->bufpos >= r->buflen) {
370         free(r->buf);
371         r->buf = NULL;
372         r->bufpos = r->buflen = 0;
373         r->mode = MODE_READ;
374     }
375 }
376
377 static void
378 newclient(int fd)
379 {
380     struct reader *r;
381     int i;
382
383     nonblocking(fd, 1);
384
385     if(numreaders >= readertablen) {
386         readertablen += 50;
387         readertab = xrealloc(readertab, readertablen * sizeof(struct reader));
388         for(i = numreaders; i < readertablen; i++) {
389             readertab[i].mode = MODE_CLOSED;
390             readertab[i].buf = NULL;
391         }
392     }
393
394     r = &(readertab[numreaders]);
395     numreaders++;
396
397     r->fd = fd;
398     r->mode = MODE_WRITE;
399     r->buflen = sizeof(OVDB_SERVER_BANNER);
400     r->bufpos = 0;
401     r->buf = xstrdup(OVDB_SERVER_BANNER);
402     r->lastactive = now;
403     r->currentsearch = NULL;
404
405     handle_write(r);
406 }
407
408 static void
409 delclient(int which)
410 {
411     int i;
412     struct reader *r = &(readertab[which]);
413
414     if(r->mode != MODE_CLOSED)
415         close(r->fd);
416
417     if(r->buf != NULL) {
418         free(r->buf);
419     }
420     if(r->currentsearch != NULL) {
421         ovdb_closesearch(r->currentsearch);
422         r->currentsearch = NULL;
423     }
424
425     /* numreaders will get decremented by the calling function */
426     for(i = which; i < numreaders-1; i++)
427         readertab[i] = readertab[i+1];
428
429     readertab[i].mode = MODE_CLOSED;
430     readertab[i].buf = NULL;
431 }
432
433 static pid_t
434 serverproc(int me)
435 {
436     fd_set rdset, wrset;
437     int i, ret, count, lastfd, lastnumreaders;
438     socklen_t salen;
439     struct sockaddr_in sa;
440     struct timeval tv;
441     pid_t pid;
442
443     pid = fork();
444     if (pid != 0)
445         return pid;
446
447     if (!ovdb_open(OV_READ|OVDB_SERVER))
448         die("cannot open overview");
449     xsignal_norestart(SIGINT, sigfunc);
450     xsignal_norestart(SIGTERM, sigfunc);
451     xsignal_norestart(SIGHUP, sigfunc);
452     xsignal_norestart(SIGUSR1, childsig);
453     xsignal(SIGPIPE, SIG_IGN);
454
455     numreaders = lastnumreaders = 0;
456     if(ovdb_conf.maxrsconn) {
457         readertablen = ovdb_conf.maxrsconn;
458     } else {
459         readertablen = 50;
460     }
461     readertab = xmalloc(readertablen * sizeof(struct reader));
462     for(i = 0; i < readertablen; i++) {
463         readertab[i].mode = MODE_CLOSED;
464         readertab[i].buf = NULL;
465     }
466
467     setproctitle("0 clients");
468
469     /* main loop */
470     while(!signalled) {
471         FD_ZERO(&rdset);
472         FD_ZERO(&wrset);
473         lastfd = 0;
474         if(wholistens == me) {
475             if(!ovdb_conf.maxrsconn || numreaders < ovdb_conf.maxrsconn) {
476                 FD_SET(listensock, &rdset);
477                 lastfd = listensock;
478                 setproctitle("%d client%s *", numreaders,
479                              numreaders == 1 ? "" : "s");
480             } else {
481                 wholistens = -1;
482                 kill(parent, SIGUSR1);
483             }
484         }
485
486         for(i = 0; i < numreaders; i++) {
487             switch(readertab[i].mode) {
488             case MODE_READ:
489                 FD_SET(readertab[i].fd, &rdset);
490                 break;
491             case MODE_WRITE:
492                 FD_SET(readertab[i].fd, &wrset);
493                 break;
494             default:
495                 continue;
496             }
497             if(readertab[i].fd > lastfd)
498                 lastfd = readertab[i].fd;
499         }
500         tv.tv_usec = 0;
501         tv.tv_sec = SELECT_TIMEOUT;
502         count = select(lastfd + 1, &rdset, &wrset, NULL, &tv);
503
504         if(signalled)
505             break;
506         if(count <= 0)
507             continue;
508
509         now = time(NULL);
510
511         if(FD_ISSET(listensock, &rdset)) {
512             if(!ovdb_conf.maxrsconn || numreaders < ovdb_conf.maxrsconn) {
513                 salen = sizeof(sa);
514                 ret = accept(listensock, (struct sockaddr *)&sa, &salen);
515                 if(ret >= 0) {
516                     newclient(ret);
517                     wholistens = -1;
518                     children[me].num = numreaders;
519                     kill(parent, SIGUSR1);
520                 }
521             }
522         }
523
524         for(i = 0; i < numreaders; i++) {
525             switch(readertab[i].mode) {
526             case MODE_READ:
527                 if(FD_ISSET(readertab[i].fd, &rdset))
528                     handle_read(&(readertab[i]));
529                 break;
530             case MODE_WRITE:
531                 if(FD_ISSET(readertab[i].fd, &wrset))
532                     handle_write(&(readertab[i]));
533                 break;
534             }
535         }
536
537         for(i = 0; i < numreaders; i++) {
538             if(readertab[i].mode == MODE_CLOSED
539                   || readertab[i].lastactive + CLIENT_TIMEOUT < now) {
540                 delclient(i);
541                 numreaders--;
542                 i--;
543             }
544         }
545         if(children[me].num != numreaders) {
546             children[me].num = numreaders;
547             kill(parent, SIGUSR1);
548         }
549         if(numreaders != lastnumreaders) {
550             lastnumreaders = numreaders;
551             setproctitle("%d client%s", numreaders,
552                          numreaders == 1 ? "" : "s");
553         }
554     }
555
556     ovdb_close();
557     exit(0);
558 }
559
560 static int
561 reap(void)
562 {
563     int i, cs;
564     pid_t c;
565
566     while((c = waitpid(-1, &cs, WNOHANG)) > 0) {
567         for(i = 0; i < ovdb_conf.numrsprocs; i++) {
568             if(c == children[i].pid) {
569                 if(children[i].started + 30 > time(NULL))
570                     return 1;
571
572                 children[i].num = 0;
573
574                 if(wholistens == i)
575                     wholistens = -1;
576
577                 if((children[i].pid = serverproc(i)) == -1)
578                     return 1;
579
580                 children[i].started = time(NULL);
581                 break;
582             }
583         }
584     }
585     if(wholistens == -1)
586         parentsig(SIGUSR1);
587     return 0;
588 }
589
590 #ifndef MAP_ANON
591 #ifdef MAP_ANONYMOUS
592 #define MAP_ANON MAP_ANONYMOUS
593 #endif
594 #endif
595
596 static void *
597 sharemem(size_t len)
598 {
599 #ifdef MAP_ANON
600     return mmap(0, len, PROT_READ|PROT_WRITE, MAP_ANON|MAP_SHARED, -1, 0);
601 #else
602     int fd = open("/dev/zero", O_RDWR, 0);
603     char *ptr = mmap(0, len, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0);
604     close(fd);
605     return ptr;
606 #endif
607 }
608
609 int
610 main(int argc, char *argv[])
611 {
612     int i, ret;
613     socklen_t salen;
614     char *path, *pidfile;
615 #ifdef HAVE_UNIX_DOMAIN_SOCKETS
616     struct sockaddr_un sa;
617 #else
618     struct sockaddr_in sa;
619 #endif
620     struct timeval tv;
621     fd_set rdset;
622
623     setproctitle_init(argc, argv);
624
625     openlog("ovdb_server", L_OPENLOG_FLAGS | LOG_PID, LOG_INN_PROG);
626     message_program_name = "ovdb_server";
627
628     if(argc != 2 || strcmp(argv[1], SPACES))
629         die("should be started by ovdb_init");
630     message_handlers_warn(1, message_log_syslog_err);
631     message_handlers_die(1, message_log_syslog_err);
632
633     if (!innconf_read(NULL))
634         exit(1);
635
636     if(strcmp(innconf->ovmethod, "ovdb"))
637         die("ovmethod not set to ovdb in inn.conf");
638
639     read_ovdb_conf();
640
641 #ifdef HAVE_UNIX_DOMAIN_SOCKETS
642     listensock = socket(AF_UNIX, SOCK_STREAM, 0);
643 #else
644     listensock = socket(AF_INET, SOCK_STREAM, 0);
645 #endif
646     if(listensock < 0)
647         sysdie("cannot create socket");
648
649     nonblocking(listensock, 1);
650
651 #ifdef HAVE_UNIX_DOMAIN_SOCKETS
652     sa.sun_family = AF_UNIX;
653     path = concatpath(innconf->pathrun, OVDB_SERVER_SOCKET);
654     strlcpy(sa.sun_path, path, sizeof(sa.sun_path));
655     unlink(sa.sun_path);
656     free(path);
657     ret = bind(listensock, (struct sockaddr *)&sa, sizeof sa);
658 #else
659     sa.sin_family = AF_INET;
660     sa.sin_port = htons(OVDB_SERVER_PORT);
661     sa.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
662     
663     ret = bind(listensock, (struct sockaddr *)&sa, sizeof sa);
664
665     if(ret != 0 && errno == EADDRNOTAVAIL) {
666         sa.sin_family = AF_INET;
667         sa.sin_port = htons(OVDB_SERVER_PORT);
668         sa.sin_addr.s_addr = INADDR_ANY;
669         ret = bind(listensock, (struct sockaddr *)&sa, sizeof sa);
670     }
671 #endif
672
673     if(ret != 0)
674         sysdie("cannot bind socket");
675     if(listen(listensock, MAXLISTEN) < 0)
676         sysdie("cannot listen on socket");
677
678     pidfile = concatpath(innconf->pathrun, OVDB_SERVER_PIDFILE);
679     if(putpid(pidfile))
680         exit(1);
681
682     xsignal_norestart(SIGINT, sigfunc);
683     xsignal_norestart(SIGTERM, sigfunc);
684     xsignal_norestart(SIGHUP, sigfunc);
685
686     xsignal_norestart(SIGUSR1, parentsig);
687     xsignal_norestart(SIGCHLD, childsig);
688     parent = getpid();
689
690     children = sharemem(sizeof(struct child) * (ovdb_conf.numrsprocs+1));
691
692     if(children == NULL)
693         sysdie("cannot mmap shared memory");
694     for(i = 0; i < ovdb_conf.numrsprocs+1; i++) {
695         children[i].pid = -1;
696         children[i].num = 0;
697     }
698
699     for(i = 0; i < ovdb_conf.numrsprocs; i++) {
700         if((children[i].pid = serverproc(i)) == -1) {
701             for(i--; i >= 0; i--)
702                 kill(children[i].pid, SIGTERM);
703             exit(1);
704         }
705         children[i].started = time(NULL);
706         sleep(1);
707     }
708
709     while(!signalled) {
710         if(reap())
711             break;
712
713         if(wholistens == -2) {
714             FD_ZERO(&rdset);
715             FD_SET(listensock, &rdset);
716             tv.tv_usec = 0;
717             tv.tv_sec = SELECT_TIMEOUT;
718             ret = select(listensock+1, &rdset, NULL, NULL, &tv);
719
720             if(ret == 1 && wholistens == -2) {
721                 salen = sizeof(sa);
722                 ret = accept(listensock, (struct sockaddr *)&sa, &salen);
723                 if(ret >= 0)
724                    close(ret);
725             }
726         } else {
727             pause();
728         }
729     }
730
731     for(i = 0; i < ovdb_conf.numrsprocs; i++)
732         if(children[i].pid != -1)
733             kill(children[i].pid, SIGTERM);
734
735     while(wait(&ret) > 0)
736         ;
737
738     unlink(pidfile);
739
740     exit(0);
741 }
742
743
744 #endif /* USE_BERKELEY_DB */