Fix from Michael Steffens <michael_steffens@hp.com> to make signal
[gd/samba-autobuild/.git] / source3 / 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, 2001
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 #include "winbindd.h"
24
25 /* List of all connected clients */
26
27 struct winbindd_cli_state *client_list;
28 static int num_clients;
29 BOOL opt_nocache;
30
31 /* Reload configuration */
32
33 static BOOL reload_services_file(BOOL test)
34 {
35         BOOL ret;
36         pstring logfile;
37
38         if (lp_loaded()) {
39                 pstring fname;
40
41                 pstrcpy(fname,lp_configfile());
42                 if (file_exist(fname,NULL) && !strcsequal(fname,dyn_CONFIGFILE)) {
43                         pstrcpy(dyn_CONFIGFILE,fname);
44                         test = False;
45                 }
46         }
47
48         snprintf(logfile, sizeof(logfile), "%s/log.winbindd", dyn_LOGFILEBASE);
49         lp_set_logfile(logfile);
50
51         reopen_logs();
52         ret = lp_load(dyn_CONFIGFILE,False,False,True);
53
54         snprintf(logfile, sizeof(logfile), "%s/log.winbindd", dyn_LOGFILEBASE);
55         lp_set_logfile(logfile);
56
57         reopen_logs();
58         load_interfaces();
59
60         return(ret);
61 }
62
63 #if DUMP_CORE
64
65 /**************************************************************************** **
66  Prepare to dump a core file - carefully!
67  **************************************************************************** */
68
69 static BOOL dump_core(void)
70 {
71         char *p;
72         pstring dname;
73         pstrcpy( dname, lp_logfile() );
74         if ((p=strrchr(dname,'/')))
75                 *p=0;
76         pstrcat( dname, "/corefiles" );
77         mkdir( dname, 0700 );
78         sys_chown( dname, getuid(), getgid() );
79         chmod( dname, 0700 );
80         if ( chdir(dname) )
81                 return( False );
82         umask( ~(0700) );
83  
84 #ifdef HAVE_GETRLIMIT
85 #ifdef RLIMIT_CORE
86         {
87                 struct rlimit rlp;
88                 getrlimit( RLIMIT_CORE, &rlp );
89                 rlp.rlim_cur = MAX( 4*1024*1024, rlp.rlim_cur );
90                 setrlimit( RLIMIT_CORE, &rlp );
91                 getrlimit( RLIMIT_CORE, &rlp );
92                 DEBUG( 3, ( "Core limits now %d %d\n", (int)rlp.rlim_cur, (int)rlp.rlim_max ) );
93         }
94 #endif
95 #endif
96  
97         DEBUG(0,("Dumping core in %s\n",dname));
98         abort();
99         return( True );
100 } /* dump_core */
101 #endif
102
103 /**************************************************************************** **
104  Handle a fault..
105  **************************************************************************** */
106
107 static void fault_quit(void)
108 {
109 #if DUMP_CORE
110         dump_core();
111 #endif
112 }
113
114 static void winbindd_status(void)
115 {
116         struct winbindd_cli_state *tmp;
117
118         DEBUG(0, ("winbindd status:\n"));
119
120         /* Print client state information */
121         
122         DEBUG(0, ("\t%d clients currently active\n", num_clients));
123         
124         if (DEBUGLEVEL >= 2 && num_clients) {
125                 DEBUG(2, ("\tclient list:\n"));
126                 for(tmp = client_list; tmp; tmp = tmp->next) {
127                         DEBUG(2, ("\t\tpid %d, sock %d, rbl %d, wbl %d\n",
128                                   tmp->pid, tmp->sock, tmp->read_buf_len, 
129                                   tmp->write_buf_len));
130                 }
131         }
132 }
133
134 /* Print winbindd status to log file */
135
136 static void print_winbindd_status(void)
137 {
138         winbindd_status();
139         winbindd_idmap_status();
140         winbindd_cm_status();
141 }
142
143 /* Flush client cache */
144
145 static void flush_caches(void)
146 {
147         /* Clear cached user and group enumation info */        
148         wcache_flush_cache();
149 }
150
151 /* Handle the signal by unlinking socket and exiting */
152
153 static void terminate(void)
154 {
155         pstring path;
156
157         winbindd_idmap_close();
158         
159         /* Remove socket file */
160         snprintf(path, sizeof(path), "%s/%s", 
161                  WINBINDD_SOCKET_DIR, WINBINDD_SOCKET_NAME);
162         unlink(path);
163         exit(0);
164 }
165
166 static BOOL do_sigterm;
167
168 static void termination_handler(int signum)
169 {
170         do_sigterm = True;
171         sys_select_signal();
172 }
173
174 static BOOL do_sigusr2;
175
176 static void sigusr2_handler(int signum)
177 {
178         do_sigusr2 = True;
179         sys_select_signal();
180 }
181
182 static BOOL do_sighup;
183
184 static void sighup_handler(int signum)
185 {
186         do_sighup = True;
187         sys_select_signal();
188 }
189
190 /* Create winbindd socket */
191
192 static int create_sock(void)
193 {
194         return create_pipe_sock( WINBINDD_SOCKET_DIR,
195                                  WINBINDD_SOCKET_NAME, 0755);
196 }
197
198 struct dispatch_table {
199         enum winbindd_cmd cmd;
200         enum winbindd_result (*fn)(struct winbindd_cli_state *state);
201         char *winbindd_cmd_name;
202 };
203
204 static struct dispatch_table dispatch_table[] = {
205         
206         /* User functions */
207
208         { WINBINDD_GETPWNAM, winbindd_getpwnam, "GETPWNAM" },
209         { WINBINDD_GETPWUID, winbindd_getpwuid, "GETPWUID" },
210
211         { WINBINDD_SETPWENT, winbindd_setpwent, "SETPWENT" },
212         { WINBINDD_ENDPWENT, winbindd_endpwent, "ENDPWENT" },
213         { WINBINDD_GETPWENT, winbindd_getpwent, "GETPWENT" },
214
215         { WINBINDD_GETGROUPS, winbindd_getgroups, "GETGROUPS" },
216
217         /* Group functions */
218
219         { WINBINDD_GETGRNAM, winbindd_getgrnam, "GETGRNAM" },
220         { WINBINDD_GETGRGID, winbindd_getgrgid, "GETGRGID" },
221         { WINBINDD_SETGRENT, winbindd_setgrent, "SETGRENT" },
222         { WINBINDD_ENDGRENT, winbindd_endgrent, "ENDGRENT" },
223         { WINBINDD_GETGRENT, winbindd_getgrent, "GETGRENT" },
224
225         /* PAM auth functions */
226
227         { WINBINDD_PAM_AUTH, winbindd_pam_auth, "PAM_AUTH" },
228         { WINBINDD_PAM_AUTH_CRAP, winbindd_pam_auth_crap, "AUTH_CRAP" },
229         { WINBINDD_PAM_CHAUTHTOK, winbindd_pam_chauthtok, "CHAUTHTOK" },
230
231         /* Enumeration functions */
232
233         { WINBINDD_LIST_USERS, winbindd_list_users, "LIST_USERS" },
234         { WINBINDD_LIST_GROUPS, winbindd_list_groups, "LIST_GROUPS" },
235         { WINBINDD_LIST_TRUSTDOM, winbindd_list_trusted_domains, "LIST_TRUSTDOM" },
236         { WINBINDD_SHOW_SEQUENCE, winbindd_show_sequence, "SHOW_SEQUENCE" },
237
238         /* SID related functions */
239
240         { WINBINDD_LOOKUPSID, winbindd_lookupsid, "LOOKUPSID" },
241         { WINBINDD_LOOKUPNAME, winbindd_lookupname, "LOOKUPNAME" },
242
243         /* Lookup related functions */
244
245         { WINBINDD_SID_TO_UID, winbindd_sid_to_uid, "SID_TO_UID" },
246         { WINBINDD_SID_TO_GID, winbindd_sid_to_gid, "SID_TO_GID" },
247         { WINBINDD_GID_TO_SID, winbindd_gid_to_sid, "GID_TO_SID" },
248         { WINBINDD_UID_TO_SID, winbindd_uid_to_sid, "UID_TO_SID" },
249
250         /* Miscellaneous */
251
252         { WINBINDD_CHECK_MACHACC, winbindd_check_machine_acct, "CHECK_MACHACC" },
253         { WINBINDD_PING, winbindd_ping, "PING" },
254         { WINBINDD_INFO, winbindd_info, "INFO" },
255         { WINBINDD_INTERFACE_VERSION, winbindd_interface_version, "INTERFACE_VERSION" },
256         { WINBINDD_DOMAIN_NAME, winbindd_domain_name, "DOMAIN_NAME" },
257
258         /* End of list */
259
260         { WINBINDD_NUM_CMDS, NULL, "NONE" }
261 };
262
263 static void process_request(struct winbindd_cli_state *state)
264 {
265         struct dispatch_table *table = dispatch_table;
266
267         /* Free response data - we may be interrupted and receive another
268            command before being able to send this data off. */
269
270         SAFE_FREE(state->response.extra_data);  
271
272         ZERO_STRUCT(state->response);
273
274         state->response.result = WINBINDD_ERROR;
275         state->response.length = sizeof(struct winbindd_response);
276
277         /* Process command */
278
279         for (table = dispatch_table; table->fn; table++) {
280                 if (state->request.cmd == table->cmd) {
281                         DEBUG(10,("process_request: request fn %s\n", table->winbindd_cmd_name ));
282                         state->response.result = table->fn(state);
283                         break;
284                 }
285         }
286
287         if (!table->fn)
288                 DEBUG(10,("process_request: unknown request fn number %d\n", (int)state->request.cmd ));
289
290         /* In case extra data pointer is NULL */
291
292         if (!state->response.extra_data)
293                 state->response.length = sizeof(struct winbindd_response);
294 }
295
296 /* Process a new connection by adding it to the client connection list */
297
298 static void new_connection(int accept_sock)
299 {
300         struct sockaddr_un sunaddr;
301         struct winbindd_cli_state *state;
302         socklen_t len;
303         int sock;
304         
305         /* Accept connection */
306         
307         len = sizeof(sunaddr);
308
309         do {
310                 sock = accept(accept_sock, (struct sockaddr *)&sunaddr, &len);
311         } while (sock == -1 && errno == EINTR);
312
313         if (sock == -1)
314                 return;
315         
316         DEBUG(6,("accepted socket %d\n", sock));
317         
318         /* Create new connection structure */
319         
320         if ((state = (struct winbindd_cli_state *) 
321              malloc(sizeof(*state))) == NULL)
322                 return;
323         
324         ZERO_STRUCTP(state);
325         state->sock = sock;
326         
327         /* Add to connection list */
328         
329         DLIST_ADD(client_list, state);
330         num_clients++;
331 }
332
333 /* Remove a client connection from client connection list */
334
335 static void remove_client(struct winbindd_cli_state *state)
336 {
337         /* It's a dead client - hold a funeral */
338         
339         if (state != NULL) {
340                 
341                 /* Close socket */
342                 
343                 close(state->sock);
344                 
345                 /* Free any getent state */
346                 
347                 free_getent_state(state->getpwent_state);
348                 free_getent_state(state->getgrent_state);
349                 
350                 /* We may have some extra data that was not freed if the
351                    client was killed unexpectedly */
352
353                 SAFE_FREE(state->response.extra_data);
354                 
355                 /* Remove from list and free */
356                 
357                 DLIST_REMOVE(client_list, state);
358                 SAFE_FREE(state);
359                 num_clients--;
360         }
361 }
362
363 /* Process a complete received packet from a client */
364
365 static void process_packet(struct winbindd_cli_state *state)
366 {
367         /* Process request */
368         
369         state->pid = state->request.pid;
370         
371         process_request(state);
372
373         /* Update client state */
374         
375         state->read_buf_len = 0;
376         state->write_buf_len = sizeof(struct winbindd_response);
377 }
378
379 /* Read some data from a client connection */
380
381 static void client_read(struct winbindd_cli_state *state)
382 {
383         int n;
384     
385         /* Read data */
386
387         do {
388
389                 n = read(state->sock, state->read_buf_len + 
390                          (char *)&state->request, 
391                          sizeof(state->request) - state->read_buf_len);
392
393         } while (n == -1 && errno == EINTR);
394         
395         DEBUG(10,("client_read: read %d bytes. Need %d more for a full request.\n", n, sizeof(state->request) - n - state->read_buf_len ));
396
397         /* Read failed, kill client */
398         
399         if (n == -1 || n == 0) {
400                 DEBUG(5,("read failed on sock %d, pid %d: %s\n",
401                          state->sock, state->pid, 
402                          (n == -1) ? strerror(errno) : "EOF"));
403                 
404                 state->finished = True;
405                 return;
406         }
407         
408         /* Update client state */
409         
410         state->read_buf_len += n;
411 }
412
413 /* Write some data to a client connection */
414
415 static void client_write(struct winbindd_cli_state *state)
416 {
417         char *data;
418         int num_written;
419         
420         /* Write some data */
421         
422         if (!state->write_extra_data) {
423
424                 /* Write response structure */
425                 
426                 data = (char *)&state->response + sizeof(state->response) - 
427                         state->write_buf_len;
428
429         } else {
430
431                 /* Write extra data */
432                 
433                 data = (char *)state->response.extra_data + 
434                         state->response.length - 
435                         sizeof(struct winbindd_response) - 
436                         state->write_buf_len;
437         }
438         
439         do {
440                 num_written = write(state->sock, data, state->write_buf_len);
441         } while (num_written == -1 && errno == EINTR);
442         
443         DEBUG(10,("client_write: wrote %d bytes.\n", num_written ));
444
445         /* Write failed, kill cilent */
446         
447         if (num_written == -1 || num_written == 0) {
448                 
449                 DEBUG(3,("write failed on sock %d, pid %d: %s\n",
450                          state->sock, state->pid, 
451                          (num_written == -1) ? strerror(errno) : "EOF"));
452                 
453                 state->finished = True;
454
455                 SAFE_FREE(state->response.extra_data);
456
457                 return;
458         }
459         
460         /* Update client state */
461         
462         state->write_buf_len -= num_written;
463         
464         /* Have we written all data? */
465         
466         if (state->write_buf_len == 0) {
467                 
468                 /* Take care of extra data */
469                 
470                 if (state->write_extra_data) {
471
472                         SAFE_FREE(state->response.extra_data);
473
474                         state->write_extra_data = False;
475
476                         DEBUG(10,("client_write: client_write: complete response written.\n"));
477
478                 } else if (state->response.length > 
479                            sizeof(struct winbindd_response)) {
480                         
481                         /* Start writing extra data */
482
483                         state->write_buf_len = 
484                                 state->response.length -
485                                 sizeof(struct winbindd_response);
486                         
487                         DEBUG(10,("client_write: need to write %d extra data bytes.\n", (int)state->write_buf_len));
488
489                         state->write_extra_data = True;
490                 }
491         }
492 }
493
494 /* Process incoming clients on accept_sock.  We use a tricky non-blocking,
495    non-forking, non-threaded model which allows us to handle many
496    simultaneous connections while remaining impervious to many denial of
497    service attacks. */
498
499 static void process_loop(int accept_sock)
500 {
501         /* We'll be doing this a lot */
502
503         while (1) {
504                 struct winbindd_cli_state *state;
505                 fd_set r_fds, w_fds;
506                 int maxfd = accept_sock, selret;
507                 struct timeval timeout;
508
509                 /* Free up temporary memory */
510
511                 lp_talloc_free();
512
513                 /* Initialise fd lists for select() */
514
515                 FD_ZERO(&r_fds);
516                 FD_ZERO(&w_fds);
517                 FD_SET(accept_sock, &r_fds);
518
519                 timeout.tv_sec = WINBINDD_ESTABLISH_LOOP;
520                 timeout.tv_usec = 0;
521
522                 /* Set up client readers and writers */
523
524                 state = client_list;
525
526                 while (state) {
527
528                         /* Dispose of client connection if it is marked as 
529                            finished */ 
530
531                         if (state->finished) {
532                                 struct winbindd_cli_state *next = state->next;
533
534                                 remove_client(state);
535                                 state = next;
536                                 continue;
537                         }
538
539                         /* Select requires we know the highest fd used */
540
541                         if (state->sock > maxfd)
542                                 maxfd = state->sock;
543
544                         /* Add fd for reading */
545
546                         if (state->read_buf_len != sizeof(state->request))
547                                 FD_SET(state->sock, &r_fds);
548
549                         /* Add fd for writing */
550
551                         if (state->write_buf_len)
552                                 FD_SET(state->sock, &w_fds);
553
554                         state = state->next;
555                 }
556
557                 /* Call select */
558         
559                 selret = sys_select(maxfd + 1, &r_fds, &w_fds, NULL, &timeout);
560
561                 if (selret == 0)
562                         continue;
563
564                 if ((selret == -1 && errno != EINTR) || selret == 0) {
565
566                         /* Select error, something is badly wrong */
567
568                         perror("select");
569                         exit(1);
570                 }
571
572                 /* Create a new connection if accept_sock readable */
573
574                 if (selret > 0) {
575
576                         if (FD_ISSET(accept_sock, &r_fds))
577                                 new_connection(accept_sock);
578             
579                         /* Process activity on client connections */
580             
581                         for (state = client_list; state; state = state->next) {
582                 
583                                 /* Data available for reading */
584                 
585                                 if (FD_ISSET(state->sock, &r_fds)) {
586                     
587                                         /* Read data */
588                     
589                                         client_read(state);
590
591                                         /* 
592                                          * If we have the start of a
593                                          * packet, then check the
594                                          * length field to make sure
595                                          * the client's not talking
596                                          * Mock Swedish.
597                                          */
598
599                                         if (state->read_buf_len >= sizeof(uint32)
600                                             && *(uint32 *) &state->request != sizeof(state->request)) {
601                                                 DEBUG(0,("process_loop: Invalid request size (%d) send, should be (%d)\n",
602                                                                 *(uint32 *) &state->request, sizeof(state->request)));
603
604                                                 remove_client(state);
605                                                 break;
606                                         }
607
608                                         /* A request packet might be 
609                                            complete */
610                     
611                                         if (state->read_buf_len == 
612                                             sizeof(state->request)) {
613                                                 process_packet(state);
614                                         }
615                                 }
616                 
617                                 /* Data available for writing */
618                 
619                                 if (FD_ISSET(state->sock, &w_fds))
620                                         client_write(state);
621                         }
622                 }
623
624                 /* Check signal handling things */
625
626                 if (do_sigterm)
627                         terminate();
628
629                 if (do_sighup) {
630
631                         /* Flush winbindd cache */
632
633                         flush_caches();
634                         reload_services_file(True);
635                         do_sighup = False;
636                 }
637
638                 if (do_sigusr2) {
639                         print_winbindd_status();
640                         do_sigusr2 = False;
641                 }
642         }
643 }
644
645 /* Main function */
646
647 struct winbindd_state server_state;   /* Server state information */
648
649 int main(int argc, char **argv)
650 {
651         extern pstring global_myname;
652         extern fstring global_myworkgroup;
653         extern BOOL append_log;
654         pstring logfile;
655         int accept_sock;
656         BOOL interactive = False;
657         int opt, new_debuglevel = -1;
658
659         /* glibc (?) likes to print "User defined signal 1" and exit if a
660            SIGUSR2 is received before a handler is installed */
661
662         CatchSignal(SIGUSR2, SIG_IGN);
663
664         fault_setup((void (*)(void *))fault_quit );
665
666         /* Append to log file by default as we are a single process daemon
667            program. */
668
669         append_log = True;
670
671         snprintf(logfile, sizeof(logfile), "%s/log.winbindd", dyn_LOGFILEBASE);
672         lp_set_logfile(logfile);
673
674         /* Initialise for running in non-root mode */
675
676         sec_init();
677
678         /* Set environment variable so we don't recursively call ourselves.
679            This may also be useful interactively. */
680
681         SETENV(WINBINDD_DONT_ENV, "1", 1);
682
683         /* Initialise samba/rpc client stuff */
684
685         while ((opt = getopt(argc, argv, "id:s:n")) != EOF) {
686                 switch (opt) {
687
688                         /* Don't become a daemon */
689                 case 'i':
690                         interactive = True;
691                         break;
692
693                         /* disable cacheing */
694                 case 'n':
695                         opt_nocache = True;
696                         break;
697
698                         /* Run with specified debug level */
699                 case 'd':
700                         new_debuglevel = atoi(optarg);
701                         break;
702
703                         /* Load a different smb.conf file */
704                 case 's':
705                         pstrcpy(dyn_CONFIGFILE,optarg);
706                         break;
707
708                 default:
709                         printf("Unknown option %c\n", (char)opt);
710                         exit(1);
711                 }
712         }
713
714         snprintf(logfile, sizeof(logfile), "%s/log.winbindd", dyn_LOGFILEBASE);
715         lp_set_logfile(logfile);
716         setup_logging("winbindd", interactive);
717         reopen_logs();
718
719         DEBUG(1, ("winbindd version %s started.\n", VERSION ) );
720         DEBUGADD( 1, ( "Copyright The Samba Team 2000-2001\n" ) );
721
722         if (!reload_services_file(False)) {
723                 DEBUG(0, ("error opening config file\n"));
724                 exit(1);
725         }
726
727         pidfile_create("winbindd");
728
729         /* Setup names. */
730
731         if (!*global_myname) {
732                 char *p;
733
734                 fstrcpy(global_myname, myhostname());
735                 p = strchr(global_myname, '.');
736                 if (p)
737                         *p = 0;
738         }
739
740         fstrcpy(global_myworkgroup, lp_workgroup());
741
742         if (new_debuglevel != -1)
743                 DEBUGLEVEL = new_debuglevel;
744
745         if (!interactive)
746                 become_daemon();
747
748 #if HAVE_SETPGID
749         /*
750          * If we're interactive we want to set our own process group for
751          * signal management.
752          */
753         if (interactive)
754                 setpgid( (pid_t)0, (pid_t)0);
755 #endif
756
757         load_interfaces();
758
759         secrets_init();
760
761         /* Get list of domains we look up requests for.  This includes the
762            domain which we are a member of as well as any trusted
763            domains. */ 
764
765         init_domain_list();
766
767         ZERO_STRUCT(server_state);
768
769         /* Winbind daemon initialisation */
770
771         if (!winbindd_param_init())
772                 return 1;
773
774         if (!winbindd_idmap_init())
775                 return 1;
776
777         /* Unblock all signals we are interested in as they may have been
778            blocked by the parent process. */
779
780         BlockSignals(False, SIGINT);
781         BlockSignals(False, SIGQUIT);
782         BlockSignals(False, SIGTERM);
783         BlockSignals(False, SIGUSR2);
784         BlockSignals(False, SIGHUP);
785
786         /* Setup signal handlers */
787         
788         CatchSignal(SIGINT, termination_handler);      /* Exit on these sigs */
789         CatchSignal(SIGQUIT, termination_handler);
790         CatchSignal(SIGTERM, termination_handler);
791
792         CatchSignal(SIGPIPE, SIG_IGN);                 /* Ignore sigpipe */
793         CatchSignal(SIGUSR1, SIG_IGN);                 /* Samba messages */
794
795         CatchSignal(SIGUSR2, sigusr2_handler);         /* Debugging sigs */
796         CatchSignal(SIGHUP, sighup_handler);
797
798         /* Create UNIX domain socket */
799         
800         if ((accept_sock = create_sock()) == -1) {
801                 DEBUG(0, ("failed to create socket\n"));
802                 return 1;
803         }
804
805         /* Loop waiting for requests */
806
807         process_loop(accept_sock);
808
809         uni_group_cache_shutdown();
810         return 0;
811 }