Put back the changes that Simo reverted and fix a speling mistak.
[tprouty/samba.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 "winbindd.h"
26
27 BOOL opt_nocache = False;
28 BOOL opt_dual_daemon = True;
29
30 /* Reload configuration */
31
32 static BOOL reload_services_file(BOOL test)
33 {
34         BOOL ret;
35
36         if (lp_loaded()) {
37                 pstring fname;
38
39                 pstrcpy(fname,lp_configfile());
40                 if (file_exist(fname,NULL) && !strcsequal(fname,dyn_CONFIGFILE)) {
41                         pstrcpy(dyn_CONFIGFILE,fname);
42                         test = False;
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(True);
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
224         /* Group functions */
225
226         { WINBINDD_GETGRNAM, winbindd_getgrnam, "GETGRNAM" },
227         { WINBINDD_GETGRGID, winbindd_getgrgid, "GETGRGID" },
228         { WINBINDD_SETGRENT, winbindd_setgrent, "SETGRENT" },
229         { WINBINDD_ENDGRENT, winbindd_endgrent, "ENDGRENT" },
230         { WINBINDD_GETGRENT, winbindd_getgrent, "GETGRENT" },
231         { WINBINDD_GETGRLST, winbindd_getgrent, "GETGRLST" },
232
233         /* PAM auth functions */
234
235         { WINBINDD_PAM_AUTH, winbindd_pam_auth, "PAM_AUTH" },
236         { WINBINDD_PAM_AUTH_CRAP, winbindd_pam_auth_crap, "AUTH_CRAP" },
237         { WINBINDD_PAM_CHAUTHTOK, winbindd_pam_chauthtok, "CHAUTHTOK" },
238
239         /* Enumeration functions */
240
241         { WINBINDD_LIST_USERS, winbindd_list_users, "LIST_USERS" },
242         { WINBINDD_LIST_GROUPS, winbindd_list_groups, "LIST_GROUPS" },
243         { WINBINDD_LIST_TRUSTDOM, winbindd_list_trusted_domains, "LIST_TRUSTDOM" },
244         { WINBINDD_SHOW_SEQUENCE, winbindd_show_sequence, "SHOW_SEQUENCE" },
245
246         /* SID related functions */
247
248         { WINBINDD_LOOKUPSID, winbindd_lookupsid, "LOOKUPSID" },
249         { WINBINDD_LOOKUPNAME, winbindd_lookupname, "LOOKUPNAME" },
250
251         /* Lookup related functions */
252
253         { WINBINDD_SID_TO_UID, winbindd_sid_to_uid, "SID_TO_UID" },
254         { WINBINDD_SID_TO_GID, winbindd_sid_to_gid, "SID_TO_GID" },
255         { WINBINDD_GID_TO_SID, winbindd_gid_to_sid, "GID_TO_SID" },
256         { WINBINDD_UID_TO_SID, winbindd_uid_to_sid, "UID_TO_SID" },
257
258         /* Miscellaneous */
259
260         { WINBINDD_CHECK_MACHACC, winbindd_check_machine_acct, "CHECK_MACHACC" },
261         { WINBINDD_PING, winbindd_ping, "PING" },
262         { WINBINDD_INFO, winbindd_info, "INFO" },
263         { WINBINDD_INTERFACE_VERSION, winbindd_interface_version, "INTERFACE_VERSION" },
264         { WINBINDD_DOMAIN_NAME, winbindd_domain_name, "DOMAIN_NAME" },
265         { WINBINDD_NETBIOS_NAME, winbindd_netbios_name, "NETBIOS_NAME" },
266         { WINBINDD_PRIV_PIPE_DIR, winbindd_priv_pipe_dir, "WINBINDD_PRIV_PIPE_DIR" },
267
268         /* WINS functions */
269
270         { WINBINDD_WINS_BYNAME, winbindd_wins_byname, "WINS_BYNAME" },
271         { WINBINDD_WINS_BYIP, winbindd_wins_byip, "WINS_BYIP" },
272         
273         /* UNIX account management functions */
274         { WINBINDD_CREATE_USER,                 winbindd_create_user,           "CREATE_USER"           },
275         { WINBINDD_CREATE_GROUP,                winbindd_create_group,          "CREATE_GROUP"          },
276         { WINBINDD_ADD_USER_TO_GROUP,           winbindd_add_user_to_group,     "ADD_USER_TO_GROUP"     },
277         { WINBINDD_REMOVE_USER_FROM_GROUP,      winbindd_remove_user_from_group,"REMOVE_USER_FROM_GROUP"},
278         { WINBINDD_SET_USER_PRIMARY_GROUP,      winbindd_set_user_primary_group,"SET_USER_PRIMARY_GROUP"},
279         { WINBINDD_DELETE_USER,                 winbindd_delete_user,           "DELETE_USER"           },
280         { WINBINDD_DELETE_GROUP,                winbindd_delete_group,          "DELETE_GROUP"          },
281         
282         /* End of list */
283
284         { WINBINDD_NUM_CMDS, NULL, "NONE" }
285 };
286
287 static void process_request(struct winbindd_cli_state *state)
288 {
289         struct dispatch_table *table = dispatch_table;
290
291         /* Free response data - we may be interrupted and receive another
292            command before being able to send this data off. */
293
294         SAFE_FREE(state->response.extra_data);  
295
296         ZERO_STRUCT(state->response);
297
298         state->response.result = WINBINDD_ERROR;
299         state->response.length = sizeof(struct winbindd_response);
300
301         /* Process command */
302
303         for (table = dispatch_table; table->fn; table++) {
304                 if (state->request.cmd == table->cmd) {
305                         DEBUG(10,("process_request: request fn %s\n", table->winbindd_cmd_name ));
306                         state->response.result = table->fn(state);
307                         break;
308                 }
309         }
310
311         if (!table->fn)
312                 DEBUG(10,("process_request: unknown request fn number %d\n", (int)state->request.cmd ));
313
314         /* In case extra data pointer is NULL */
315
316         if (!state->response.extra_data)
317                 state->response.length = sizeof(struct winbindd_response);
318 }
319
320 /* Process a new connection by adding it to the client connection list */
321
322 static void new_connection(int listen_sock, BOOL privileged)
323 {
324         struct sockaddr_un sunaddr;
325         struct winbindd_cli_state *state;
326         socklen_t len;
327         int sock;
328         
329         /* Accept connection */
330         
331         len = sizeof(sunaddr);
332
333         do {
334                 sock = accept(listen_sock, (struct sockaddr *)&sunaddr, &len);
335         } while (sock == -1 && errno == EINTR);
336
337         if (sock == -1)
338                 return;
339         
340         DEBUG(6,("accepted socket %d\n", sock));
341         
342         /* Create new connection structure */
343         
344         if ((state = (struct winbindd_cli_state *) 
345              malloc(sizeof(*state))) == NULL)
346                 return;
347         
348         ZERO_STRUCTP(state);
349         state->sock = sock;
350
351         state->last_access = time(NULL);        
352
353         state->privileged = privileged;
354
355         /* Add to connection list */
356         
357         winbindd_add_client(state);
358 }
359
360 /* Remove a client connection from client connection list */
361
362 static void remove_client(struct winbindd_cli_state *state)
363 {
364         /* It's a dead client - hold a funeral */
365         
366         if (state != NULL) {
367                 
368                 /* Close socket */
369                 
370                 close(state->sock);
371                 
372                 /* Free any getent state */
373                 
374                 free_getent_state(state->getpwent_state);
375                 free_getent_state(state->getgrent_state);
376                 
377                 /* We may have some extra data that was not freed if the
378                    client was killed unexpectedly */
379
380                 SAFE_FREE(state->response.extra_data);
381                 
382                 /* Remove from list and free */
383                 
384                 winbindd_remove_client(state);
385                 SAFE_FREE(state);
386         }
387 }
388
389
390 /* Shutdown client connection which has been idle for the longest time */
391
392 static BOOL remove_idle_client(void)
393 {
394         struct winbindd_cli_state *state, *remove_state = NULL;
395         time_t last_access = 0;
396         int nidle = 0;
397
398         for (state = winbindd_client_list(); state; state = state->next) {
399                 if (state->read_buf_len == 0 && state->write_buf_len == 0 &&
400                                 !state->getpwent_state && !state->getgrent_state) {
401                         nidle++;
402                         if (!last_access || state->last_access < last_access) {
403                                 last_access = state->last_access;
404                                 remove_state = state;
405                         }
406                 }
407         }
408
409         if (remove_state) {
410                 DEBUG(5,("Found %d idle client connections, shutting down sock %d, pid %u\n",
411                         nidle, remove_state->sock, (unsigned int)remove_state->pid));
412                 remove_client(remove_state);
413                 return True;
414         }
415
416         return False;
417 }
418
419 /* Process a complete received packet from a client */
420
421 void winbind_process_packet(struct winbindd_cli_state *state)
422 {
423         /* Process request */
424         
425         /* Ensure null termination of entire request */
426         state->request.null_term = '\0';
427
428         state->pid = state->request.pid;
429         
430         process_request(state);
431
432         /* Update client state */
433         
434         state->read_buf_len = 0;
435         state->write_buf_len = sizeof(struct winbindd_response);
436
437         /* we might need to send it to the dual daemon */
438         if (opt_dual_daemon) {
439                 dual_send_request(state);
440         }
441 }
442
443 /* Read some data from a client connection */
444
445 void winbind_client_read(struct winbindd_cli_state *state)
446 {
447         int n;
448     
449         /* Read data */
450
451         n = sys_read(state->sock, state->read_buf_len + 
452                  (char *)&state->request, 
453                  sizeof(state->request) - state->read_buf_len);
454         
455         DEBUG(10,("client_read: read %d bytes. Need %d more for a full request.\n", n, sizeof(state->request) - n - state->read_buf_len ));
456
457         /* Read failed, kill client */
458         
459         if (n == -1 || n == 0) {
460                 DEBUG(5,("read failed on sock %d, pid %lu: %s\n",
461                          state->sock, (unsigned long)state->pid, 
462                          (n == -1) ? strerror(errno) : "EOF"));
463                 
464                 state->finished = True;
465                 return;
466         }
467         
468         /* Update client state */
469         
470         state->read_buf_len += n;
471         state->last_access = time(NULL);
472 }
473
474 /* Write some data to a client connection */
475
476 static void client_write(struct winbindd_cli_state *state)
477 {
478         char *data;
479         int num_written;
480         
481         /* Write some data */
482         /*
483          * The fancy calculation of data below allows us to handle the 
484          * case where write (sys_write) does not write all the data we 
485          * gave it. In that case, we will come back through here again
486          * because of the loop above us, and we want to pick up where
487          * we left off.
488          */
489         
490         if (!state->write_extra_data) {
491
492                 /* Write response structure */
493                 
494                 data = (char *)&state->response + sizeof(state->response) - 
495                         state->write_buf_len;
496
497         } else {
498
499                 /* Write extra data */
500                 
501                 data = (char *)state->response.extra_data + 
502                         state->response.length - 
503                         sizeof(struct winbindd_response) - 
504                         state->write_buf_len;
505         }
506         
507         num_written = sys_write(state->sock, data, state->write_buf_len);
508         
509         DEBUG(10,("client_write: wrote %d bytes.\n", num_written ));
510
511         /* Write failed, kill cilent */
512         
513         if (num_written == -1 || num_written == 0) {
514                 
515                 DEBUG(3,("write failed on sock %d, pid %lu: %s\n",
516                          state->sock, (unsigned long)state->pid, 
517                          (num_written == -1) ? strerror(errno) : "EOF"));
518                 
519                 state->finished = True;
520
521                 SAFE_FREE(state->response.extra_data);
522
523                 return;
524         }
525         
526         /* Update client state */
527         
528         state->write_buf_len -= num_written;
529         state->last_access = time(NULL);
530
531         /* Have we written all data? */
532         
533         if (state->write_buf_len == 0) {
534                 
535                 /* Take care of extra data */
536                 
537                 if (state->write_extra_data) {
538
539                         SAFE_FREE(state->response.extra_data);
540
541                         state->write_extra_data = False;
542
543                         DEBUG(10,("client_write: client_write: complete response written.\n"));
544
545                 } else if (state->response.length > 
546                            sizeof(struct winbindd_response)) {
547                         
548                         /* Start writing extra data */
549
550                         state->write_buf_len = 
551                                 state->response.length -
552                                 sizeof(struct winbindd_response);
553                         
554                         DEBUG(10,("client_write: need to write %d extra data bytes.\n", (int)state->write_buf_len));
555
556                         state->write_extra_data = True;
557                 }
558         }
559 }
560
561 /* Process incoming clients on listen_sock.  We use a tricky non-blocking,
562    non-forking, non-threaded model which allows us to handle many
563    simultaneous connections while remaining impervious to many denial of
564    service attacks. */
565
566 static void process_loop(void)
567 {
568         /* We'll be doing this a lot */
569
570         while (1) {
571                 struct winbindd_cli_state *state;
572                 fd_set r_fds, w_fds;
573                 int maxfd, listen_sock, listen_priv_sock, selret;
574                 struct timeval timeout;
575
576                 /* Handle messages */
577
578                 message_dispatch();
579
580                 /* refresh the trusted domain cache */
581                    
582                 rescan_trusted_domains();
583
584                 /* Free up temporary memory */
585
586                 lp_talloc_free();
587                 main_loop_talloc_free();
588
589                 /* Initialise fd lists for select() */
590
591                 listen_sock = open_winbindd_socket();
592                 listen_priv_sock = open_winbindd_priv_socket();
593
594                 if (listen_sock == -1 || listen_priv_sock == -1) {
595                         perror("open_winbind_socket");
596                         exit(1);
597                 }
598
599                 maxfd = MAX(listen_sock, listen_priv_sock);
600
601                 FD_ZERO(&r_fds);
602                 FD_ZERO(&w_fds);
603                 FD_SET(listen_sock, &r_fds);
604                 FD_SET(listen_priv_sock, &r_fds);
605
606                 timeout.tv_sec = WINBINDD_ESTABLISH_LOOP;
607                 timeout.tv_usec = 0;
608
609                 if (opt_dual_daemon) {
610                         maxfd = dual_select_setup(&w_fds, maxfd);
611                 }
612
613                 /* Set up client readers and writers */
614
615                 state = winbindd_client_list();
616
617                 while (state) {
618
619                         /* Dispose of client connection if it is marked as 
620                            finished */ 
621
622                         if (state->finished) {
623                                 struct winbindd_cli_state *next = state->next;
624
625                                 remove_client(state);
626                                 state = next;
627                                 continue;
628                         }
629
630                         /* Select requires we know the highest fd used */
631
632                         if (state->sock > maxfd)
633                                 maxfd = state->sock;
634
635                         /* Add fd for reading */
636
637                         if (state->read_buf_len != sizeof(state->request))
638                                 FD_SET(state->sock, &r_fds);
639
640                         /* Add fd for writing */
641
642                         if (state->write_buf_len)
643                                 FD_SET(state->sock, &w_fds);
644
645                         state = state->next;
646                 }
647
648                 /* Call select */
649         
650                 selret = sys_select(maxfd + 1, &r_fds, &w_fds, NULL, &timeout);
651
652                 if (selret == 0)
653                         continue;
654
655                 if ((selret == -1 && errno != EINTR) || selret == 0) {
656
657                         /* Select error, something is badly wrong */
658
659                         perror("select");
660                         exit(1);
661                 }
662
663                 /* Create a new connection if listen_sock readable */
664
665                 if (selret > 0) {
666
667                         if (opt_dual_daemon) {
668                                 dual_select(&w_fds);
669                         }
670
671                         if (FD_ISSET(listen_sock, &r_fds)) {
672                                 while (winbindd_num_clients() > WINBINDD_MAX_SIMULTANEOUS_CLIENTS - 1) {
673                                         DEBUG(5,("winbindd: Exceeding %d client connections, removing idle connection.\n",
674                                                 WINBINDD_MAX_SIMULTANEOUS_CLIENTS));
675                                         if (!remove_idle_client()) {
676                                                 DEBUG(0,("winbindd: Exceeding %d client connections, no idle connection found\n",
677                                                         WINBINDD_MAX_SIMULTANEOUS_CLIENTS));
678                                                 break;
679                                         }
680                                 }
681                                 /* new, non-privileged connection */
682                                 new_connection(listen_sock, False);
683                         }
684             
685                         if (FD_ISSET(listen_priv_sock, &r_fds)) {
686                                 while (winbindd_num_clients() > WINBINDD_MAX_SIMULTANEOUS_CLIENTS - 1) {
687                                         DEBUG(5,("winbindd: Exceeding %d client connections, removing idle connection.\n",
688                                                 WINBINDD_MAX_SIMULTANEOUS_CLIENTS));
689                                         if (!remove_idle_client()) {
690                                                 DEBUG(0,("winbindd: Exceeding %d client connections, no idle connection found\n",
691                                                         WINBINDD_MAX_SIMULTANEOUS_CLIENTS));
692                                                 break;
693                                         }
694                                 }
695                                 /* new, privileged connection */
696                                 new_connection(listen_priv_sock, True);
697                         }
698             
699                         /* Process activity on client connections */
700             
701                         for (state = winbindd_client_list(); state; 
702                              state = state->next) {
703                 
704                                 /* Data available for reading */
705                 
706                                 if (FD_ISSET(state->sock, &r_fds)) {
707                     
708                                         /* Read data */
709                     
710                                         winbind_client_read(state);
711
712                                         /* 
713                                          * If we have the start of a
714                                          * packet, then check the
715                                          * length field to make sure
716                                          * the client's not talking
717                                          * Mock Swedish.
718                                          */
719
720                                         if (state->read_buf_len >= sizeof(uint32)
721                                             && *(uint32 *) &state->request != sizeof(state->request)) {
722                                                 DEBUG(0,("process_loop: Invalid request size from pid %lu: %d bytes sent, should be %d\n",
723                                                                 (unsigned long)state->request.pid, *(uint32 *) &state->request, sizeof(state->request)));
724
725                                                 remove_client(state);
726                                                 break;
727                                         }
728
729                                         /* A request packet might be 
730                                            complete */
731                     
732                                         if (state->read_buf_len == 
733                                             sizeof(state->request)) {
734                                                 winbind_process_packet(state);
735                                         }
736                                 }
737                 
738                                 /* Data available for writing */
739                 
740                                 if (FD_ISSET(state->sock, &w_fds))
741                                         client_write(state);
742                         }
743                 }
744
745 #if 0
746                 winbindd_check_cache_size(time(NULL));
747 #endif
748
749                 /* Check signal handling things */
750
751                 if (do_sigterm)
752                         terminate();
753
754                 if (do_sighup) {
755
756                         DEBUG(3, ("got SIGHUP\n"));
757
758                         msg_reload_services(MSG_SMB_CONF_UPDATED, (pid_t) 0, NULL, 0);
759                         do_sighup = False;
760                 }
761
762                 if (do_sigusr2) {
763                         print_winbindd_status();
764                         do_sigusr2 = False;
765                 }
766         }
767 }
768
769 /* Main function */
770
771 struct winbindd_state server_state;   /* Server state information */
772
773 int main(int argc, char **argv)
774 {
775         pstring logfile;
776         static BOOL interactive = False;
777         static BOOL Fork = True;
778         static BOOL log_stdout = False;
779         struct poptOption long_options[] = {
780                 POPT_AUTOHELP
781                 { "stdout", 'S', POPT_ARG_VAL, &log_stdout, True, "Log to stdout" },
782                 { "foreground", 'F', POPT_ARG_VAL, &Fork, False, "Daemon in foreground mode" },
783                 { "interactive", 'i', POPT_ARG_NONE, NULL, 'i', "Interactive mode" },
784                 { "single-daemon", 'Y', POPT_ARG_VAL, &opt_dual_daemon, False, "Single daemon mode" },
785                 { "no-caching", 'n', POPT_ARG_VAL, &opt_nocache, False, "Disable caching" },
786                 POPT_COMMON_SAMBA
787                 POPT_TABLEEND
788         };
789         poptContext pc;
790         int opt;
791
792         /* glibc (?) likes to print "User defined signal 1" and exit if a
793            SIGUSR[12] is received before a handler is installed */
794
795         CatchSignal(SIGUSR1, SIG_IGN);
796         CatchSignal(SIGUSR2, SIG_IGN);
797
798         fault_setup((void (*)(void *))fault_quit );
799
800         /* Initialise for running in non-root mode */
801
802         sec_init();
803
804         set_remote_machine_name("winbindd", False);
805
806         /* Set environment variable so we don't recursively call ourselves.
807            This may also be useful interactively. */
808
809         setenv(WINBINDD_DONT_ENV, "1", 1);
810
811         /* Initialise samba/rpc client stuff */
812
813         pc = poptGetContext("winbindd", argc, (const char **)argv, long_options,
814                                                 POPT_CONTEXT_KEEP_FIRST);
815
816         while ((opt = poptGetNextOpt(pc)) != -1) {
817                 switch (opt) {
818                         /* Don't become a daemon */
819                 case 'i':
820                         interactive = True;
821                         log_stdout = True;
822                         Fork = False;
823                         break;
824                 }
825         }
826
827
828         if (log_stdout && Fork) {
829                 printf("Can't log to stdout (-S) unless daemon is in foreground +(-F) or interactive (-i)\n");
830                 poptPrintUsage(pc, stderr, 0);
831                 exit(1);
832         }
833
834         pstr_sprintf(logfile, "%s/log.winbindd", dyn_LOGFILEBASE);
835         lp_set_logfile(logfile);
836         setup_logging("winbindd", log_stdout);
837         reopen_logs();
838
839         DEBUG(1, ("winbindd version %s started.\n", SAMBA_VERSION_STRING) );
840         DEBUGADD( 1, ( "Copyright The Samba Team 2000-2003\n" ) );
841
842         if (!reload_services_file(False)) {
843                 DEBUG(0, ("error opening config file\n"));
844                 exit(1);
845         }
846
847         /* Setup names. */
848
849         if (!init_names())
850                 exit(1);
851
852         load_interfaces();
853
854         if (!secrets_init()) {
855
856                 DEBUG(0,("Could not initialize domain trust account secrets. Giving up\n"));
857                 return False;
858         }
859
860         /* Enable netbios namecache */
861
862         namecache_enable();
863
864         /* Check winbindd parameters are valid */
865
866         ZERO_STRUCT(server_state);
867
868         if (!winbindd_param_init())
869                 return 1;
870
871         /* Winbind daemon initialisation */
872
873         if (!winbindd_upgrade_idmap())
874                 return 1;
875
876         if (!idmap_init(lp_idmap_backend()))
877                 return 1;
878
879         /* Unblock all signals we are interested in as they may have been
880            blocked by the parent process. */
881
882         BlockSignals(False, SIGINT);
883         BlockSignals(False, SIGQUIT);
884         BlockSignals(False, SIGTERM);
885         BlockSignals(False, SIGUSR1);
886         BlockSignals(False, SIGUSR2);
887         BlockSignals(False, SIGHUP);
888
889         /* Setup signal handlers */
890         
891         CatchSignal(SIGINT, termination_handler);      /* Exit on these sigs */
892         CatchSignal(SIGQUIT, termination_handler);
893         CatchSignal(SIGTERM, termination_handler);
894
895         CatchSignal(SIGPIPE, SIG_IGN);                 /* Ignore sigpipe */
896
897         CatchSignal(SIGUSR2, sigusr2_handler);         /* Debugging sigs */
898         CatchSignal(SIGHUP, sighup_handler);
899
900         if (!interactive)
901                 become_daemon(Fork);
902
903         pidfile_create("winbindd");
904
905 #if HAVE_SETPGID
906         /*
907          * If we're interactive we want to set our own process group for
908          * signal management.
909          */
910         if (interactive)
911                 setpgid( (pid_t)0, (pid_t)0);
912 #endif
913
914         if (opt_dual_daemon) {
915                 do_dual_daemon();
916         }
917
918         /* Initialise messaging system */
919
920         if (!message_init()) {
921                 DEBUG(0, ("unable to initialise messaging system\n"));
922                 exit(1);
923         }
924         
925         /* React on 'smbcontrol winbindd reload-config' in the same way
926            as to SIGHUP signal */
927         message_register(MSG_SMB_CONF_UPDATED, msg_reload_services);
928         message_register(MSG_SHUTDOWN, msg_shutdown);
929         
930         poptFreeContext(pc);
931
932         netsamlogon_cache_init(); /* Non-critical */
933         
934         /* Loop waiting for requests */
935
936         process_loop();
937
938         trustdom_cache_shutdown();
939
940         return 0;
941 }