ea849c92b1d3a2326b6da4808e178c0456426792
[OpenSRF.git] / src / libopensrf / osrf_prefork.c
1 #include <signal.h>
2 #include <sys/types.h>
3 #include <sys/time.h>
4 #include <unistd.h>
5 #include <stdlib.h>
6 #include <stdio.h>
7 #include <string.h>
8 #include <sys/select.h>
9 #include <sys/wait.h>
10
11 #include "opensrf/utils.h"
12 #include "opensrf/log.h"
13 #include "opensrf/transport_client.h"
14 #include "opensrf/osrf_stack.h"
15 #include "opensrf/osrf_settings.h"
16 #include "opensrf/osrf_application.h"
17
18 #define READ_BUFSIZE 1024
19 #define ABS_MAX_CHILDREN 256
20
21 typedef struct {
22         int max_requests;
23         int min_children;
24         int max_children;
25         int fd;               /**< Unused. */
26         int data_to_child;    /**< Unused. */
27         int data_to_parent;   /**< Unused. */
28         int current_num_children;
29         int keepalive;        /**< keepalive time for stateful sessions. */
30         char* appname;
31         struct prefork_child_struct* first_child;
32         transport_client* connection;
33 } prefork_simple;
34
35 struct prefork_child_struct {
36         pid_t pid;
37         int read_data_fd;
38         int write_data_fd;
39         int read_status_fd;
40         int write_status_fd;
41         int min_children;
42         int available;
43         int max_requests;
44         char* appname;
45         int keepalive;
46         struct prefork_child_struct* next;
47 };
48
49 typedef struct prefork_child_struct prefork_child;
50
51 static int prefork_simple_init( prefork_simple* prefork, transport_client* client,
52         int max_requests, int min_children, int max_children );
53 static prefork_child* launch_child( prefork_simple* forker );
54 static void prefork_launch_children( prefork_simple* forker );
55 static void prefork_run(prefork_simple* forker);
56 static void add_prefork_child( prefork_simple* forker, prefork_child* child );
57
58 //static prefork_child* find_prefork_child( prefork_simple* forker, pid_t pid );
59
60 static void del_prefork_child( prefork_simple* forker, pid_t pid );
61 static void check_children( prefork_simple* forker, int forever );
62 static void prefork_child_process_request(prefork_child*, char* data);
63 static int prefork_child_init_hook(prefork_child*);
64 static prefork_child* prefork_child_init(
65                 int max_requests, int read_data_fd, int write_data_fd,
66                 int read_status_fd, int write_status_fd );
67
68 /* listens on the 'data_to_child' fd and wait for incoming data */
69 static void prefork_child_wait( prefork_child* child );
70 static void prefork_clear( prefork_simple* );
71 static int prefork_child_free( prefork_child* );
72 static void osrf_prefork_register_routers( const char* appname );
73 static void osrf_prefork_child_exit( prefork_child* );
74
75
76 /* true if we just deleted a child.  This will allow us to make sure we're
77         not trying to use freed memory */
78 static sig_atomic_t child_dead;
79
80 static void sigchld_handler( int sig );
81
82 int osrf_prefork_run(const char* appname) {
83
84         if(!appname) {
85                 osrfLogError( OSRF_LOG_MARK, "osrf_prefork_run requires an appname to run!");
86                 return -1;
87         }
88
89         set_proc_title( "OpenSRF Listener [%s]", appname );
90
91         int maxr = 1000;
92         int maxc = 10;
93         int minc = 3;
94         int kalive = 5;
95
96         osrfLogInfo( OSRF_LOG_MARK, "Loading config in osrf_forker for app %s", appname);
97
98         char* max_req      = osrf_settings_host_value("/apps/%s/unix_config/max_requests", appname);
99         char* min_children = osrf_settings_host_value("/apps/%s/unix_config/min_children", appname);
100         char* max_children = osrf_settings_host_value("/apps/%s/unix_config/max_children", appname);
101         char* keepalive    = osrf_settings_host_value("/apps/%s/keepalive", appname);
102
103         if(!keepalive) osrfLogWarning( OSRF_LOG_MARK, "Keepalive is not defined, assuming %d", kalive);
104         else kalive = atoi(keepalive);
105
106         if(!max_req) osrfLogWarning( OSRF_LOG_MARK, "Max requests not defined, assuming %d", maxr);
107         else maxr = atoi(max_req);
108
109         if(!min_children) osrfLogWarning( OSRF_LOG_MARK,
110                         "Min children not defined, assuming %d", minc);
111         else minc = atoi(min_children);
112
113         if(!max_children) osrfLogWarning( OSRF_LOG_MARK,
114                         "Max children not defined, assuming %d", maxc);
115         else maxc = atoi(max_children);
116
117         free(keepalive);
118         free(max_req);
119         free(min_children);
120         free(max_children);
121         /* --------------------------------------------------- */
122
123         char* resc = va_list_to_string("%s_listener", appname);
124
125         if(!osrfSystemBootstrapClientResc( NULL, NULL, resc )) {
126                 osrfLogError( OSRF_LOG_MARK, "Unable to bootstrap client for osrf_prefork_run()");
127                 free(resc);
128                 return -1;
129         }
130
131         free(resc);
132
133         prefork_simple forker;
134
135         if( prefork_simple_init( &forker, osrfSystemGetTransportClient(), maxr, minc, maxc ) ) {
136                 osrfLogError( OSRF_LOG_MARK,
137                                 "osrf_prefork_run() failed to create prefork_simple object" );
138                 return -1;
139         }
140
141         // Finish initializing the prefork_simple
142         forker.appname   = strdup(appname);
143         forker.keepalive = kalive;
144
145         // Spawn the children
146         prefork_launch_children( &forker );
147
148         // Tell the router that you're open for business
149         osrf_prefork_register_routers(appname);
150
151         // Sit back and let the requests roll in
152         osrfLogInfo( OSRF_LOG_MARK, "Launching osrf_forker for app %s", appname);
153         prefork_run( &forker );
154
155         osrfLogWarning( OSRF_LOG_MARK, "prefork_run() retuned - how??");
156         prefork_clear( &forker );
157         return 0;
158 }
159
160 /**
161         @brief Register the application with a specified router.
162         @param appname Name of the application.
163         @param routerName Name of the router.
164         @param routerDomain Domain of the router.
165
166         Tell the router that you're open for business so that it can route requests to you.
167 */
168 static void osrf_prefork_send_router_registration(
169                 const char* appname, const char* routerName, const char* routerDomain ) {
170         // Get a pointer to the global transport_client
171         transport_client* client = osrfSystemGetTransportClient();
172
173         // Construct the Jabber address of the router
174         char* jid = va_list_to_string( "%s@%s/router", routerName, routerDomain );
175         osrfLogInfo( OSRF_LOG_MARK, "%s registering with router %s", appname, jid );
176
177         // Create the registration message, and send it
178         transport_message* msg = message_init("registering", NULL, NULL, jid, NULL );
179         message_set_router_info( msg, NULL, NULL, appname, "register", 0 );
180         client_send_message( client, msg );
181
182         // Clean up
183         message_free( msg );
184         free(jid);
185 }
186
187 /** parses a single "complex" router configuration chunk */
188 static void osrf_prefork_parse_router_chunk(const char* appname, jsonObject* routerChunk) {
189
190         const char* routerName = jsonObjectGetString(jsonObjectGetKeyConst(routerChunk, "name"));
191         const char* domain = jsonObjectGetString(jsonObjectGetKeyConst(routerChunk, "domain"));
192         const jsonObject* services = jsonObjectGetKeyConst(routerChunk, "services");
193         osrfLogDebug(OSRF_LOG_MARK, "found router config with domain %s and name %s",
194                         routerName, domain);
195
196         if( services && services->type == JSON_HASH ) {
197                 osrfLogDebug(OSRF_LOG_MARK, "investigating router information...");
198                 const jsonObject* service_obj = jsonObjectGetKeyConst(services, "service");
199                 if( !service_obj )
200                         ;    // do nothing (shouldn't happen)
201                 else if( JSON_ARRAY == service_obj->type ) {
202                         int j;
203                         for(j = 0; j < service_obj->size; j++ ) {
204                                 const char* service = jsonObjectGetString(jsonObjectGetIndex(service_obj, j));
205                                 if( service && !strcmp( appname, service ))
206                                         osrf_prefork_send_router_registration(appname, routerName, domain);
207                         }
208                 }
209                 else if( JSON_STRING == service_obj->type ) {
210                         if( !strcmp(appname, jsonObjectGetString( service_obj )) )
211                                 osrf_prefork_send_router_registration(appname, routerName, domain);
212                 }
213         } else {
214                 osrf_prefork_send_router_registration(appname, routerName, domain);
215         }
216 }
217
218 static void osrf_prefork_register_routers( const char* appname ) {
219
220         jsonObject* routerInfo = osrfConfigGetValueObject(NULL, "/routers/router");
221
222         int i;
223         for(i = 0; i < routerInfo->size; i++) {
224                 jsonObject* routerChunk = jsonObjectGetIndex(routerInfo, i);
225
226                 if(routerChunk->type == JSON_STRING) {
227                         /* this accomodates simple router configs */
228                         char* routerName = osrfConfigGetValue( NULL, "/router_name" );
229                         char* domain = osrfConfigGetValue(NULL, "/routers/router");
230                         osrfLogDebug(OSRF_LOG_MARK, "found simple router settings with router name %s",
231                                         routerName);
232                         osrf_prefork_send_router_registration(appname, routerName, domain);
233
234                 } else {
235                         osrf_prefork_parse_router_chunk(appname, routerChunk);
236                 }
237         }
238 }
239
240 static int prefork_child_init_hook(prefork_child* child) {
241
242         if(!child) return -1;
243         osrfLogDebug( OSRF_LOG_MARK, "Child init hook for child %d", child->pid);
244
245         osrfSystemInitCache();
246         char* resc = va_list_to_string("%s_drone",child->appname);
247
248         /* if we're a source-client, tell the logger now that we're a new process*/
249         char* isclient = osrfConfigGetValue(NULL, "/client");
250         if( isclient && !strcasecmp(isclient,"true") )
251                 osrfLogSetIsClient(1);
252         free(isclient);
253
254         /* we want to remove traces of our parents socket connection
255         * so we can have our own */
256         osrfSystemIgnoreTransportClient();
257
258         if(!osrfSystemBootstrapClientResc( NULL, NULL, resc)) {
259                 osrfLogError( OSRF_LOG_MARK, "Unable to bootstrap client for osrf_prefork_run()");
260                 free(resc);
261                 return -1;
262         }
263
264         free(resc);
265
266         if( ! osrfAppRunChildInit(child->appname) ) {
267                 osrfLogDebug(OSRF_LOG_MARK, "Prefork child_init succeeded\n");
268         } else {
269                 osrfLogError(OSRF_LOG_MARK, "Prefork child_init failed\n");
270                 return -1;
271         }
272
273         set_proc_title( "OpenSRF Drone [%s]", child->appname );
274         return 0;
275 }
276
277 static void prefork_child_process_request(prefork_child* child, char* data) {
278         if( !child ) return;
279
280         transport_client* client = osrfSystemGetTransportClient();
281
282         if(!client_connected(client)) {
283                 osrfSystemIgnoreTransportClient();
284                 osrfLogWarning(OSRF_LOG_MARK, "Reconnecting child to opensrf after disconnect...");
285                 if(!osrf_system_bootstrap_client(NULL, NULL)) {
286                         osrfLogError( OSRF_LOG_MARK,
287                                 "Unable to bootstrap client in prefork_child_process_request()");
288                         sleep(1);
289                         osrf_prefork_child_exit(child);
290                 }
291         }
292
293         /* construct the message from the xml */
294         transport_message* msg = new_message_from_xml( data );
295
296         osrfAppSession* session = osrf_stack_transport_handler(msg, child->appname);
297         if(!session) return;
298
299         if( session->stateless && session->state != OSRF_SESSION_CONNECTED ) {
300                 osrfAppSessionFree( session );
301                 return;
302         }
303
304         osrfLogDebug( OSRF_LOG_MARK, "Entering keepalive loop for session %s", session->session_id );
305         int keepalive = child->keepalive;
306         int retval;
307         int recvd;
308         time_t start;
309         time_t end;
310
311         while(1) {
312
313                 osrfLogDebug(OSRF_LOG_MARK,
314                                 "osrf_prefork calling queue_wait [%d] in keepalive loop", keepalive);
315                 start   = time(NULL);
316                 retval  = osrf_app_session_queue_wait(session, keepalive, &recvd);
317                 end     = time(NULL);
318
319                 osrfLogDebug(OSRF_LOG_MARK, "Data received == %d", recvd);
320
321                 if(retval) {
322                         osrfLogError(OSRF_LOG_MARK, "queue-wait returned non-success %d", retval);
323                         break;
324                 }
325
326                 /* see if the client disconnected from us */
327                 if(session->state != OSRF_SESSION_CONNECTED) break;
328
329                 /* if no data was reveived within the timeout interval */
330                 if( !recvd && (end - start) >= keepalive ) {
331                         osrfLogInfo(OSRF_LOG_MARK,
332                                         "No request was received in %d seconds, exiting stateful session", keepalive);
333                         osrfAppSessionStatus(
334                                         session,
335                                         OSRF_STATUS_TIMEOUT,
336                                         "osrfConnectStatus",
337                                         0, "Disconnected on timeout" );
338
339                         break;
340                 }
341         }
342
343         osrfLogDebug( OSRF_LOG_MARK, "Exiting keepalive loop for session %s", session->session_id );
344         osrfAppSessionFree( session );
345         return;
346 }
347
348
349 /**
350         @brief Partially initialize a prefork_simple provided by the caller.
351         @param prefork Pointer to a a raw prefork_simple to be initialized.
352         @param client Pointer to a transport_client (connection to Jabber).
353         @param max_requests
354         @param min_children Minimum number of child processes to maintain.
355         @param max_children Maximum number of child processes to maintain.
356         @return 0 if successful, or 1 if not (due to invalid parameters).
357 */
358 static int prefork_simple_init( prefork_simple* prefork, transport_client* client,
359                  int max_requests, int min_children, int max_children ) {
360
361         if( min_children > max_children ) {
362                 osrfLogError( OSRF_LOG_MARK,  "min_children (%d) is greater "
363                                 "than max_children (%d)", min_children, max_children );
364                 return 1;
365         }
366
367         if( max_children > ABS_MAX_CHILDREN ) {
368                 osrfLogError( OSRF_LOG_MARK,  "max_children (%d) is greater than ABS_MAX_CHILDREN (%d)",
369                                 max_children, ABS_MAX_CHILDREN );
370                 return 1;
371         }
372
373         osrfLogInfo(OSRF_LOG_MARK, "Prefork launching child with max_request=%d,"
374                 "min_children=%d, max_children=%d", max_requests, min_children, max_children );
375
376         /* flesh out the struct */
377         //prefork_simple* prefork = safe_malloc(sizeof(prefork_simple));
378         prefork->max_requests = max_requests;
379         prefork->min_children = min_children;
380         prefork->max_children = max_children;
381         prefork->fd           = 0;
382         prefork->data_to_child = 0;
383         prefork->data_to_parent = 0;
384         prefork->current_num_children = 0;
385         prefork->keepalive    = 0;
386         prefork->appname      = NULL;
387         prefork->first_child  = NULL;
388         prefork->connection   = client;
389
390         return 0;
391 }
392
393 static prefork_child* launch_child( prefork_simple* forker ) {
394
395         pid_t pid;
396         int data_fd[2];
397         int status_fd[2];
398
399         /* Set up the data pipes and add the child struct to the parent */
400         if( pipe(data_fd) < 0 ) { /* build the data pipe*/
401                 osrfLogError( OSRF_LOG_MARK,  "Pipe making error" );
402                 return NULL;
403         }
404
405         if( pipe(status_fd) < 0 ) {/* build the status pipe */
406                 osrfLogError( OSRF_LOG_MARK,  "Pipe making error" );
407                 return NULL;
408         }
409
410         osrfLogInternal( OSRF_LOG_MARK,  "Pipes: %d %d %d %d",
411                         data_fd[0], data_fd[1], status_fd[0], status_fd[1] );
412         prefork_child* child = prefork_child_init( forker->max_requests, data_fd[0],
413                         data_fd[1], status_fd[0], status_fd[1] );
414
415         child->appname = strdup(forker->appname);
416         child->keepalive = forker->keepalive;
417
418
419         add_prefork_child( forker, child );
420
421         if( (pid=fork()) < 0 ) {
422                 osrfLogError( OSRF_LOG_MARK,  "Forking Error" );
423                 return NULL;
424         }
425
426         if( pid > 0 ) {  /* parent */
427
428                 signal(SIGCHLD, sigchld_handler);
429                 (forker->current_num_children)++;
430                 child->pid = pid;
431
432                 osrfLogDebug( OSRF_LOG_MARK,  "Parent launched %d", pid );
433                 /* *no* child pipe FD's can be closed or the parent will re-use fd's that
434                         the children are currently using */
435                 return child;
436         }
437
438         else { /* child */
439
440                 osrfLogInternal( OSRF_LOG_MARK,
441                                 "I am  new child with read_data_fd = %d and write_status_fd = %d",
442                                 child->read_data_fd, child->write_status_fd );
443
444                 child->pid = getpid();
445                 close( child->write_data_fd );
446                 close( child->read_status_fd );
447
448                 /* do the initing */
449                 if( prefork_child_init_hook(child) == -1 ) {
450                         osrfLogError(OSRF_LOG_MARK,
451                                 "Forker child going away because we could not connect to OpenSRF...");
452                         osrf_prefork_child_exit(child);
453                 }
454
455                 prefork_child_wait( child );
456                 osrf_prefork_child_exit(child); /* just to be sure */
457         }
458         return NULL;
459 }
460
461 static void osrf_prefork_child_exit(prefork_child* child) {
462         osrfAppRunExitCode();
463         exit(0);
464 }
465
466 static void prefork_launch_children( prefork_simple* forker ) {
467         if(!forker) return;
468         int c = 0;
469         while( c++ < forker->min_children )
470                 launch_child( forker );
471 }
472
473
474 static void sigchld_handler( int sig ) {
475         signal(SIGCHLD, sigchld_handler);
476         child_dead = 1;
477 }
478
479
480 void reap_children( prefork_simple* forker ) {
481
482         pid_t child_pid;
483         int status;
484
485         while( (child_pid=waitpid(-1,&status,WNOHANG)) > 0)
486                 del_prefork_child( forker, child_pid );
487
488         /* replenish */
489         while( forker->current_num_children < forker->min_children )
490                 launch_child( forker );
491
492         child_dead = 0;
493 }
494
495 static void prefork_run(prefork_simple* forker) {
496
497         if( forker->first_child == NULL )
498                 return;
499
500         transport_message* cur_msg = NULL;
501
502
503         while(1) {
504
505                 if( forker->first_child == NULL ) {/* no more children */
506                         osrfLogWarning( OSRF_LOG_MARK, "No more children..." );
507                         return;
508                 }
509
510                 // Wait indefinitely for an input message
511                 osrfLogDebug( OSRF_LOG_MARK, "Forker going into wait for data...");
512                 cur_msg = client_recv( forker->connection, -1 );
513
514                 if( cur_msg == NULL )
515                         continue;           // Error?  Interrupted by a signal?
516
517                 int honored = 0;     /* will be set to true when we service the request */
518                 int no_recheck = 0;
519
520                 while( ! honored ) {
521
522                         if(!no_recheck)
523                                 check_children( forker, 0 );
524                         no_recheck = 0;
525
526                         osrfLogDebug( OSRF_LOG_MARK, "Server received inbound data" );
527                         int k;
528                         prefork_child* cur_child = forker->first_child;
529
530                         /* Look for an available child */
531                         for( k = 0; k < forker->current_num_children; k++ ) {
532
533                                 osrfLogInternal( OSRF_LOG_MARK,
534                                                 "Searching for available child. cur_child->pid = %d", cur_child->pid );
535                                 osrfLogInternal( OSRF_LOG_MARK, "Current num children %d and loop %d",
536                                                 forker->current_num_children, k);
537
538                                 if( cur_child->available ) {
539                                         osrfLogDebug( OSRF_LOG_MARK, "forker sending data to %d", cur_child->pid );
540
541                                         message_prepare_xml( cur_msg );
542                                         char* data = cur_msg->msg_xml;
543                                         if( ! data || strlen(data) < 1 ) break;
544
545                                         cur_child->available = 0;
546                                         osrfLogInternal( OSRF_LOG_MARK, "Writing to child fd %d",
547                                                         cur_child->write_data_fd );
548
549                                         int written = 0;
550                                         if( (written = write( cur_child->write_data_fd, data, strlen(data) + 1 )) < 0 ) {
551                                                 osrfLogWarning( OSRF_LOG_MARK, "Write returned error %d", errno);
552                                                 cur_child = cur_child->next;
553                                                 continue;
554                                         }
555
556                                         forker->first_child = cur_child->next;
557                                         honored = 1;
558                                         break;
559                                 } else
560                                         cur_child = cur_child->next;
561                         }
562
563                         /* if none available, add a new child if we can */
564                         if( ! honored ) {
565                                 osrfLogDebug( OSRF_LOG_MARK, "Not enough children, attempting to add...");
566
567                                 if( forker->current_num_children < forker->max_children ) {
568                                         osrfLogDebug( OSRF_LOG_MARK,  "Launching new child with current_num = %d",
569                                                         forker->current_num_children );
570
571                                         prefork_child* new_child = launch_child( forker );
572                                         if( new_child ) {
573
574                                                 message_prepare_xml( cur_msg );
575                                                 char* data = cur_msg->msg_xml;
576
577                                                 if( data ) {
578                                                         int len = strlen(data);
579
580                                                         if( len > 0 ) {
581                                                                 new_child->available = 0;
582                                                                 osrfLogDebug( OSRF_LOG_MARK, "Writing to new child fd %d : pid %d",
583                                                                                 new_child->write_data_fd, new_child->pid );
584
585                                                                 if( write( new_child->write_data_fd, data, len + 1 ) >= 0 ) {
586                                                                         forker->first_child = new_child->next;
587                                                                         honored = 1;
588                                                                 }
589                                                         }
590                                                 }
591                                         }
592
593                                 }
594                         }
595
596                         if( !honored ) {
597                                 osrfLogWarning( OSRF_LOG_MARK,  "No children available, waiting...");
598
599                                 check_children( forker, 1 );  /* non-poll version */
600                                 /* tell the loop not to call check_children again, since we're calling it now */
601                                 no_recheck = 1;
602                         }
603
604                         if( child_dead )
605                                 reap_children(forker);
606
607
608                         //fprintf(stderr, "Parent done with request %f\n", get_timestamp_millis() );
609
610                 } // honored?
611
612                 message_free( cur_msg );
613
614         } /* top level listen loop */
615
616 }
617
618
619 /** XXX Add a flag which tells select() to wait forever on children
620         in the best case, this will be faster than calling usleep(x), and
621         in the worst case it won't be slower and will do less logging...
622 */
623 static void check_children( prefork_simple* forker, int forever ) {
624
625         //check_begin:
626
627         int select_ret;
628         fd_set read_set;
629         FD_ZERO(&read_set);
630         int max_fd = 0;
631         int n;
632
633
634         if( child_dead )
635                 reap_children(forker);
636
637         prefork_child* cur_child = forker->first_child;
638
639         int i;
640         for( i = 0; i!= forker->current_num_children; i++ ) {
641
642                 if( cur_child->read_status_fd > max_fd )
643                         max_fd = cur_child->read_status_fd;
644                 FD_SET( cur_child->read_status_fd, &read_set );
645                 cur_child = cur_child->next;
646         }
647
648         FD_CLR(0,&read_set); /* just to be sure */
649
650         if( forever ) {
651                 osrfLogWarning(OSRF_LOG_MARK,
652                                 "We have no children available - waiting for one to show up...");
653
654                 if( (select_ret=select( max_fd + 1 , &read_set, NULL, NULL, NULL)) == -1 ) {
655                         osrfLogWarning( OSRF_LOG_MARK,  "Select returned error %d on check_children", errno );
656                 }
657                 osrfLogInfo(OSRF_LOG_MARK,
658                                 "select() completed after waiting on children to become available");
659
660         } else {
661
662                 struct timeval tv;
663                 tv.tv_sec   = 0;
664                 tv.tv_usec  = 0;
665
666                 if( (select_ret=select( max_fd + 1 , &read_set, NULL, NULL, &tv)) == -1 ) {
667                         osrfLogWarning( OSRF_LOG_MARK,  "Select returned error %d on check_children", errno );
668                 }
669         }
670
671         if( select_ret == 0 )
672                 return;
673
674         /* see if one of a child has told us it's done */
675         cur_child = forker->first_child;
676         int j;
677         int num_handled = 0;
678         for( j = 0; j!= forker->current_num_children && num_handled < select_ret ; j++ ) {
679
680                 if( FD_ISSET( cur_child->read_status_fd, &read_set ) ) {
681                         //printf( "Server received status from a child %d\n", cur_child->pid );
682                         osrfLogDebug( OSRF_LOG_MARK,
683                                         "Server received status from a child %d", cur_child->pid );
684
685                         num_handled++;
686
687                         /* now suck off the data */
688                         char buf[64];
689                         osrf_clearbuf( buf, sizeof(buf) );
690                         if( (n=read(cur_child->read_status_fd, buf, sizeof(buf) - 1)) < 0 ) {
691                                 osrfLogWarning( OSRF_LOG_MARK,
692                                                 "Read error after select in child status read with errno %d", errno);
693                         }
694                         else {
695                                 buf[n] = '\0';
696                                 osrfLogDebug( OSRF_LOG_MARK,  "Read %d bytes from status buffer: %s", n, buf );
697                         }
698                         cur_child->available = 1;
699                 }
700                 cur_child = cur_child->next;
701         }
702
703 }
704
705
706 static void prefork_child_wait( prefork_child* child ) {
707
708         int i,n;
709         growing_buffer* gbuf = buffer_init( READ_BUFSIZE );
710         char buf[READ_BUFSIZE];
711         osrf_clearbuf( buf, sizeof(buf) );
712
713         for( i = 0; i < child->max_requests; i++ ) {
714
715                 n = -1;
716                 int gotdata = 0;
717                 clr_fl(child->read_data_fd, O_NONBLOCK );
718
719                 while( (n=read(child->read_data_fd, buf, READ_BUFSIZE-1)) > 0 ) {
720                         buf[n] = '\0';
721                         osrfLogDebug(OSRF_LOG_MARK, "Prefork child read %d bytes of data", n);
722                         if(!gotdata)
723                                 set_fl(child->read_data_fd, O_NONBLOCK );
724                         buffer_add( gbuf, buf );
725                         osrf_clearbuf( buf, sizeof(buf) );
726                         gotdata = 1;
727                 }
728
729                 if( errno == EAGAIN ) n = 0;
730
731                 if( errno == EPIPE ) {
732                         osrfLogDebug(OSRF_LOG_MARK, "C child attempted read on broken pipe, exiting...");
733                         break;
734                 }
735
736                 if( n < 0 ) {
737                         osrfLogWarning( OSRF_LOG_MARK,
738                                         "Prefork child read returned error with errno %d", errno );
739                         break;
740
741                 } else if( gotdata ) {
742                         osrfLogDebug(OSRF_LOG_MARK, "Prefork child got a request.. processing..");
743                         prefork_child_process_request(child, gbuf->buf);
744                         buffer_reset( gbuf );
745                 }
746
747                 if( i < child->max_requests - 1 )
748                         write( child->write_status_fd, "available" /*less than 64 bytes*/, 9 );
749         }
750
751         buffer_free(gbuf);
752
753         osrfLogDebug( OSRF_LOG_MARK, "Child with max-requests=%d, num-served=%d exiting...[%ld]",
754                         child->max_requests, i, (long) getpid() );
755
756         osrf_prefork_child_exit(child); /* just to be sure */
757 }
758
759
760 static void add_prefork_child( prefork_simple* forker, prefork_child* child ) {
761
762         if( forker->first_child == NULL ) {
763                 forker->first_child = child;
764                 child->next = child;
765                 return;
766         }
767
768         /* we put the child in as the last because, regardless,
769                 we have to do the DLL splice dance, and this is the
770                 simplest way */
771
772         prefork_child* start_child = forker->first_child;
773         while(1) {
774                 if( forker->first_child->next == start_child )
775                         break;
776                 forker->first_child = forker->first_child->next;
777         }
778
779         /* here we know that forker->first_child is the last element
780                 in the list and start_child is the first.  Insert the
781                 new child between them*/
782
783         forker->first_child->next = child;
784         child->next = start_child;
785         return;
786 }
787
788 //static prefork_child* find_prefork_child( prefork_simple* forker, pid_t pid ) {
789 //
790 //  if( forker->first_child == NULL ) { return NULL; }
791 //  prefork_child* start_child = forker->first_child;
792 //  do {
793 //      if( forker->first_child->pid == pid )
794 //          return forker->first_child;
795 //  } while( (forker->first_child = forker->first_child->next) != start_child );
796 //
797 //  return NULL;
798 //}
799
800
801 static void del_prefork_child( prefork_simple* forker, pid_t pid ) {
802
803         if( forker->first_child == NULL ) { return; }
804
805         (forker->current_num_children)--;
806         osrfLogDebug( OSRF_LOG_MARK, "Deleting Child: %d", pid );
807
808         prefork_child* start_child = forker->first_child; /* starting point */
809         prefork_child* cur_child   = start_child; /* current pointer */
810         prefork_child* prev_child  = start_child; /* the trailing pointer */
811
812         /* special case where there is only one in the list */
813         if( start_child == start_child->next ) {
814                 if( start_child->pid == pid ) {
815                         forker->first_child = NULL;
816
817                         close( start_child->read_data_fd );
818                         close( start_child->write_data_fd );
819                         close( start_child->read_status_fd );
820                         close( start_child->write_status_fd );
821
822                         prefork_child_free( start_child );
823                 }
824                 return;
825         }
826
827
828         /* special case where the first item in the list needs to be removed */
829         if( start_child->pid == pid ) {
830
831                 /* find the last one so we can remove the start_child */
832                 do {
833                         prev_child = cur_child;
834                         cur_child = cur_child->next;
835                 } while( cur_child != start_child );
836
837                 /* now cur_child == start_child */
838                 prev_child->next = cur_child->next;
839                 forker->first_child = prev_child;
840
841                 close( cur_child->read_data_fd );
842                 close( cur_child->write_data_fd );
843                 close( cur_child->read_status_fd );
844                 close( cur_child->write_status_fd );
845
846                 prefork_child_free( cur_child );
847                 return;
848         }
849
850         do {
851                 prev_child = cur_child;
852                 cur_child = cur_child->next;
853
854                 if( cur_child->pid == pid ) {
855                         prev_child->next = cur_child->next;
856
857                         close( cur_child->read_data_fd );
858                         close( cur_child->write_data_fd );
859                         close( cur_child->read_status_fd );
860                         close( cur_child->write_status_fd );
861
862                         prefork_child_free( cur_child );
863                         return;
864                 }
865
866         } while(cur_child != start_child);
867 }
868
869
870
871
872 static prefork_child* prefork_child_init(
873         int max_requests, int read_data_fd, int write_data_fd,
874         int read_status_fd, int write_status_fd ) {
875
876         prefork_child* child = (prefork_child*) safe_malloc(sizeof(prefork_child));
877         child->pid              = 0;
878         child->max_requests     = max_requests;
879         child->read_data_fd     = read_data_fd;
880         child->write_data_fd    = write_data_fd;
881         child->read_status_fd   = read_status_fd;
882         child->write_status_fd  = write_status_fd;
883         child->min_children     = 0;
884         child->available        = 1;
885         child->appname          = NULL;
886         child->keepalive        = 0;
887         child->next             = NULL;
888
889         return child;
890 }
891
892
893 static void prefork_clear( prefork_simple* prefork ) {
894
895         while( prefork->first_child != NULL ) {
896                 osrfLogInfo( OSRF_LOG_MARK, "Killing children and sleeping 1 to reap..." );
897                 kill( 0, SIGKILL );
898                 sleep(1);
899         }
900
901         client_free(prefork->connection);
902         free(prefork->appname);
903 }
904
905 static int prefork_child_free( prefork_child* child ) {
906         free(child->appname);
907         close(child->read_data_fd);
908         close(child->write_status_fd);
909         free( child );
910         return 1;
911 }