import HEAD into svn+ssh://svn.samba.org/home/svn/samba/trunk
[metze/old/v3-2-winbind-ndr.git] / source / nsswitch / winbindd.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    Winbind daemon for ntdom nss module
5
6    Copyright (C) by Tim Potter 2000-2002
7    Copyright (C) Andrew Tridgell 2002
8    Copyright (C) Jelmer Vernooij 2003
9    
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 2 of the License, or
13    (at your option) any later version.
14    
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19    
20    You should have received a copy of the GNU General Public License
21    along with this program; if not, write to the Free Software
22    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24
25 #include "includes.h"
26 #include "winbindd.h"
27
28 BOOL opt_nocache = False;
29 BOOL opt_dual_daemon = True;
30
31 /* Reload configuration */
32
33 static BOOL reload_services_file(void)
34 {
35         BOOL ret;
36
37         if (lp_loaded()) {
38                 pstring fname;
39
40                 pstrcpy(fname,lp_configfile());
41                 if (file_exist(fname,NULL) && !strcsequal(fname,dyn_CONFIGFILE)) {
42                         pstrcpy(dyn_CONFIGFILE,fname);
43                 }
44         }
45
46         reopen_logs();
47         ret = lp_load(dyn_CONFIGFILE,False,False,True);
48
49         reopen_logs();
50         load_interfaces();
51
52         return(ret);
53 }
54
55
56 #if DUMP_CORE
57
58 /**************************************************************************** **
59  Prepare to dump a core file - carefully!
60  **************************************************************************** */
61
62 static BOOL dump_core(void)
63 {
64         char *p;
65         pstring dname;
66         pstrcpy( dname, lp_logfile() );
67         if ((p=strrchr(dname,'/')))
68                 *p=0;
69         pstrcat( dname, "/corefiles" );
70         mkdir( dname, 0700 );
71         sys_chown( dname, getuid(), getgid() );
72         chmod( dname, 0700 );
73         if ( chdir(dname) )
74                 return( False );
75         umask( ~(0700) );
76  
77 #ifdef HAVE_GETRLIMIT
78 #ifdef RLIMIT_CORE
79         {
80                 struct rlimit rlp;
81                 getrlimit( RLIMIT_CORE, &rlp );
82                 rlp.rlim_cur = MAX( 4*1024*1024, rlp.rlim_cur );
83                 setrlimit( RLIMIT_CORE, &rlp );
84                 getrlimit( RLIMIT_CORE, &rlp );
85                 DEBUG( 3, ( "Core limits now %d %d\n", (int)rlp.rlim_cur, (int)rlp.rlim_max ) );
86         }
87 #endif
88 #endif
89  
90         DEBUG(0,("Dumping core in %s\n",dname));
91         abort();
92         return( True );
93 } /* dump_core */
94 #endif
95
96 /**************************************************************************** **
97  Handle a fault..
98  **************************************************************************** */
99
100 static void fault_quit(void)
101 {
102 #if DUMP_CORE
103         dump_core();
104 #endif
105 }
106
107 static void winbindd_status(void)
108 {
109         struct winbindd_cli_state *tmp;
110
111         DEBUG(0, ("winbindd status:\n"));
112
113         /* Print client state information */
114         
115         DEBUG(0, ("\t%d clients currently active\n", winbindd_num_clients()));
116         
117         if (DEBUGLEVEL >= 2 && winbindd_num_clients()) {
118                 DEBUG(2, ("\tclient list:\n"));
119                 for(tmp = winbindd_client_list(); tmp; tmp = tmp->next) {
120                         DEBUG(2, ("\t\tpid %lu, sock %d, rbl %d, wbl %d\n",
121                                   (unsigned long)tmp->pid, tmp->sock, tmp->read_buf_len, 
122                                   tmp->write_buf_len));
123                 }
124         }
125 }
126
127 /* Print winbindd status to log file */
128
129 static void print_winbindd_status(void)
130 {
131         winbindd_status();
132         winbindd_cm_status();
133 }
134
135 /* Flush client cache */
136
137 static void flush_caches(void)
138 {
139 #if 0
140         /* Clear cached user and group enumation info */        
141         if (!opt_dual_daemon) /* Until we have coherent cache flush. */
142                 wcache_flush_cache();
143 #endif
144
145         /* We need to invalidate cached user list entries on a SIGHUP 
146            otherwise cached access denied errors due to restrict anonymous
147            hang around until the sequence number changes. */
148
149         wcache_invalidate_cache();
150 }
151
152 /* Handle the signal by unlinking socket and exiting */
153
154 static void terminate(void)
155 {
156         pstring path;
157
158         idmap_close();
159         
160         /* Remove socket file */
161         pstr_sprintf(path, "%s/%s", 
162                  WINBINDD_SOCKET_DIR, WINBINDD_SOCKET_NAME);
163         unlink(path);
164         exit(0);
165 }
166
167 static BOOL do_sigterm;
168
169 static void termination_handler(int signum)
170 {
171         do_sigterm = True;
172         sys_select_signal();
173 }
174
175 static BOOL do_sigusr2;
176
177 static void sigusr2_handler(int signum)
178 {
179         do_sigusr2 = True;
180         sys_select_signal();
181 }
182
183 static BOOL do_sighup;
184
185 static void sighup_handler(int signum)
186 {
187         do_sighup = True;
188         sys_select_signal();
189 }
190
191 /* React on 'smbcontrol winbindd reload-config' in the same way as on SIGHUP*/
192 static void msg_reload_services(int msg_type, pid_t src, void *buf, size_t len)
193 {
194         /* Flush various caches */
195         flush_caches();
196         reload_services_file();
197 }
198
199 /* React on 'smbcontrol winbindd shutdown' in the same way as on SIGTERM*/
200 static void msg_shutdown(int msg_type, pid_t src, void *buf, size_t len)
201 {
202         terminate();
203 }
204
205 struct dispatch_table {
206         enum winbindd_cmd cmd;
207         enum winbindd_result (*fn)(struct winbindd_cli_state *state);
208         const char *winbindd_cmd_name;
209 };
210
211 static struct dispatch_table dispatch_table[] = {
212         
213         /* User functions */
214
215         { WINBINDD_GETPWNAM, winbindd_getpwnam, "GETPWNAM" },
216         { WINBINDD_GETPWUID, winbindd_getpwuid, "GETPWUID" },
217
218         { WINBINDD_SETPWENT, winbindd_setpwent, "SETPWENT" },
219         { WINBINDD_ENDPWENT, winbindd_endpwent, "ENDPWENT" },
220         { WINBINDD_GETPWENT, winbindd_getpwent, "GETPWENT" },
221
222         { WINBINDD_GETGROUPS, winbindd_getgroups, "GETGROUPS" },
223         { WINBINDD_GETUSERSIDS, winbindd_getusersids, "GETUSERSIDS" },
224
225         /* Group functions */
226
227         { WINBINDD_GETGRNAM, winbindd_getgrnam, "GETGRNAM" },
228         { WINBINDD_GETGRGID, winbindd_getgrgid, "GETGRGID" },
229         { WINBINDD_SETGRENT, winbindd_setgrent, "SETGRENT" },
230         { WINBINDD_ENDGRENT, winbindd_endgrent, "ENDGRENT" },
231         { WINBINDD_GETGRENT, winbindd_getgrent, "GETGRENT" },
232         { WINBINDD_GETGRLST, winbindd_getgrent, "GETGRLST" },
233
234         /* PAM auth functions */
235
236         { WINBINDD_PAM_AUTH, winbindd_pam_auth, "PAM_AUTH" },
237         { WINBINDD_PAM_AUTH_CRAP, winbindd_pam_auth_crap, "AUTH_CRAP" },
238         { WINBINDD_PAM_CHAUTHTOK, winbindd_pam_chauthtok, "CHAUTHTOK" },
239
240         /* Enumeration functions */
241
242         { WINBINDD_LIST_USERS, winbindd_list_users, "LIST_USERS" },
243         { WINBINDD_LIST_GROUPS, winbindd_list_groups, "LIST_GROUPS" },
244         { WINBINDD_LIST_TRUSTDOM, winbindd_list_trusted_domains, "LIST_TRUSTDOM" },
245         { WINBINDD_SHOW_SEQUENCE, winbindd_show_sequence, "SHOW_SEQUENCE" },
246
247         /* SID related functions */
248
249         { WINBINDD_LOOKUPSID, winbindd_lookupsid, "LOOKUPSID" },
250         { WINBINDD_LOOKUPNAME, winbindd_lookupname, "LOOKUPNAME" },
251
252         /* Lookup related functions */
253
254         { WINBINDD_SID_TO_UID, winbindd_sid_to_uid, "SID_TO_UID" },
255         { WINBINDD_SID_TO_GID, winbindd_sid_to_gid, "SID_TO_GID" },
256         { WINBINDD_GID_TO_SID, winbindd_gid_to_sid, "GID_TO_SID" },
257         { WINBINDD_UID_TO_SID, winbindd_uid_to_sid, "UID_TO_SID" },
258         { WINBINDD_ALLOCATE_RID, winbindd_allocate_rid, "ALLOCATE_RID" },
259
260         /* Miscellaneous */
261
262         { WINBINDD_CHECK_MACHACC, winbindd_check_machine_acct, "CHECK_MACHACC" },
263         { WINBINDD_PING, winbindd_ping, "PING" },
264         { WINBINDD_INFO, winbindd_info, "INFO" },
265         { WINBINDD_INTERFACE_VERSION, winbindd_interface_version, "INTERFACE_VERSION" },
266         { WINBINDD_DOMAIN_NAME, winbindd_domain_name, "DOMAIN_NAME" },
267         { WINBINDD_DOMAIN_INFO, winbindd_domain_info, "DOMAIN_INFO" },
268         { WINBINDD_NETBIOS_NAME, winbindd_netbios_name, "NETBIOS_NAME" },
269         { WINBINDD_PRIV_PIPE_DIR, winbindd_priv_pipe_dir, "WINBINDD_PRIV_PIPE_DIR" },
270
271         /* WINS functions */
272
273         { WINBINDD_WINS_BYNAME, winbindd_wins_byname, "WINS_BYNAME" },
274         { WINBINDD_WINS_BYIP, winbindd_wins_byip, "WINS_BYIP" },
275         
276         /* UNIX account management functions */
277         { WINBINDD_CREATE_USER,                 winbindd_create_user,           "CREATE_USER"           },
278         { WINBINDD_CREATE_GROUP,                winbindd_create_group,          "CREATE_GROUP"          },
279         { WINBINDD_ADD_USER_TO_GROUP,           winbindd_add_user_to_group,     "ADD_USER_TO_GROUP"     },
280         { WINBINDD_REMOVE_USER_FROM_GROUP,      winbindd_remove_user_from_group,"REMOVE_USER_FROM_GROUP"},
281         { WINBINDD_SET_USER_PRIMARY_GROUP,      winbindd_set_user_primary_group,"SET_USER_PRIMARY_GROUP"},
282         { WINBINDD_DELETE_USER,                 winbindd_delete_user,           "DELETE_USER"           },
283         { WINBINDD_DELETE_GROUP,                winbindd_delete_group,          "DELETE_GROUP"          },
284         
285         /* End of list */
286
287         { WINBINDD_NUM_CMDS, NULL, "NONE" }
288 };
289
290 static void process_request(struct winbindd_cli_state *state)
291 {
292         struct dispatch_table *table = dispatch_table;
293
294         /* Free response data - we may be interrupted and receive another
295            command before being able to send this data off. */
296
297         SAFE_FREE(state->response.extra_data);  
298
299         ZERO_STRUCT(state->response);
300
301         state->response.result = WINBINDD_ERROR;
302         state->response.length = sizeof(struct winbindd_response);
303
304         /* Process command */
305
306         for (table = dispatch_table; table->fn; table++) {
307                 if (state->request.cmd == table->cmd) {
308                         DEBUG(10,("process_request: request fn %s\n", table->winbindd_cmd_name ));
309                         state->response.result = table->fn(state);
310                         break;
311                 }
312         }
313
314         if (!table->fn)
315                 DEBUG(10,("process_request: unknown request fn number %d\n", (int)state->request.cmd ));
316
317         /* In case extra data pointer is NULL */
318
319         if (!state->response.extra_data)
320                 state->response.length = sizeof(struct winbindd_response);
321 }
322
323 /* Process a new connection by adding it to the client connection list */
324
325 static void new_connection(int listen_sock, BOOL privileged)
326 {
327         struct sockaddr_un sunaddr;
328         struct winbindd_cli_state *state;
329         socklen_t len;
330         int sock;
331         
332         /* Accept connection */
333         
334         len = sizeof(sunaddr);
335
336         do {
337                 sock = accept(listen_sock, (struct sockaddr *)&sunaddr, &len);
338         } while (sock == -1 && errno == EINTR);
339
340         if (sock == -1)
341                 return;
342         
343         DEBUG(6,("accepted socket %d\n", sock));
344         
345         /* Create new connection structure */
346         
347         if ((state = (struct winbindd_cli_state *) 
348              malloc(sizeof(*state))) == NULL)
349                 return;
350         
351         ZERO_STRUCTP(state);
352         state->sock = sock;
353
354         state->last_access = time(NULL);        
355
356         state->privileged = privileged;
357
358         /* Add to connection list */
359         
360         winbindd_add_client(state);
361 }
362
363 /* Remove a client connection from client connection list */
364
365 static void remove_client(struct winbindd_cli_state *state)
366 {
367         /* It's a dead client - hold a funeral */
368         
369         if (state != NULL) {
370                 
371                 /* Close socket */
372                 
373                 close(state->sock);
374                 
375                 /* Free any getent state */
376                 
377                 free_getent_state(state->getpwent_state);
378                 free_getent_state(state->getgrent_state);
379                 
380                 /* We may have some extra data that was not freed if the
381                    client was killed unexpectedly */
382
383                 SAFE_FREE(state->response.extra_data);
384                 
385                 /* Remove from list and free */
386                 
387                 winbindd_remove_client(state);
388                 SAFE_FREE(state);
389         }
390 }
391
392
393 /* Shutdown client connection which has been idle for the longest time */
394
395 static BOOL remove_idle_client(void)
396 {
397         struct winbindd_cli_state *state, *remove_state = NULL;
398         time_t last_access = 0;
399         int nidle = 0;
400
401         for (state = winbindd_client_list(); state; state = state->next) {
402                 if (state->read_buf_len == 0 && state->write_buf_len == 0 &&
403                                 !state->getpwent_state && !state->getgrent_state) {
404                         nidle++;
405                         if (!last_access || state->last_access < last_access) {
406                                 last_access = state->last_access;
407                                 remove_state = state;
408                         }
409                 }
410         }
411
412         if (remove_state) {
413                 DEBUG(5,("Found %d idle client connections, shutting down sock %d, pid %u\n",
414                         nidle, remove_state->sock, (unsigned int)remove_state->pid));
415                 remove_client(remove_state);
416                 return True;
417         }
418
419         return False;
420 }
421
422 /* Process a complete received packet from a client */
423
424 void winbind_process_packet(struct winbindd_cli_state *state)
425 {
426         /* Process request */
427         
428         /* Ensure null termination of entire request */
429         state->request.null_term = '\0';
430
431         state->pid = state->request.pid;
432         
433         process_request(state);
434
435         /* Update client state */
436         
437         state->read_buf_len = 0;
438         state->write_buf_len = sizeof(struct winbindd_response);
439
440         /* we might need to send it to the dual daemon */
441         if (opt_dual_daemon) {
442                 dual_send_request(state);
443         }
444 }
445
446 /* Read some data from a client connection */
447
448 void winbind_client_read(struct winbindd_cli_state *state)
449 {
450         int n;
451     
452         /* Read data */
453
454         n = sys_read(state->sock, state->read_buf_len + 
455                  (char *)&state->request, 
456                  sizeof(state->request) - state->read_buf_len);
457         
458         DEBUG(10,("client_read: read %d bytes. Need %ld more for a full request.\n", n, (unsigned long)(sizeof(state->request) - n - state->read_buf_len) ));
459
460         /* Read failed, kill client */
461         
462         if (n == -1 || n == 0) {
463                 DEBUG(5,("read failed on sock %d, pid %lu: %s\n",
464                          state->sock, (unsigned long)state->pid, 
465                          (n == -1) ? strerror(errno) : "EOF"));
466                 
467                 state->finished = True;
468                 return;
469         }
470         
471         /* Update client state */
472         
473         state->read_buf_len += n;
474         state->last_access = time(NULL);
475 }
476
477 /* Write some data to a client connection */
478
479 static void client_write(struct winbindd_cli_state *state)
480 {
481         char *data;
482         int num_written;
483         
484         /* Write some data */
485         /*
486          * The fancy calculation of data below allows us to handle the 
487          * case where write (sys_write) does not write all the data we 
488          * gave it. In that case, we will come back through here again
489          * because of the loop above us, and we want to pick up where
490          * we left off.
491          */
492         
493         if (!state->write_extra_data) {
494
495                 /* Write response structure */
496                 
497                 data = (char *)&state->response + sizeof(state->response) - 
498                         state->write_buf_len;
499
500         } else {
501
502                 /* Write extra data */
503                 
504                 data = (char *)state->response.extra_data + 
505                         state->response.length - 
506                         sizeof(struct winbindd_response) - 
507                         state->write_buf_len;
508         }
509         
510         num_written = sys_write(state->sock, data, state->write_buf_len);
511         
512         DEBUG(10,("client_write: wrote %d bytes.\n", num_written ));
513
514         /* Write failed, kill cilent */
515         
516         if (num_written == -1 || num_written == 0) {
517                 
518                 DEBUG(3,("write failed on sock %d, pid %lu: %s\n",
519                          state->sock, (unsigned long)state->pid, 
520                          (num_written == -1) ? strerror(errno) : "EOF"));
521                 
522                 state->finished = True;
523
524                 SAFE_FREE(state->response.extra_data);
525
526                 return;
527         }
528         
529         /* Update client state */
530         
531         state->write_buf_len -= num_written;
532         state->last_access = time(NULL);
533
534         /* Have we written all data? */
535         
536         if (state->write_buf_len == 0) {
537                 
538                 /* Take care of extra data */
539                 
540                 if (state->write_extra_data) {
541
542                         SAFE_FREE(state->response.extra_data);
543
544                         state->write_extra_data = False;
545
546                         DEBUG(10,("client_write: client_write: complete response written.\n"));
547
548                 } else if (state->response.length > 
549                            sizeof(struct winbindd_response)) {
550                         
551                         /* Start writing extra data */
552
553                         state->write_buf_len = 
554                                 state->response.length -
555                                 sizeof(struct winbindd_response);
556                         
557                         DEBUG(10,("client_write: need to write %d extra data bytes.\n", (int)state->write_buf_len));
558
559                         state->write_extra_data = True;
560                 }
561         }
562 }
563
564 /* Process incoming clients on listen_sock.  We use a tricky non-blocking,
565    non-forking, non-threaded model which allows us to handle many
566    simultaneous connections while remaining impervious to many denial of
567    service attacks. */
568
569 static void process_loop(void)
570 {
571         /* We'll be doing this a lot */
572
573         while (1) {
574                 struct winbindd_cli_state *state;
575                 fd_set r_fds, w_fds;
576                 int maxfd, listen_sock, listen_priv_sock, selret;
577                 struct timeval timeout;
578
579                 /* Handle messages */
580
581                 message_dispatch();
582
583                 /* refresh the trusted domain cache */
584                    
585                 rescan_trusted_domains();
586
587                 /* Free up temporary memory */
588
589                 lp_talloc_free();
590                 main_loop_talloc_free();
591
592                 /* Initialise fd lists for select() */
593
594                 listen_sock = open_winbindd_socket();
595                 listen_priv_sock = open_winbindd_priv_socket();
596
597                 if (listen_sock == -1 || listen_priv_sock == -1) {
598                         perror("open_winbind_socket");
599                         exit(1);
600                 }
601
602                 maxfd = MAX(listen_sock, listen_priv_sock);
603
604                 FD_ZERO(&r_fds);
605                 FD_ZERO(&w_fds);
606                 FD_SET(listen_sock, &r_fds);
607                 FD_SET(listen_priv_sock, &r_fds);
608
609                 timeout.tv_sec = WINBINDD_ESTABLISH_LOOP;
610                 timeout.tv_usec = 0;
611
612                 if (opt_dual_daemon) {
613                         maxfd = dual_select_setup(&w_fds, maxfd);
614                 }
615
616                 /* Set up client readers and writers */
617
618                 state = winbindd_client_list();
619
620                 while (state) {
621
622                         /* Dispose of client connection if it is marked as 
623                            finished */ 
624
625                         if (state->finished) {
626                                 struct winbindd_cli_state *next = state->next;
627
628                                 remove_client(state);
629                                 state = next;
630                                 continue;
631                         }
632
633                         /* Select requires we know the highest fd used */
634
635                         if (state->sock > maxfd)
636                                 maxfd = state->sock;
637
638                         /* Add fd for reading */
639
640                         if (state->read_buf_len != sizeof(state->request))
641                                 FD_SET(state->sock, &r_fds);
642
643                         /* Add fd for writing */
644
645                         if (state->write_buf_len)
646                                 FD_SET(state->sock, &w_fds);
647
648                         state = state->next;
649                 }
650
651                 /* Call select */
652         
653                 selret = sys_select(maxfd + 1, &r_fds, &w_fds, NULL, &timeout);
654
655                 if (selret == 0)
656                         continue;
657
658                 if ((selret == -1 && errno != EINTR) || selret == 0) {
659
660                         /* Select error, something is badly wrong */
661
662                         perror("select");
663                         exit(1);
664                 }
665
666                 /* Create a new connection if listen_sock readable */
667
668                 if (selret > 0) {
669
670                         if (opt_dual_daemon) {
671                                 dual_select(&w_fds);
672                         }
673
674                         if (FD_ISSET(listen_sock, &r_fds)) {
675                                 while (winbindd_num_clients() > WINBINDD_MAX_SIMULTANEOUS_CLIENTS - 1) {
676                                         DEBUG(5,("winbindd: Exceeding %d client connections, removing idle connection.\n",
677                                                 WINBINDD_MAX_SIMULTANEOUS_CLIENTS));
678                                         if (!remove_idle_client()) {
679                                                 DEBUG(0,("winbindd: Exceeding %d client connections, no idle connection found\n",
680                                                         WINBINDD_MAX_SIMULTANEOUS_CLIENTS));
681                                                 break;
682                                         }
683                                 }
684                                 /* new, non-privileged connection */
685                                 new_connection(listen_sock, False);
686                         }
687             
688                         if (FD_ISSET(listen_priv_sock, &r_fds)) {
689                                 while (winbindd_num_clients() > WINBINDD_MAX_SIMULTANEOUS_CLIENTS - 1) {
690                                         DEBUG(5,("winbindd: Exceeding %d client connections, removing idle connection.\n",
691                                                 WINBINDD_MAX_SIMULTANEOUS_CLIENTS));
692                                         if (!remove_idle_client()) {
693                                                 DEBUG(0,("winbindd: Exceeding %d client connections, no idle connection found\n",
694                                                         WINBINDD_MAX_SIMULTANEOUS_CLIENTS));
695                                                 break;
696                                         }
697                                 }
698                                 /* new, privileged connection */
699                                 new_connection(listen_priv_sock, True);
700                         }
701             
702                         /* Process activity on client connections */
703             
704                         for (state = winbindd_client_list(); state; 
705                              state = state->next) {
706                 
707                                 /* Data available for reading */
708                 
709                                 if (FD_ISSET(state->sock, &r_fds)) {
710                     
711                                         /* Read data */
712                     
713                                         winbind_client_read(state);
714
715                                         /* 
716                                          * If we have the start of a
717                                          * packet, then check the
718                                          * length field to make sure
719                                          * the client's not talking
720                                          * Mock Swedish.
721                                          */
722
723                                         if (state->read_buf_len >= sizeof(uint32)
724                                             && *(uint32 *) &state->request != sizeof(state->request)) {
725                                                 DEBUG(0,("process_loop: Invalid request size from pid %lu: %d bytes sent, should be %ld\n",
726                                                                 (unsigned long)state->request.pid, *(uint32 *) &state->request, (unsigned long)sizeof(state->request)));
727                                                 DEBUGADD(0, ("This usually means that you are running old wbinfo, pam_winbind or libnss_winbind clients\n"));
728
729                                                 remove_client(state);
730                                                 break;
731                                         }
732
733                                         /* A request packet might be 
734                                            complete */
735                     
736                                         if (state->read_buf_len == 
737                                             sizeof(state->request)) {
738                                                 winbind_process_packet(state);
739                                         }
740                                 }
741                 
742                                 /* Data available for writing */
743                 
744                                 if (FD_ISSET(state->sock, &w_fds))
745                                         client_write(state);
746                         }
747                 }
748
749 #if 0
750                 winbindd_check_cache_size(time(NULL));
751 #endif
752
753                 /* Check signal handling things */
754
755                 if (do_sigterm)
756                         terminate();
757
758                 if (do_sighup) {
759
760                         DEBUG(3, ("got SIGHUP\n"));
761
762                         msg_reload_services(MSG_SMB_CONF_UPDATED, (pid_t) 0, NULL, 0);
763                         do_sighup = False;
764                 }
765
766                 if (do_sigusr2) {
767                         print_winbindd_status();
768                         do_sigusr2 = False;
769                 }
770         }
771 }
772
773 /* Main function */
774
775 struct winbindd_state server_state;   /* Server state information */
776
777 int main(int argc, char **argv)
778 {
779         pstring logfile;
780         static BOOL interactive = False;
781         static BOOL Fork = True;
782         static BOOL log_stdout = False;
783         struct poptOption long_options[] = {
784                 POPT_AUTOHELP
785                 { "stdout", 'S', POPT_ARG_VAL, &log_stdout, True, "Log to stdout" },
786                 { "foreground", 'F', POPT_ARG_VAL, &Fork, False, "Daemon in foreground mode" },
787                 { "interactive", 'i', POPT_ARG_NONE, NULL, 'i', "Interactive mode" },
788                 { "single-daemon", 'Y', POPT_ARG_VAL, &opt_dual_daemon, False, "Single daemon mode" },
789                 { "no-caching", 'n', POPT_ARG_VAL, &opt_nocache, True, "Disable caching" },
790                 POPT_COMMON_SAMBA
791                 POPT_TABLEEND
792         };
793         poptContext pc;
794         int opt;
795
796         /* glibc (?) likes to print "User defined signal 1" and exit if a
797            SIGUSR[12] is received before a handler is installed */
798
799         CatchSignal(SIGUSR1, SIG_IGN);
800         CatchSignal(SIGUSR2, SIG_IGN);
801
802         fault_setup((void (*)(void *))fault_quit );
803
804         /* Initialise for running in non-root mode */
805
806         sec_init();
807
808         set_remote_machine_name("winbindd", False);
809
810         /* Set environment variable so we don't recursively call ourselves.
811            This may also be useful interactively. */
812
813         setenv(WINBINDD_DONT_ENV, "1", 1);
814
815         /* Initialise samba/rpc client stuff */
816
817         pc = poptGetContext("winbindd", argc, (const char **)argv, long_options,
818                                                 POPT_CONTEXT_KEEP_FIRST);
819
820         while ((opt = poptGetNextOpt(pc)) != -1) {
821                 switch (opt) {
822                         /* Don't become a daemon */
823                 case 'i':
824                         interactive = True;
825                         log_stdout = True;
826                         Fork = False;
827                         break;
828                 }
829         }
830
831
832         if (log_stdout && Fork) {
833                 printf("Can't log to stdout (-S) unless daemon is in foreground +(-F) or interactive (-i)\n");
834                 poptPrintUsage(pc, stderr, 0);
835                 exit(1);
836         }
837
838         pstr_sprintf(logfile, "%s/log.winbindd", dyn_LOGFILEBASE);
839         lp_set_logfile(logfile);
840         setup_logging("winbindd", log_stdout);
841         reopen_logs();
842
843         DEBUG(1, ("winbindd version %s started.\n", SAMBA_VERSION_STRING) );
844         DEBUGADD( 1, ( "Copyright The Samba Team 2000-2004\n" ) );
845
846         if (!reload_services_file()) {
847                 DEBUG(0, ("error opening config file\n"));
848                 exit(1);
849         }
850
851         /* Setup names. */
852
853         if (!init_names())
854                 exit(1);
855
856         load_interfaces();
857
858         if (!secrets_init()) {
859
860                 DEBUG(0,("Could not initialize domain trust account secrets. Giving up\n"));
861                 return False;
862         }
863
864         /* Enable netbios namecache */
865
866         namecache_enable();
867
868         /* Check winbindd parameters are valid */
869
870         ZERO_STRUCT(server_state);
871
872         if (!winbindd_param_init())
873                 return 1;
874
875         /* Winbind daemon initialisation */
876
877         if (!winbindd_upgrade_idmap())
878                 return 1;
879
880         if (!idmap_init(lp_idmap_backend()))
881                 return 1;
882
883         /* Unblock all signals we are interested in as they may have been
884            blocked by the parent process. */
885
886         BlockSignals(False, SIGINT);
887         BlockSignals(False, SIGQUIT);
888         BlockSignals(False, SIGTERM);
889         BlockSignals(False, SIGUSR1);
890         BlockSignals(False, SIGUSR2);
891         BlockSignals(False, SIGHUP);
892
893         /* Setup signal handlers */
894         
895         CatchSignal(SIGINT, termination_handler);      /* Exit on these sigs */
896         CatchSignal(SIGQUIT, termination_handler);
897         CatchSignal(SIGTERM, termination_handler);
898
899         CatchSignal(SIGPIPE, SIG_IGN);                 /* Ignore sigpipe */
900
901         CatchSignal(SIGUSR2, sigusr2_handler);         /* Debugging sigs */
902         CatchSignal(SIGHUP, sighup_handler);
903
904         if (!interactive)
905                 become_daemon(Fork);
906
907         pidfile_create("winbindd");
908
909 #if HAVE_SETPGID
910         /*
911          * If we're interactive we want to set our own process group for
912          * signal management.
913          */
914         if (interactive)
915                 setpgid( (pid_t)0, (pid_t)0);
916 #endif
917
918         if (opt_dual_daemon) {
919                 do_dual_daemon();
920         }
921
922         /* Initialise messaging system */
923
924         if (!message_init()) {
925                 DEBUG(0, ("unable to initialise messaging system\n"));
926                 exit(1);
927         }
928         
929         /* React on 'smbcontrol winbindd reload-config' in the same way
930            as to SIGHUP signal */
931         message_register(MSG_SMB_CONF_UPDATED, msg_reload_services);
932         message_register(MSG_SHUTDOWN, msg_shutdown);
933         
934         poptFreeContext(pc);
935
936         netsamlogon_cache_init(); /* Non-critical */
937         
938         init_domain_list();
939
940         /* Loop waiting for requests */
941
942         process_loop();
943
944         trustdom_cache_shutdown();
945
946         return 0;
947 }