source/nsswitch/winbindd.c

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