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                 /* Handle messages */
 510
 511                 message_dispatch();
 512
 513                 /* Free up temporary memory */
 514
 515                 lp_talloc_free();
 516                 main_loop_talloc_free();
 517
 518                 /* Initialise fd lists for select() */
 519
 520                 FD_ZERO(&r_fds);
 521                 FD_ZERO(&w_fds);
 522                 FD_SET(accept_sock, &r_fds);
 523
 524                 timeout.tv_sec = WINBINDD_ESTABLISH_LOOP;
 525                 timeout.tv_usec = 0;
 526
 527                 /* Set up client readers and writers */
 528
 529                 state = client_list;
 530
 531                 while (state) {
 532
 533                         /* Dispose of client connection if it is marked as
 534                            finished */
 535
 536                         if (state->finished) {
 537                                 struct winbindd_cli_state *next = state->next;
 538
 539                                 remove_client(state);
 540                                 state = next;
 541                                 continue;
 542                         }
 543
 544                         /* Select requires we know the highest fd used */
 545
 546                         if (state->sock > maxfd)
 547                                 maxfd = state->sock;
 548
 549                         /* Add fd for reading */
 550
 551                         if (state->read_buf_len != sizeof(state->request))
 552                                 FD_SET(state->sock, &r_fds);
 553
 554                         /* Add fd for writing */
 555
 556                         if (state->write_buf_len)
 557                                 FD_SET(state->sock, &w_fds);
 558
 559                         state = state->next;
 560                 }
 561
 562                 /* Call select */
 563
 564                 selret = sys_select(maxfd + 1, &r_fds, &w_fds, NULL, &timeout);
 565
 566                 if (selret == 0)
 567                         continue;
 568
 569                 if ((selret == -1 && errno != EINTR) || selret == 0) {
 570
 571                         /* Select error, something is badly wrong */
 572
 573                         perror("select");
 574                         exit(1);
 575                 }
 576
 577                 /* Create a new connection if accept_sock readable */
 578
 579                 if (selret > 0) {
 580
 581                         if (FD_ISSET(accept_sock, &r_fds))
 582                                 new_connection(accept_sock);
 583
 584                         /* Process activity on client connections */
 585
 586                         for (state = client_list; state; state = state->next) {
 587
 588                                 /* Data available for reading */
 589
 590                                 if (FD_ISSET(state->sock, &r_fds)) {
 591
 592                                         /* Read data */
 593
 594                                         client_read(state);
 595
 596                                         /*
 597                                          * If we have the start of a
 598                                          * packet, then check the
 599                                          * length field to make sure
 600                                          * the client's not talking
 601                                          * Mock Swedish.
 602                                          */
 603
 604                                         if (state->read_buf_len >= sizeof(uint32)
 605                                             && *(uint32 *) &state->request != sizeof(state->request)) {
 606                                                 DEBUG(0,("process_loop: Invalid request size (%d) send, should be (%d)\n",
 607                                                                 *(uint32 *) &state->request, sizeof(state->request)));
 608
 609                                                 remove_client(state);
 610                                                 break;
 611                                         }
 612
 613                                         /* A request packet might be
 614                                            complete */
 615
 616                                         if (state->read_buf_len ==
 617                                             sizeof(state->request)) {
 618                                                 process_packet(state);
 619                                         }
 620                                 }
 621
 622                                 /* Data available for writing */
 623
 624                                 if (FD_ISSET(state->sock, &w_fds))
 625                                         client_write(state);
 626                         }
 627                 }
 628
 629                 /* Check signal handling things */
 630
 631                 if (do_sigterm)
 632                         terminate();
 633
 634                 if (do_sighup) {
 635
 636                         /* Flush winbindd cache */
 637
 638                         flush_caches();
 639                         reload_services_file(True);
 640                         do_sighup = False;
 641                 }
 642
 643                 if (do_sigusr2) {
 644                         print_winbindd_status();
 645                         do_sigusr2 = False;
 646                 }
 647         }
 648 }
 649
 650 /* Main function */
 651
 652 struct winbindd_state server_state;   /* Server state information */
 653
 654
 655 static void usage(void)
 656 {
 657         printf("Usage: winbindd [options]\n");
 658         printf("\t-i                interactive mode\n");
 659         printf("\t-n                disable cacheing\n");
 660         printf("\t-d level          set debug level\n");
 661         printf("\t-s configfile     choose smb.conf location\n");
 662         printf("\t-h                show this help message\n");
 663 }
 664
 665 int main(int argc, char **argv)
 666 {
 667         extern BOOL AllowDebugChange;
 668         extern pstring global_myname;
 669         extern fstring global_myworkgroup;
 670         extern BOOL append_log;
 671         pstring logfile;
 672         int accept_sock;
 673         BOOL interactive = False;
 674         int opt;
 675
 676         /* glibc (?) likes to print "User defined signal 1" and exit if a
 677            SIGUSR[12] is received before a handler is installed */
 678
 679         CatchSignal(SIGUSR1, SIG_IGN);
 680         CatchSignal(SIGUSR2, SIG_IGN);
 681
 682         fault_setup((void (*)(void *))fault_quit );
 683
 684         /* Append to log file by default as we are a single process daemon
 685            program. */
 686
 687         append_log = True;
 688
 689         snprintf(logfile, sizeof(logfile), "%s/log.winbindd", dyn_LOGFILEBASE);
 690         lp_set_logfile(logfile);
 691
 692         /* Initialise for running in non-root mode */
 693
 694         sec_init();
 695
 696         /* Set environment variable so we don't recursively call ourselves.
 697            This may also be useful interactively. */
 698
 699         SETENV(WINBINDD_DONT_ENV, "1", 1);
 700
 701         /* Initialise samba/rpc client stuff */
 702
 703         while ((opt = getopt(argc, argv, "id:s:nh")) != EOF) {
 704                 switch (opt) {
 705
 706                         /* Don't become a daemon */
 707                 case 'i':
 708                         interactive = True;
 709                         break;
 710
 711                         /* disable cacheing */
 712                 case 'n':
 713                         opt_nocache = True;
 714                         break;
 715
 716                         /* Run with specified debug level */
 717                 case 'd':
 718                         DEBUGLEVEL = atoi(optarg);
 719                         AllowDebugChange = False;
 720                         break;
 721
 722                         /* Load a different smb.conf file */
 723                 case 's':
 724                         pstrcpy(dyn_CONFIGFILE,optarg);
 725                         break;
 726
 727                 case 'h':
 728                         usage();
 729                         exit(0);
 730
 731                 default:
 732                         printf("Unknown option %c\n", (char)opt);
 733                         exit(1);
 734                 }
 735         }
 736
 737         snprintf(logfile, sizeof(logfile), "%s/log.winbindd", dyn_LOGFILEBASE);
 738         lp_set_logfile(logfile);
 739         setup_logging("winbindd", interactive);
 740         reopen_logs();
 741
 742         DEBUG(1, ("winbindd version %s started.\n", VERSION ) );
 743         DEBUGADD( 1, ( "Copyright The Samba Team 2000-2001\n" ) );
 744
 745         if (!reload_services_file(False)) {
 746                 DEBUG(0, ("error opening config file\n"));
 747                 exit(1);
 748         }
 749
 750         pidfile_create("winbindd");
 751
 752         /* Setup names. */
 753
 754         if (!*global_myname) {
 755                 char *p;
 756
 757                 fstrcpy(global_myname, myhostname());
 758                 p = strchr(global_myname, '.');
 759                 if (p)
 760                         *p = 0;
 761         }
 762
 763         fstrcpy(global_myworkgroup, lp_workgroup());
 764
 765         if (!interactive)
 766                 become_daemon();
 767
 768 #if HAVE_SETPGID
 769         /*
 770          * If we're interactive we want to set our own process group for
 771          * signal management.
 772          */
 773         if (interactive)
 774                 setpgid( (pid_t)0, (pid_t)0);
 775 #endif
 776
 777         load_interfaces();
 778
 779         secrets_init();
 780
 781         /* Get list of domains we look up requests for.  This includes the
 782            domain which we are a member of as well as any trusted
 783            domains. */
 784
 785         init_domain_list();
 786
 787         ZERO_STRUCT(server_state);
 788
 789         /* Winbind daemon initialisation */
 790
 791         if (!winbindd_param_init())
 792                 return 1;
 793
 794         if (!winbindd_idmap_init())
 795                 return 1;
 796
 797         /* Unblock all signals we are interested in as they may have been
 798            blocked by the parent process. */
 799
 800         BlockSignals(False, SIGINT);
 801         BlockSignals(False, SIGQUIT);
 802         BlockSignals(False, SIGTERM);
 803         BlockSignals(False, SIGUSR1);
 804         BlockSignals(False, SIGUSR2);
 805         BlockSignals(False, SIGHUP);
 806
 807         /* Setup signal handlers */
 808
 809         CatchSignal(SIGINT, termination_handler);      /* Exit on these sigs */
 810         CatchSignal(SIGQUIT, termination_handler);
 811         CatchSignal(SIGTERM, termination_handler);
 812
 813         CatchSignal(SIGPIPE, SIG_IGN);                 /* Ignore sigpipe */
 814
 815         CatchSignal(SIGUSR2, sigusr2_handler);         /* Debugging sigs */
 816         CatchSignal(SIGHUP, sighup_handler);
 817
 818         /* Initialise messaging system */
 819
 820         if (!message_init()) {
 821                 DEBUG(0, ("unable to initialise messaging system\n"));
 822                 exit(1);
 823         }
 824
 825         register_msg_pool_usage();
 826
 827         /* Create UNIX domain socket */
 828
 829         if ((accept_sock = create_sock()) == -1) {
 830                 DEBUG(0, ("failed to create socket\n"));
 831                 return 1;
 832         }
 833
 834         /* Loop waiting for requests */
 835
 836         process_loop(accept_sock);
 837
 838         uni_group_cache_shutdown();
 839         return 0;
 840 }