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