odr_create_Odr_oct: null terminate the buffer
[yaz-moved-to-github.git] / src / statserv.c
1 /* This file is part of the YAZ toolkit.
2  * Copyright (C) 1995-2013 Index Data
3  * See the file LICENSE for details.
4  */
5
6 /**
7  * \file statserv.c
8  * \brief Implements GFS logic
9  */
10
11 #if HAVE_CONFIG_H
12 #include <config.h>
13 #endif
14
15 #include <stdio.h>
16 #include <stdlib.h>
17 #include <string.h>
18
19 #ifdef WIN32
20 #include <process.h>
21 #include <winsock.h>
22 #include <direct.h>
23 #endif
24
25 #include <yaz/sc.h>
26
27 #if HAVE_SYS_TYPES_H
28 #include <sys/types.h>
29 #endif
30 #if HAVE_SYS_WAIT_H
31 #include <sys/wait.h>
32 #endif
33 #if HAVE_UNISTD_H
34 #include <unistd.h>
35 #endif
36 #if HAVE_PWD_H
37 #include <pwd.h>
38 #endif
39
40 #if YAZ_HAVE_XML2
41 #include <libxml/parser.h>
42 #include <libxml/tree.h>
43 #include <libxml/xinclude.h>
44 #endif
45
46 #if YAZ_POSIX_THREADS
47 #include <pthread.h>
48 #endif
49
50 #include <fcntl.h>
51 #include <signal.h>
52 #include <errno.h>
53
54 #include <yaz/comstack.h>
55 #include <yaz/tcpip.h>
56 #include <yaz/options.h>
57 #include <yaz/errno.h>
58 #ifdef USE_XTIMOSI
59 #include <yaz/xmosi.h>
60 #endif
61 #include <yaz/log.h>
62 #include "eventl.h"
63 #include "session.h"
64 #include <yaz/statserv.h>
65 #include <yaz/daemon.h>
66 #include <yaz/yaz-iconv.h>
67
68 static IOCHAN pListener = NULL;
69
70 static char gfs_root_dir[FILENAME_MAX+1];
71 static struct gfs_server *gfs_server_list = 0;
72 static struct gfs_listen *gfs_listen_list = 0;
73 static NMEM gfs_nmem = 0;
74
75 static char *me = "statserver"; /* log prefix */
76 static char *programname="statserver"; /* full program name */
77 #ifdef WIN32
78 DWORD current_control_tls;
79 static int init_control_tls = 0;
80 #elif YAZ_POSIX_THREADS
81 static pthread_key_t current_control_tls;
82 static int init_control_tls = 0;
83 #else
84 static statserv_options_block *current_control_block = 0;
85 #endif
86
87 /*
88  * default behavior.
89  */
90 #define STAT_DEFAULT_LOG_LEVEL "server,session,request"
91
92 int check_options(int argc, char **argv);
93 statserv_options_block control_block = {
94     1,                          /* dynamic mode */
95     0,                          /* threaded mode */
96     0,                          /* one shot (single session) */
97     "",                         /* no PDUs */
98     "",                         /* diagnostic output to stderr */
99     PROTO_Z3950,                /* default application protocol */
100     900,                        /* idle timeout (seconds) */
101     64*1024*1024,               /* maximum PDU size (approx.) to allow */
102     "default-config",           /* configuration name to pass to backend */
103     "",                         /* set user id */
104     0,                          /* bend_start handler */
105     0,                          /* bend_stop handler */
106     check_options,              /* Default routine, for checking the run-time arguments */
107     check_ip_tcpd,
108     "",
109     0,                          /* default value for inet deamon */
110     0,                          /* handle (for service, etc) */
111     0,                          /* bend_init handle */
112     0,                          /* bend_close handle */
113 #ifdef WIN32
114     "Z39.50 Server",            /* NT Service Name */
115     "Server",                   /* NT application Name */
116     "",                         /* NT Service Dependencies */
117     "Z39.50 Server",            /* NT Service Display Name */
118 #endif /* WIN32 */
119     "",                         /* PID fname */
120     0,                          /* background daemon */
121     "",                         /* SSL certificate filename */
122     "",                         /* XML config filename */
123     1                           /* keepalive */
124 };
125
126 static int max_sessions = 0;
127
128 static int logbits_set = 0;
129 static int log_session = 0; /* one-line logs for session */
130 static int log_sessiondetail = 0; /* more detailed stuff */
131 static int log_server = 0;
132
133 /** get_logbits sets global loglevel bits */
134 static void get_logbits(int force)
135 { /* needs to be called after parsing cmd-line args that can set loglevels!*/
136     if (force || !logbits_set)
137     {
138         logbits_set = 1;
139         log_session = yaz_log_module_level("session");
140         log_sessiondetail = yaz_log_module_level("sessiondetail");
141         log_server = yaz_log_module_level("server");
142     }
143 }
144
145
146 static int add_listener(char *where, int listen_id);
147
148 #if YAZ_HAVE_XML2
149 static xmlDocPtr xml_config_doc = 0;
150 #endif
151
152 #if YAZ_HAVE_XML2
153 static xmlNodePtr xml_config_get_root(void)
154 {
155     xmlNodePtr ptr = 0;
156     if (xml_config_doc)
157     {
158         ptr = xmlDocGetRootElement(xml_config_doc);
159         if (!ptr || ptr->type != XML_ELEMENT_NODE ||
160             strcmp((const char *) ptr->name, "yazgfs"))
161         {
162             yaz_log(YLOG_WARN, "Bad/missing root element for config %s",
163                     control_block.xml_config);
164             return 0;
165
166         }
167     }
168     return ptr;
169 }
170 #endif
171
172 #if YAZ_HAVE_XML2
173 static char *nmem_dup_xml_content(NMEM n, xmlNodePtr ptr)
174 {
175     unsigned char *cp;
176     xmlNodePtr p;
177     int len = 1;  /* start with 1, because of trailing 0 */
178     unsigned char *str;
179     int first = 1; /* whitespace lead flag .. */
180     /* determine length */
181     for (p = ptr; p; p = p->next)
182     {
183         if (p->type == XML_TEXT_NODE)
184             len += xmlStrlen(p->content);
185     }
186     /* now allocate for the string */
187     str = (unsigned char *) nmem_malloc(n, len);
188     *str = '\0'; /* so we can use strcat */
189     for (p = ptr; p; p = p->next)
190     {
191         if (p->type == XML_TEXT_NODE)
192         {
193             cp = p->content;
194             if (first)
195             {
196                 while(*cp && yaz_isspace(*cp))
197                     cp++;
198                 if (*cp)
199                     first = 0;  /* reset if we got non-whitespace out */
200             }
201             strcat((char *)str, (const char *)cp); /* append */
202         }
203     }
204     /* remove trailing whitespace */
205     cp = strlen((const char *)str) + str;
206     while (cp != str && yaz_isspace(cp[-1]))
207         cp--;
208     *cp = '\0';
209     /* return resulting string */
210     return (char *) str;
211 }
212 #endif
213
214 #if YAZ_HAVE_XML2
215 static struct gfs_server * gfs_server_new(const char *id)
216 {
217     struct gfs_server *n = (struct gfs_server *)
218         nmem_malloc(gfs_nmem, sizeof(*n));
219     memcpy(&n->cb, &control_block, sizeof(control_block));
220     n->next = 0;
221     n->host = 0;
222     n->listen_ref = 0;
223     n->cql_transform = 0;
224     n->ccl_transform = 0;
225     n->server_node_ptr = 0;
226     n->directory = 0;
227     n->docpath = 0;
228     n->stylesheet = 0;
229     n->id = nmem_strdup_null(gfs_nmem, id);
230     n->retrieval = yaz_retrieval_create();
231     return n;
232 }
233 #endif
234
235 #if YAZ_HAVE_XML2
236 static struct gfs_listen * gfs_listen_new(const char *id,
237                                           const char *address)
238 {
239     struct gfs_listen *n = (struct gfs_listen *)
240         nmem_malloc(gfs_nmem, sizeof(*n));
241     if (id)
242         n->id = nmem_strdup(gfs_nmem, id);
243     else
244         n->id = 0;
245     n->next = 0;
246     n->address = nmem_strdup(gfs_nmem, address);
247     return n;
248 }
249 #endif
250
251 static void gfs_server_chdir(struct gfs_server *gfs)
252 {
253     if (gfs_root_dir[0])
254     {
255         if (chdir(gfs_root_dir))
256             yaz_log(YLOG_WARN|YLOG_ERRNO, "chdir %s", gfs_root_dir);
257     }
258     if (gfs->directory)
259     {
260         if (chdir(gfs->directory))
261             yaz_log(YLOG_WARN|YLOG_ERRNO, "chdir %s",
262                     gfs->directory);
263     }
264 }
265
266 int control_association(association *assoc, const char *host, int force_open)
267 {
268     char vhost[128], *cp;
269     if (host)
270     {
271         strncpy(vhost, host, 127);
272         vhost[127] = '\0';
273         cp = strchr(vhost, ':');
274         if (cp)
275             *cp = '\0';
276         host = vhost;
277     }
278     assoc->server = 0;
279     if (control_block.xml_config[0])
280     {
281         struct gfs_server *gfs;
282         for (gfs = gfs_server_list; gfs; gfs = gfs->next)
283         {
284             int listen_match = 0;
285             int host_match = 0;
286             if ( !gfs->host || (host && gfs->host && !strcmp(host, gfs->host)))
287                 host_match = 1;
288             if (!gfs->listen_ref ||
289                 gfs->listen_ref == assoc->client_chan->chan_id)
290                 listen_match = 1;
291             if (listen_match && host_match)
292             {
293                 if (force_open ||
294                     (assoc->last_control != &gfs->cb && assoc->backend))
295                 {
296                     statserv_setcontrol(assoc->last_control);
297                     if (assoc->backend && assoc->init)
298                     {
299                         gfs_server_chdir(gfs);
300                         (assoc->last_control->bend_close)(assoc->backend);
301                     }
302                     assoc->backend = 0;
303                     xfree(assoc->init);
304                     assoc->init = 0;
305                 }
306                 assoc->server = gfs;
307                 assoc->last_control = &gfs->cb;
308                 statserv_setcontrol(&gfs->cb);
309
310                 gfs_server_chdir(gfs);
311                 break;
312             }
313         }
314         if (!gfs)
315         {
316             statserv_setcontrol(0);
317             assoc->last_control = 0;
318             return 0;
319         }
320     }
321     else
322     {
323         statserv_setcontrol(&control_block);
324         assoc->last_control = &control_block;
325     }
326     yaz_log(YLOG_DEBUG, "server select: config=%s",
327             assoc->last_control->configname);
328
329     assoc->maximumRecordSize = assoc->last_control->maxrecordsize;
330     assoc->preferredMessageSize = assoc->last_control->maxrecordsize;
331     cs_set_max_recv_bytes(assoc->client_link, assoc->maximumRecordSize);
332     return 1;
333 }
334
335 #if YAZ_HAVE_XML2
336 static void xml_config_read(void)
337 {
338     struct gfs_server **gfsp = &gfs_server_list;
339     struct gfs_listen **gfslp = &gfs_listen_list;
340     xmlNodePtr ptr = xml_config_get_root();
341
342     if (!ptr)
343         return;
344     for (ptr = ptr->children; ptr; ptr = ptr->next)
345     {
346         struct _xmlAttr *attr;
347         if (ptr->type != XML_ELEMENT_NODE)
348             continue;
349         attr = ptr->properties;
350         if (!strcmp((const char *) ptr->name, "listen"))
351         {
352             /*
353               <listen id="listenerid">tcp:@:9999</listen>
354             */
355             const char *id = 0;
356             const char *address =
357                 nmem_dup_xml_content(gfs_nmem, ptr->children);
358             for ( ; attr; attr = attr->next)
359                 if (!xmlStrcmp(attr->name, BAD_CAST "id")
360                     && attr->children && attr->children->type == XML_TEXT_NODE)
361                     id = nmem_dup_xml_content(gfs_nmem, attr->children);
362             if (address)
363             {
364                 *gfslp = gfs_listen_new(id, address);
365                 gfslp = &(*gfslp)->next;
366                 *gfslp = 0; /* make listener list consistent for search */
367             }
368         }
369         else if (!strcmp((const char *) ptr->name, "server"))
370         {
371             xmlNodePtr ptr_server = ptr;
372             xmlNodePtr ptr;
373             const char *listenref = 0;
374             const char *id = 0;
375             struct gfs_server *gfs;
376
377             for ( ; attr; attr = attr->next)
378                 if (!xmlStrcmp(attr->name, BAD_CAST "listenref")
379                     && attr->children && attr->children->type == XML_TEXT_NODE)
380                     listenref = nmem_dup_xml_content(gfs_nmem, attr->children);
381                 else if (!xmlStrcmp(attr->name, BAD_CAST "id")
382                          && attr->children
383                          && attr->children->type == XML_TEXT_NODE)
384                     id = nmem_dup_xml_content(gfs_nmem, attr->children);
385                 else
386                     yaz_log(YLOG_WARN, "Unknown attribute '%s' for server",
387                             attr->name);
388             gfs = *gfsp = gfs_server_new(id);
389             gfs->server_node_ptr = ptr_server;
390             if (listenref)
391             {
392                 int id_no;
393                 struct gfs_listen *gl = gfs_listen_list;
394                 for (id_no = 1; gl; gl = gl->next, id_no++)
395                     if (gl->id && !strcmp(gl->id, listenref))
396                     {
397                         gfs->listen_ref = id_no;
398                         break;
399                     }
400                 if (!gl)
401                     yaz_log(YLOG_WARN, "Non-existent listenref '%s' in server "
402                             "config element", listenref);
403             }
404             for (ptr = ptr_server->children; ptr; ptr = ptr->next)
405             {
406                 if (ptr->type != XML_ELEMENT_NODE)
407                     continue;
408                 if (!strcmp((const char *) ptr->name, "host"))
409                 {
410                     gfs->host = nmem_dup_xml_content(gfs_nmem,
411                                                      ptr->children);
412                 }
413                 else if (!strcmp((const char *) ptr->name, "config"))
414                 {
415                     strcpy(gfs->cb.configname,
416                            nmem_dup_xml_content(gfs_nmem, ptr->children));
417                 }
418                 else if (!strcmp((const char *) ptr->name, "cql2rpn"))
419                 {
420                     char *name = nmem_dup_xml_content(gfs_nmem, ptr->children);
421                     gfs->cql_transform = cql_transform_open_fname(name);
422                     if (!gfs->cql_transform)
423                     {
424                         yaz_log(YLOG_FATAL|YLOG_ERRNO,
425                                 "open CQL transform file '%s'", name);
426                         exit(1);
427                     }
428                 }
429                 else if (!strcmp((const char *) ptr->name, "ccl2rpn"))
430                 {
431                     char *name;
432                     FILE *f;
433
434                     name = nmem_dup_xml_content(gfs_nmem, ptr->children);
435                     if ((f = fopen(name, "r")) == 0) {
436                         yaz_log(YLOG_FATAL, "can't open CCL file '%s'", name);
437                         exit(1);
438                     }
439                     gfs->ccl_transform = ccl_qual_mk();
440                     ccl_qual_file (gfs->ccl_transform, f);
441                     fclose(f);
442                 }
443                 else if (!strcmp((const char *) ptr->name, "directory"))
444                 {
445                     gfs->directory =
446                         nmem_dup_xml_content(gfs_nmem, ptr->children);
447                 }
448                 else if (!strcmp((const char *) ptr->name, "docpath"))
449                 {
450                     gfs->docpath =
451                         nmem_dup_xml_content(gfs_nmem, ptr->children);
452                 }
453                 else if (!strcmp((const char *) ptr->name, "maximumrecordsize"))
454                 {
455                     gfs->cb.maxrecordsize = atoi(
456                         nmem_dup_xml_content(gfs_nmem, ptr->children));
457                 }
458                 else if (!strcmp((const char *) ptr->name, "stylesheet"))
459                 {
460                     char *s = nmem_dup_xml_content(gfs_nmem, ptr->children);
461                     gfs->stylesheet = (char *)
462                         nmem_malloc(gfs_nmem, strlen(s) + 2);
463                     sprintf(gfs->stylesheet, "/%s", s);
464                 }
465                 else if (!strcmp((const char *) ptr->name, "explain"))
466                 {
467                     ; /* being processed separately */
468                 }
469                 else if (!strcmp((const char *) ptr->name, "retrievalinfo"))
470                 {
471                     if (yaz_retrieval_configure(gfs->retrieval, ptr))
472                     {
473                         yaz_log(YLOG_FATAL, "%s in config %s",
474                                 yaz_retrieval_get_error(gfs->retrieval),
475                                 control_block.xml_config);
476                         exit(1);
477                     }
478                 }
479                 else
480                 {
481                     yaz_log(YLOG_FATAL, "Unknown element '%s' in config %s",
482                             ptr->name, control_block.xml_config);
483                     exit(1);
484                 }
485             }
486             gfsp = &(*gfsp)->next;
487         }
488     }
489     *gfsp = 0;
490 }
491 #endif
492
493 static void xml_config_open(void)
494 {
495     if (!getcwd(gfs_root_dir, FILENAME_MAX))
496     {
497         yaz_log(YLOG_WARN|YLOG_ERRNO, "getcwd failed");
498         gfs_root_dir[0] = '\0';
499     }
500 #ifdef WIN32
501     init_control_tls = 1;
502     current_control_tls = TlsAlloc();
503 #elif YAZ_POSIX_THREADS
504     init_control_tls = 1;
505     pthread_key_create(&current_control_tls, 0);
506 #endif
507
508     gfs_nmem = nmem_create();
509 #if YAZ_HAVE_XML2
510     if (control_block.xml_config[0] == '\0')
511         return;
512
513     if (!xml_config_doc)
514     {
515         xml_config_doc = xmlParseFile(control_block.xml_config);
516         if (!xml_config_doc)
517         {
518             yaz_log(YLOG_FATAL, "Could not parse %s", control_block.xml_config);
519             exit(1);
520         }
521         else
522         {
523             int noSubstitutions = xmlXIncludeProcess(xml_config_doc);
524             if (noSubstitutions == -1)
525             {
526                 yaz_log(YLOG_WARN, "XInclude processing failed for config %s",
527                         control_block.xml_config);
528                 exit(1);
529             }
530         }
531     }
532     xml_config_read();
533 #endif
534 }
535
536 static void xml_config_close(void)
537 {
538 #if YAZ_HAVE_XML2
539     if (xml_config_doc)
540     {
541         xmlFreeDoc(xml_config_doc);
542         xml_config_doc = 0;
543     }
544 #endif
545     gfs_server_list = 0;
546     nmem_destroy(gfs_nmem);
547 #ifdef WIN32
548     if (init_control_tls)
549         TlsFree(current_control_tls);
550 #elif YAZ_POSIX_THREADS
551     if (init_control_tls)
552         pthread_key_delete(current_control_tls);
553 #endif
554 }
555
556 static void xml_config_add_listeners(void)
557 {
558     struct gfs_listen *gfs = gfs_listen_list;
559     int id_no;
560
561     for (id_no = 1; gfs; gfs = gfs->next, id_no++)
562     {
563         if (gfs->address)
564             add_listener(gfs->address, id_no);
565     }
566 }
567
568 static void xml_config_bend_start(void)
569 {
570     if (control_block.xml_config[0])
571     {
572         struct gfs_server *gfs = gfs_server_list;
573         for (; gfs; gfs = gfs->next)
574         {
575             yaz_log(YLOG_DEBUG, "xml_config_bend_start config=%s",
576                     gfs->cb.configname);
577             statserv_setcontrol(&gfs->cb);
578             if (control_block.bend_start)
579             {
580                 gfs_server_chdir(gfs);
581                 (control_block.bend_start)(&gfs->cb);
582             }
583         }
584     }
585     else
586     {
587         yaz_log(YLOG_DEBUG, "xml_config_bend_start default config");
588         statserv_setcontrol(&control_block);
589         if (control_block.bend_start)
590             (*control_block.bend_start)(&control_block);
591     }
592 }
593
594 static void xml_config_bend_stop(void)
595 {
596     if (control_block.xml_config[0])
597     {
598         struct gfs_server *gfs = gfs_server_list;
599         for (; gfs; gfs = gfs->next)
600         {
601             yaz_log(YLOG_DEBUG, "xml_config_bend_stop config=%s",
602                     gfs->cb.configname);
603             statserv_setcontrol(&gfs->cb);
604             if (control_block.bend_stop)
605                 (control_block.bend_stop)(&gfs->cb);
606         }
607     }
608     else
609     {
610         yaz_log(YLOG_DEBUG, "xml_config_bend_stop default config");
611         statserv_setcontrol(&control_block);
612         if (control_block.bend_stop)
613             (*control_block.bend_stop)(&control_block);
614     }
615 }
616
617 static void remove_listeners(void);
618
619 /*
620  * handle incoming connect requests.
621  * The dynamic mode is a bit tricky mostly because we want to avoid
622  * doing all of the listening and accepting in the parent - it's
623  * safer that way.
624  */
625 #ifdef WIN32
626
627 typedef struct _ThreadList ThreadList;
628
629 struct _ThreadList
630 {
631     HANDLE hThread;
632     IOCHAN pIOChannel;
633     ThreadList *pNext;
634 };
635
636 static ThreadList *pFirstThread;
637 static CRITICAL_SECTION Thread_CritSect;
638 static BOOL bInitialized = FALSE;
639
640 static void ThreadList_Initialize()
641 {
642     /* Initialize the critical Sections */
643     InitializeCriticalSection(&Thread_CritSect);
644
645     /* Set the first thraed */
646     pFirstThread = NULL;
647
648     /* we have been initialized */
649     bInitialized = TRUE;
650 }
651
652 static void statserv_add(HANDLE hThread, IOCHAN pIOChannel)
653 {
654     /* Only one thread can go through this section at a time */
655     EnterCriticalSection(&Thread_CritSect);
656
657     {
658         /* Lets create our new object */
659         ThreadList *pNewThread = (ThreadList *)malloc(sizeof(ThreadList));
660         pNewThread->hThread = hThread;
661         pNewThread->pIOChannel = pIOChannel;
662         pNewThread->pNext = pFirstThread;
663         pFirstThread = pNewThread;
664
665         /* Lets let somebody else create a new object now */
666         LeaveCriticalSection(&Thread_CritSect);
667     }
668 }
669
670 void statserv_remove(IOCHAN pIOChannel)
671 {
672     /* Only one thread can go through this section at a time */
673     EnterCriticalSection(&Thread_CritSect);
674
675     {
676         ThreadList *pCurrentThread = pFirstThread;
677         ThreadList *pNextThread;
678         ThreadList *pPrevThread =NULL;
679
680         /* Step through all the threads */
681         for (; pCurrentThread != NULL; pCurrentThread = pNextThread)
682         {
683             /* We only need to compare on the IO Channel */
684             if (pCurrentThread->pIOChannel == pIOChannel)
685             {
686                 /* We have found the thread we want to delete */
687                 /* First of all reset the next pointers */
688                 if (pPrevThread == NULL)
689                     pFirstThread = pCurrentThread->pNext;
690                 else
691                     pPrevThread->pNext = pCurrentThread->pNext;
692
693                 /* All we need todo now is delete the memory */
694                 free(pCurrentThread);
695
696                 /* No need to look at any more threads */
697                 pNextThread = NULL;
698             }
699             else
700             {
701                 /* We need to look at another thread */
702                 pNextThread = pCurrentThread->pNext;
703                 pPrevThread = pCurrentThread;
704             }
705         }
706
707         /* Lets let somebody else remove an object now */
708         LeaveCriticalSection(&Thread_CritSect);
709     }
710 }
711
712 /* WIN32 statserv_closedown */
713 static void statserv_closedown()
714 {
715     /* Shouldn't do anything if we are not initialized */
716     if (bInitialized)
717     {
718         int iHandles = 0;
719         HANDLE *pThreadHandles = NULL;
720
721         /* We need to stop threads adding and removing while we */
722         /* start the closedown process */
723         EnterCriticalSection(&Thread_CritSect);
724
725         {
726             /* We have exclusive access to the thread stuff now */
727             /* Y didn't i use a semaphore - Oh well never mind */
728             ThreadList *pCurrentThread = pFirstThread;
729
730             /* Before we do anything else, we need to shutdown the listener */
731             if (pListener != NULL)
732                 iochan_destroy(pListener);
733
734             for (; pCurrentThread != NULL; pCurrentThread = pCurrentThread->pNext)
735             {
736                 /* Just destroy the IOCHAN, that should do the trick */
737                 iochan_destroy(pCurrentThread->pIOChannel);
738                 closesocket(pCurrentThread->pIOChannel->fd);
739
740                 /* Keep a running count of our handles */
741                 iHandles++;
742             }
743
744             if (iHandles > 0)
745             {
746                 HANDLE *pCurrentHandle ;
747
748                 /* Allocate the thread handle array */
749                 pThreadHandles = (HANDLE *)malloc(sizeof(HANDLE) * iHandles);
750                 pCurrentHandle = pThreadHandles;
751
752                 for (pCurrentThread = pFirstThread;
753                      pCurrentThread != NULL;
754                      pCurrentThread = pCurrentThread->pNext, pCurrentHandle++)
755                 {
756                     /* Just the handle */
757                     *pCurrentHandle = pCurrentThread->hThread;
758                 }
759             }
760
761             /* We can now leave the critical section */
762             LeaveCriticalSection(&Thread_CritSect);
763         }
764
765         /* Now we can really do something */
766         if (iHandles > 0)
767         {
768             yaz_log(log_server, "waiting for %d to die", iHandles);
769             /* This will now wait, until all the threads close */
770             WaitForMultipleObjects(iHandles, pThreadHandles, TRUE, INFINITE);
771
772             /* Free the memory we allocated for the handle array */
773             free(pThreadHandles);
774         }
775
776         xml_config_bend_stop();
777         /* No longer require the critical section, since all threads are dead */
778         DeleteCriticalSection(&Thread_CritSect);
779     }
780     xml_config_close();
781 }
782
783 void __cdecl event_loop_thread(IOCHAN iochan)
784 {
785     iochan_event_loop(&iochan);
786 }
787
788 /* WIN32 listener */
789 static void listener(IOCHAN h, int event)
790 {
791     COMSTACK line = (COMSTACK) iochan_getdata(h);
792     IOCHAN parent_chan = line->user;
793     association *newas;
794     int res;
795     HANDLE newHandle;
796
797     if (event == EVENT_INPUT)
798     {
799         COMSTACK new_line;
800         IOCHAN new_chan;
801
802         if ((res = cs_listen(line, 0, 0)) < 0)
803         {
804             yaz_log(YLOG_FATAL|YLOG_ERRNO, "cs_listen failed");
805             return;
806         }
807         else if (res == 1)
808             return; /* incomplete */
809         yaz_log(YLOG_DEBUG, "listen ok");
810         new_line = cs_accept(line);
811         if (!new_line)
812         {
813             yaz_log(YLOG_FATAL, "Accept failed.");
814             return;
815         }
816         yaz_log(YLOG_DEBUG, "Accept ok");
817
818         if (!(new_chan = iochan_create(cs_fileno(new_line), ir_session,
819                                        EVENT_INPUT, parent_chan->chan_id)))
820         {
821             yaz_log(YLOG_FATAL, "Failed to create iochan");
822             iochan_destroy(h);
823             return;
824         }
825
826         yaz_log(YLOG_DEBUG, "Creating association");
827         if (!(newas = create_association(new_chan, new_line,
828                                          control_block.apdufile)))
829         {
830             yaz_log(YLOG_FATAL, "Failed to create new assoc.");
831             iochan_destroy(h);
832             return;
833         }
834         newas->cs_get_mask = EVENT_INPUT;
835         newas->cs_put_mask = 0;
836         newas->cs_accept_mask = 0;
837
838         yaz_log(YLOG_DEBUG, "Setting timeout %d", control_block.idle_timeout);
839         iochan_setdata(new_chan, newas);
840         iochan_settimeout(new_chan, 60);
841
842         /* Now what we need todo is create a new thread with this iochan as
843            the parameter */
844         newHandle = (HANDLE) _beginthread(event_loop_thread, 0, new_chan);
845         if (newHandle == (HANDLE) -1)
846         {
847
848             yaz_log(YLOG_FATAL|YLOG_ERRNO, "Failed to create new thread.");
849             iochan_destroy(h);
850             return;
851         }
852         /* We successfully created the thread, so add it to the list */
853         statserv_add(newHandle, new_chan);
854
855         yaz_log(YLOG_DEBUG, "Created new thread, id = %ld iochan %p",(long) newHandle, new_chan);
856         iochan_setflags(h, EVENT_INPUT | EVENT_EXCEPT); /* reset listener */
857     }
858     else
859     {
860         yaz_log(YLOG_FATAL, "Bad event on listener.");
861         iochan_destroy(h);
862         return;
863     }
864 }
865
866 #else /* ! WIN32 */
867
868 /* To save having an #ifdef in event_loop we need to
869    define this empty function
870 */
871 void statserv_remove(IOCHAN pIOChannel)
872 {
873 }
874
875 static void statserv_closedown(void)
876 {
877     IOCHAN p;
878
879     xml_config_bend_stop();
880     for (p = pListener; p; p = p->next)
881     {
882         iochan_destroy(p);
883     }
884     xml_config_close();
885 }
886
887 static void *new_session(void *vp);
888 static int no_sessions = 0;
889
890 /* UNIX listener */
891 static void listener(IOCHAN h, int event)
892 {
893     COMSTACK line = (COMSTACK) iochan_getdata(h);
894     int res;
895
896     if (event == EVENT_INPUT)
897     {
898         COMSTACK new_line;
899         if ((res = cs_listen_check(line, 0, 0, control_block.check_ip,
900                                    control_block.daemon_name)) < 0)
901         {
902             yaz_log(YLOG_WARN|YLOG_ERRNO, "cs_listen failed");
903             return;
904         }
905         else if (res == 1)
906         {
907             yaz_log(YLOG_WARN, "cs_listen incomplete");
908             return;
909         }
910         new_line = cs_accept(line);
911         if (!new_line)
912         {
913             yaz_log(YLOG_FATAL, "Accept failed.");
914             iochan_setflags(h, EVENT_INPUT | EVENT_EXCEPT); /* reset listener */
915             return;
916         }
917
918         if (control_block.one_shot)
919             remove_listeners();
920
921         yaz_log(log_sessiondetail, "Connect from %s", cs_addrstr(new_line));
922
923         no_sessions++;
924         if (control_block.dynamic)
925         {
926             if ((res = fork()) < 0)
927             {
928                 yaz_log(YLOG_FATAL|YLOG_ERRNO, "fork");
929                 iochan_destroy(h);
930                 return;
931             }
932             else if (res == 0) /* child */
933             {
934                 char nbuf[100];
935                 IOCHAN pp;
936
937                 for (pp = pListener; pp; pp = iochan_getnext(pp))
938                 {
939                     COMSTACK l = (COMSTACK)iochan_getdata(pp);
940                     cs_close(l);
941                     iochan_destroy(pp);
942                 }
943                 sprintf(nbuf, "%s(%d)", me, no_sessions);
944                 yaz_log_init_prefix(nbuf);
945                 /* ensure that bend_stop is not called when each child exits -
946                    only for the main process ..  */
947                 control_block.bend_stop = 0;
948             }
949             else /* parent */
950             {
951                 cs_close(new_line);
952                 return;
953             }
954         }
955
956         if (control_block.threads)
957         {
958 #if YAZ_POSIX_THREADS
959             pthread_t child_thread;
960             pthread_create(&child_thread, 0, new_session, new_line);
961             pthread_detach(child_thread);
962 #else
963             new_session(new_line);
964 #endif
965         }
966         else
967             new_session(new_line);
968     }
969     else if (event == EVENT_TIMEOUT)
970     {
971         yaz_log(log_server, "Shutting down listener.");
972         iochan_destroy(h);
973     }
974     else
975     {
976         yaz_log(YLOG_FATAL, "Bad event on listener.");
977         iochan_destroy(h);
978     }
979 }
980
981 static void *new_session(void *vp)
982 {
983     const char *a;
984     association *newas;
985     IOCHAN new_chan;
986     COMSTACK new_line = (COMSTACK) vp;
987     IOCHAN parent_chan = (IOCHAN) new_line->user;
988
989     unsigned cs_get_mask, cs_accept_mask, mask =
990         ((new_line->io_pending & CS_WANT_WRITE) ? EVENT_OUTPUT : 0) |
991         ((new_line->io_pending & CS_WANT_READ) ? EVENT_INPUT : 0);
992
993     if (mask)
994     {
995         cs_accept_mask = mask;  /* accept didn't complete */
996         cs_get_mask = 0;
997     }
998     else
999     {
1000         cs_accept_mask = 0;     /* accept completed.  */
1001         cs_get_mask = mask = EVENT_INPUT;
1002     }
1003
1004     if (!(new_chan = iochan_create(cs_fileno(new_line), ir_session, mask,
1005                                    parent_chan->chan_id)))
1006     {
1007         yaz_log(YLOG_FATAL, "Failed to create iochan");
1008         return 0;
1009     }
1010     if (!(newas = create_association(new_chan, new_line,
1011                                      control_block.apdufile)))
1012     {
1013         yaz_log(YLOG_FATAL, "Failed to create new assoc.");
1014         return 0;
1015     }
1016     newas->cs_accept_mask = cs_accept_mask;
1017     newas->cs_get_mask = cs_get_mask;
1018
1019     iochan_setdata(new_chan, newas);
1020     iochan_settimeout(new_chan, 60);
1021 #if 1
1022     a = cs_addrstr(new_line);
1023 #else
1024     a = 0;
1025 #endif
1026     yaz_log_xml_errors(0, YLOG_WARN);
1027     yaz_log(log_session, "Session - OK %d %s PID=%ld",
1028             no_sessions, a ? a : "[Unknown]", (long) getpid());
1029     if (max_sessions && no_sessions >= max_sessions)
1030         control_block.one_shot = 1;
1031     if (control_block.threads)
1032     {
1033         iochan_event_loop(&new_chan);
1034     }
1035     else
1036     {
1037         new_chan->next = pListener;
1038         pListener = new_chan;
1039     }
1040     return 0;
1041 }
1042
1043 /* UNIX */
1044 #endif
1045
1046 static void inetd_connection(int what)
1047 {
1048     COMSTACK line;
1049     IOCHAN chan;
1050     association *assoc;
1051     const char *addr;
1052
1053     if ((line = cs_createbysocket(0, tcpip_type, 0, what)))
1054     {
1055         if ((chan = iochan_create(cs_fileno(line), ir_session, EVENT_INPUT,
1056                                   0)))
1057         {
1058             if ((assoc = create_association(chan, line,
1059                                             control_block.apdufile)))
1060             {
1061                 iochan_setdata(chan, assoc);
1062                 iochan_settimeout(chan, 60);
1063                 addr = cs_addrstr(line);
1064                 yaz_log(log_sessiondetail, "Inetd association from %s",
1065                         addr ? addr : "[UNKNOWN]");
1066                 assoc->cs_get_mask = EVENT_INPUT;
1067             }
1068             else
1069             {
1070                 yaz_log(YLOG_FATAL, "Failed to create association structure");
1071             }
1072             chan->next = pListener;
1073             pListener = chan;
1074         }
1075         else
1076         {
1077             yaz_log(YLOG_FATAL, "Failed to create iochan");
1078         }
1079     }
1080     else
1081     {
1082         yaz_log(YLOG_ERRNO|YLOG_FATAL, "Failed to create comstack on socket 0");
1083     }
1084 }
1085
1086 /*
1087  * Set up a listening endpoint, and give it to the event-handler.
1088  */
1089 static int add_listener(char *where, int listen_id)
1090 {
1091     COMSTACK l;
1092     void *ap;
1093     IOCHAN lst = NULL;
1094     const char *mode;
1095
1096     if (control_block.dynamic)
1097         mode = "dynamic";
1098     else if (control_block.threads)
1099         mode = "threaded";
1100     else
1101         mode = "static";
1102
1103     yaz_log(log_server, "Adding %s listener on %s id=%d PID=%ld", mode, where,
1104             listen_id, (long) getpid());
1105
1106     l = cs_create_host(where, 2, &ap);
1107     if (!l)
1108     {
1109         yaz_log(YLOG_FATAL, "Failed to listen on %s", where);
1110         return -1;
1111     }
1112     if (*control_block.cert_fname)
1113         cs_set_ssl_certificate_file(l, control_block.cert_fname);
1114
1115     if (cs_bind(l, ap, CS_SERVER) < 0)
1116     {
1117         if (cs_errno(l) == CSYSERR)
1118             yaz_log(YLOG_FATAL|YLOG_ERRNO, "Failed to bind to %s", where);
1119         else
1120             yaz_log(YLOG_FATAL, "Failed to bind to %s: %s", where,
1121                     cs_strerror(l));
1122         cs_close(l);
1123         return -1;
1124     }
1125     if (!(lst = iochan_create(cs_fileno(l), listener, EVENT_INPUT |
1126                               EVENT_EXCEPT, listen_id)))
1127     {
1128         yaz_log(YLOG_FATAL|YLOG_ERRNO, "Failed to create IOCHAN-type");
1129         cs_close(l);
1130         return -1;
1131     }
1132     iochan_setdata(lst, l); /* user-defined data for listener is COMSTACK */
1133     l->user = lst;  /* user-defined data for COMSTACK is listener chan */
1134
1135     /* Add listener to chain */
1136     lst->next = pListener;
1137     pListener = lst;
1138     return 0; /* OK */
1139 }
1140
1141 static void remove_listeners(void)
1142 {
1143     IOCHAN l = pListener;
1144     for (; l; l = l->next)
1145         iochan_destroy(l);
1146 }
1147
1148 #ifndef WIN32
1149 /* UNIX only (for windows we don't need to catch the signals) */
1150 static void catchchld(int num)
1151 {
1152     while (waitpid(-1, 0, WNOHANG) > 0)
1153         ;
1154     signal(SIGCHLD, catchchld);
1155 }
1156 #endif
1157
1158 statserv_options_block *statserv_getcontrol(void)
1159 {
1160 #ifdef WIN32
1161     if (init_control_tls)
1162         return (statserv_options_block *) TlsGetValue(current_control_tls);
1163     else
1164         return &control_block;
1165 #elif YAZ_POSIX_THREADS
1166     if (init_control_tls)
1167         return (statserv_options_block *)
1168             pthread_getspecific(current_control_tls);
1169     else
1170         return &control_block;
1171 #else
1172     if (current_control_block)
1173         return current_control_block;
1174     return &control_block;
1175 #endif
1176 }
1177
1178 void statserv_setcontrol(statserv_options_block *block)
1179 {
1180     if (gfs_root_dir[0])
1181     {
1182         if (chdir(gfs_root_dir))
1183             yaz_log(YLOG_WARN|YLOG_ERRNO, "chdir %s", gfs_root_dir);
1184     }
1185 #ifdef WIN32
1186     if (init_control_tls)
1187         TlsSetValue(current_control_tls, block);
1188 #elif YAZ_POSIX_THREADS
1189     if (init_control_tls)
1190         pthread_setspecific(current_control_tls, block);
1191 #else
1192     current_control_block = block;
1193 #endif
1194 }
1195
1196 static void statserv_reset(void)
1197 {
1198 }
1199
1200 static void daemon_handler(void *data)
1201 {
1202     IOCHAN *pListener = data;
1203     iochan_event_loop(pListener);
1204 }
1205
1206 #ifndef WIN32
1207 static void normal_stop_handler(int num)
1208 {
1209     yaz_log(log_server, "Received SIGTERM. PID=%ld", (long) getpid());
1210     exit(0);
1211 }
1212 #endif
1213
1214 static int statserv_sc_main(yaz_sc_t s, int argc, char **argv)
1215 {
1216     char sep;
1217 #ifdef WIN32
1218     /* We need to initialize the thread list */
1219     ThreadList_Initialize();
1220 /* WIN32 */
1221 #endif
1222
1223
1224 #ifdef WIN32
1225     sep = '\\';
1226 #else
1227     sep = '/';
1228 #endif
1229     if ((me = strrchr(argv[0], sep)))
1230         me++; /* get the basename */
1231     else
1232         me = argv[0];
1233     programname = argv[0];
1234
1235     if (control_block.options_func(argc, argv))
1236         return 1;
1237
1238     xml_config_open();
1239
1240     xml_config_bend_start();
1241
1242     if (control_block.inetd)
1243     {
1244 #ifdef WIN32
1245         ; /* no inetd on Windows */
1246 #else
1247         inetd_connection(control_block.default_proto);
1248 #endif
1249     }
1250     else
1251     {
1252         xml_config_add_listeners();
1253
1254         if (!pListener)
1255             add_listener("tcp:@:9999", 0);
1256
1257 #ifndef WIN32
1258         if (control_block.dynamic)
1259             signal(SIGCHLD, catchchld);
1260 #endif
1261     }
1262     if (pListener == NULL)
1263         return 1;
1264     if (s)
1265         yaz_sc_running(s);
1266
1267 #ifndef WIN32
1268     signal(SIGTERM, normal_stop_handler);
1269 #endif
1270     yaz_daemon(programname,
1271                (control_block.background ? YAZ_DAEMON_FORK : 0),
1272                daemon_handler, &pListener,
1273                *control_block.pid_fname ? control_block.pid_fname : 0,
1274                *control_block.setuid ? control_block.setuid : 0);
1275     return 0;
1276 }
1277
1278 static void option_copy(char *dst, const char *src)
1279 {
1280     strncpy(dst, src ? src : "", BEND_NAME_MAX-1);
1281     dst[BEND_NAME_MAX-1] = '\0';
1282 }
1283
1284 int check_options(int argc, char **argv)
1285 {
1286     int ret = 0, r;
1287     char *arg;
1288
1289     yaz_log_init_level(yaz_log_mask_str(STAT_DEFAULT_LOG_LEVEL));
1290
1291     get_logbits(1);
1292
1293     while ((ret = options("1a:iszSTl:v:u:c:w:t:k:Kd:A:p:DC:f:m:r:",
1294                           argv, argc, &arg)) != -2)
1295     {
1296         switch (ret)
1297         {
1298         case 0:
1299             if (add_listener(arg, 0))
1300                 return 1;  /* failed to create listener */
1301             break;
1302         case '1':
1303             control_block.one_shot = 1;
1304             control_block.dynamic = 0;
1305             break;
1306         case 'z':
1307             control_block.default_proto = PROTO_Z3950;
1308             break;
1309         case 's':
1310             fprintf(stderr, "%s: SR protocol no longer supported\n", me);
1311             exit(1);
1312             break;
1313         case 'S':
1314             control_block.dynamic = 0;
1315             break;
1316         case 'T':
1317 #if YAZ_POSIX_THREADS
1318             control_block.dynamic = 0;
1319             control_block.threads = 1;
1320 #else
1321             fprintf(stderr, "%s: Threaded mode not available.\n", me);
1322             return 1;
1323 #endif
1324             break;
1325         case 'l':
1326             option_copy(control_block.logfile, arg);
1327             yaz_log_init_file(control_block.logfile);
1328             break;
1329         case 'm':
1330             if (!arg) {
1331                 fprintf(stderr, "%s: Specify time format for log file.\n", me);
1332                 return(1);
1333             }
1334             yaz_log_time_format(arg);
1335             break;
1336         case 'v':
1337             yaz_log_init_level(yaz_log_mask_str(arg));
1338             get_logbits(1);
1339             break;
1340         case 'a':
1341             option_copy(control_block.apdufile, arg);
1342             break;
1343         case 'u':
1344             option_copy(control_block.setuid, arg);
1345             break;
1346         case 'c':
1347             option_copy(control_block.configname, arg);
1348             break;
1349         case 'C':
1350             option_copy(control_block.cert_fname, arg);
1351             break;
1352         case 'd':
1353             option_copy(control_block.daemon_name, arg);
1354             break;
1355         case 't':
1356             if (!arg || !(r = atoi(arg)))
1357             {
1358                 fprintf(stderr, "%s: Specify positive timeout for -t.\n", me);
1359                 return(1);
1360             }
1361             control_block.idle_timeout = strchr(arg, 's') ? r : 60 * r;
1362             break;
1363         case  'k':
1364             if (!arg || !(r = atoi(arg)))
1365             {
1366                 fprintf(stderr, "%s: Specify positive size for -k.\n", me);
1367                 return(1);
1368             }
1369             control_block.maxrecordsize = r * 1024;
1370             break;
1371         case 'K':
1372             control_block.keepalive = 0;
1373             break;
1374         case 'i':
1375             control_block.inetd = 1;
1376             break;
1377         case 'w':
1378             if (chdir(arg))
1379             {
1380                 perror(arg);
1381                 return 1;
1382             }
1383             break;
1384         case 'A':
1385             max_sessions = atoi(arg);
1386             break;
1387         case 'p':
1388             option_copy(control_block.pid_fname, arg);
1389             break;
1390         case 'f':
1391 #if YAZ_HAVE_XML2
1392             option_copy(control_block.xml_config, arg);
1393 #else
1394             fprintf(stderr, "%s: Option -f unsupported since YAZ is compiled without Libxml2 support\n", me);
1395             exit(1);
1396 #endif
1397             break;
1398         case 'D':
1399             control_block.background = 1;
1400             break;
1401         case 'r':
1402             if (!arg || !(r = atoi(arg)))
1403             {
1404                 fprintf(stderr, "%s: Specify positive size for -r.\n", me);
1405                 return(1);
1406             }
1407             yaz_log_init_max_size(r * 1024);
1408             break;
1409         default:
1410             fprintf(stderr, "Usage: %s [ -a <pdufile> -v <loglevel>"
1411                     " -l <logfile> -u <user> -c <config> -t <minutes>"
1412                     " -k <kilobytes> -d <daemon> -p <pidfile> -C certfile"
1413                     " -zKiDST1 -m <time-format> -w <directory> <listener-addr>... ]\n", me);
1414             return 1;
1415         }
1416     }
1417     return 0;
1418 }
1419
1420 void statserv_sc_stop(yaz_sc_t s)
1421 {
1422     statserv_closedown();
1423     statserv_reset();
1424 }
1425
1426 int statserv_main(int argc, char **argv,
1427                   bend_initresult *(*bend_init)(bend_initrequest *r),
1428                   void (*bend_close)(void *handle))
1429 {
1430     int ret;
1431     struct statserv_options_block *cb = &control_block;
1432
1433     /* control block does not have service_name member on Unix */
1434     yaz_sc_t s = yaz_sc_create(
1435 #ifdef WIN32
1436         cb->service_name, cb->service_display_name
1437 #else
1438         0, 0
1439 #endif
1440         );
1441
1442     cb->bend_init = bend_init;
1443     cb->bend_close = bend_close;
1444
1445     ret = yaz_sc_program(s, argc, argv, statserv_sc_main, statserv_sc_stop);
1446     yaz_sc_destroy(&s);
1447     return ret;
1448 }
1449
1450 /*
1451  * Local variables:
1452  * c-basic-offset: 4
1453  * c-file-style: "Stroustrup"
1454  * indent-tabs-mode: nil
1455  * End:
1456  * vim: shiftwidth=4 tabstop=8 expandtab
1457  */
1458