source3/nsswitch/winbindd.c

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