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 Copyright (C) Volker Lendecke 2004 10 11 This program is free software; you can redistribute it and/or modify 12 it under the terms of the GNU General Public License as published by 13 the Free Software Foundation; either version 3 of the License, or 14 (at your option) any later version. 15 16 This program is distributed in the hope that it will be useful, 17 but WITHOUT ANY WARRANTY; without even the implied warranty of 18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 GNU General Public License for more details. 20 21 You should have received a copy of the GNU General Public License 22 along with this program. If not, see <http://www.gnu.org/licenses/>. 23*/ 24 25#include "includes.h" 26#include "winbindd.h" 27#include "../../nsswitch/libwbclient/wbc_async.h" 28 29#undef DBGC_CLASS 30#define DBGC_CLASS DBGC_WINBIND 31 32static void remove_client(struct winbindd_cli_state *state); 33 34static bool opt_nocache = False; 35static bool interactive = False; 36 37extern bool override_logfile; 38 39struct event_context *winbind_event_context(void) 40{ 41 static struct event_context *ctx; 42 43 if (!ctx && !(ctx = event_context_init(NULL))) { 44 smb_panic("Could not init winbind event context"); 45 } 46 return ctx; 47} 48 49struct messaging_context *winbind_messaging_context(void) 50{ 51 static struct messaging_context *ctx; 52 53 if (ctx == NULL) { 54 ctx = messaging_init(NULL, server_id_self(), 55 winbind_event_context()); 56 } 57 if (ctx == NULL) { 58 DEBUG(0, ("Could not init winbind messaging context.\n")); 59 } 60 return ctx; 61} 62 63/* Reload configuration */ 64 65static bool reload_services_file(const char *lfile) 66{ 67 bool ret; 68 69 if (lp_loaded()) { 70 const char *fname = lp_configfile(); 71 72 if (file_exist(fname) && !strcsequal(fname,get_dyn_CONFIGFILE())) { 73 set_dyn_CONFIGFILE(fname); 74 } 75 } 76 77 /* if this is a child, restore the logfile to the special 78 name - <domain>, idmap, etc. */ 79 if (lfile && *lfile) { 80 lp_set_logfile(lfile); 81 } 82 83 reopen_logs(); 84 ret = lp_load(get_dyn_CONFIGFILE(),False,False,True,True); 85 86 reopen_logs(); 87 load_interfaces(); 88 89 return(ret); 90} 91 92 93/**************************************************************************** ** 94 Handle a fault.. 95 **************************************************************************** */ 96 97static void fault_quit(void) 98{ 99 dump_core(); 100} 101 102static void winbindd_status(void) 103{ 104 struct winbindd_cli_state *tmp; 105 106 DEBUG(0, ("winbindd status:\n")); 107 108 /* Print client state information */ 109 110 DEBUG(0, ("\t%d clients currently active\n", winbindd_num_clients())); 111 112 if (DEBUGLEVEL >= 2 && winbindd_num_clients()) { 113 DEBUG(2, ("\tclient list:\n")); 114 for(tmp = winbindd_client_list(); tmp; tmp = tmp->next) { 115 DEBUGADD(2, ("\t\tpid %lu, sock %d\n", 116 (unsigned long)tmp->pid, tmp->sock)); 117 } 118 } 119} 120 121/* Print winbindd status to log file */ 122 123static void print_winbindd_status(void) 124{ 125 winbindd_status(); 126} 127 128/* Flush client cache */ 129 130static void flush_caches(void) 131{ 132 /* We need to invalidate cached user list entries on a SIGHUP 133 otherwise cached access denied errors due to restrict anonymous 134 hang around until the sequence number changes. */ 135 136 if (!wcache_invalidate_cache()) { 137 DEBUG(0, ("invalidating the cache failed; revalidate the cache\n")); 138 if (!winbindd_cache_validate_and_initialize()) { 139 exit(1); 140 } 141 } 142} 143 144/* Handle the signal by unlinking socket and exiting */ 145 146static void terminate(bool is_parent) 147{ 148 if (is_parent) { 149 /* When parent goes away we should 150 * remove the socket file. Not so 151 * when children terminate. 152 */ 153 char *path = NULL; 154 155 if (asprintf(&path, "%s/%s", 156 get_winbind_pipe_dir(), WINBINDD_SOCKET_NAME) > 0) { 157 unlink(path); 158 SAFE_FREE(path); 159 } 160 } 161 162 idmap_close(); 163 164 trustdom_cache_shutdown(); 165 166 gencache_stabilize(); 167 168#if 0 169 if (interactive) { 170 TALLOC_CTX *mem_ctx = talloc_init("end_description"); 171 char *description = talloc_describe_all(mem_ctx); 172 173 DEBUG(3, ("tallocs left:\n%s\n", description)); 174 talloc_destroy(mem_ctx); 175 } 176#endif 177 178 if (is_parent) { 179 pidfile_unlink(); 180 } 181 182 exit(0); 183} 184 185static void winbindd_sig_term_handler(struct tevent_context *ev, 186 struct tevent_signal *se, 187 int signum, 188 int count, 189 void *siginfo, 190 void *private_data) 191{ 192 bool *is_parent = talloc_get_type_abort(private_data, bool); 193 194 DEBUG(0,("Got sig[%d] terminate (is_parent=%d)\n", 195 signum, (int)*is_parent)); 196 terminate(*is_parent); 197} 198 199bool winbindd_setup_sig_term_handler(bool parent) 200{ 201 struct tevent_signal *se; 202 bool *is_parent; 203 204 is_parent = talloc(winbind_event_context(), bool); 205 if (!is_parent) { 206 return false; 207 } 208 209 *is_parent = parent; 210 211 se = tevent_add_signal(winbind_event_context(), 212 is_parent, 213 SIGTERM, 0, 214 winbindd_sig_term_handler, 215 is_parent); 216 if (!se) { 217 DEBUG(0,("failed to setup SIGTERM handler")); 218 talloc_free(is_parent); 219 return false; 220 } 221 222 se = tevent_add_signal(winbind_event_context(), 223 is_parent, 224 SIGINT, 0, 225 winbindd_sig_term_handler, 226 is_parent); 227 if (!se) { 228 DEBUG(0,("failed to setup SIGINT handler")); 229 talloc_free(is_parent); 230 return false; 231 } 232 233 se = tevent_add_signal(winbind_event_context(), 234 is_parent, 235 SIGQUIT, 0, 236 winbindd_sig_term_handler, 237 is_parent); 238 if (!se) { 239 DEBUG(0,("failed to setup SIGINT handler")); 240 talloc_free(is_parent); 241 return false; 242 } 243 244 return true; 245} 246 247static void winbindd_sig_hup_handler(struct tevent_context *ev, 248 struct tevent_signal *se, 249 int signum, 250 int count, 251 void *siginfo, 252 void *private_data) 253{ 254 const char *file = (const char *)private_data; 255 256 DEBUG(1,("Reloading services after SIGHUP\n")); 257 flush_caches(); 258 reload_services_file(file); 259} 260 261bool winbindd_setup_sig_hup_handler(const char *lfile) 262{ 263 struct tevent_signal *se; 264 char *file = NULL; 265 266 if (lfile) { 267 file = talloc_strdup(winbind_event_context(), 268 lfile); 269 if (!file) { 270 return false; 271 } 272 } 273 274 se = tevent_add_signal(winbind_event_context(), 275 winbind_event_context(), 276 SIGHUP, 0, 277 winbindd_sig_hup_handler, 278 file); 279 if (!se) { 280 return false; 281 } 282 283 return true; 284} 285 286static void winbindd_sig_chld_handler(struct tevent_context *ev, 287 struct tevent_signal *se, 288 int signum, 289 int count, 290 void *siginfo, 291 void *private_data) 292{ 293 pid_t pid; 294 295 while ((pid = sys_waitpid(-1, NULL, WNOHANG)) > 0) { 296 winbind_child_died(pid); 297 } 298} 299 300static bool winbindd_setup_sig_chld_handler(void) 301{ 302 struct tevent_signal *se; 303 304 se = tevent_add_signal(winbind_event_context(), 305 winbind_event_context(), 306 SIGCHLD, 0, 307 winbindd_sig_chld_handler, 308 NULL); 309 if (!se) { 310 return false; 311 } 312 313 return true; 314} 315 316static void winbindd_sig_usr2_handler(struct tevent_context *ev, 317 struct tevent_signal *se, 318 int signum, 319 int count, 320 void *siginfo, 321 void *private_data) 322{ 323 print_winbindd_status(); 324} 325 326static bool winbindd_setup_sig_usr2_handler(void) 327{ 328 struct tevent_signal *se; 329 330 se = tevent_add_signal(winbind_event_context(), 331 winbind_event_context(), 332 SIGUSR2, 0, 333 winbindd_sig_usr2_handler, 334 NULL); 335 if (!se) { 336 return false; 337 } 338 339 return true; 340} 341 342/* React on 'smbcontrol winbindd reload-config' in the same way as on SIGHUP*/ 343static void msg_reload_services(struct messaging_context *msg, 344 void *private_data, 345 uint32_t msg_type, 346 struct server_id server_id, 347 DATA_BLOB *data) 348{ 349 /* Flush various caches */ 350 flush_caches(); 351 reload_services_file((const char *) private_data); 352} 353 354/* React on 'smbcontrol winbindd shutdown' in the same way as on SIGTERM*/ 355static void msg_shutdown(struct messaging_context *msg, 356 void *private_data, 357 uint32_t msg_type, 358 struct server_id server_id, 359 DATA_BLOB *data) 360{ 361 /* only the parent waits for this message */ 362 DEBUG(0,("Got shutdown message\n")); 363 terminate(true); 364} 365 366 367static void winbind_msg_validate_cache(struct messaging_context *msg_ctx, 368 void *private_data, 369 uint32_t msg_type, 370 struct server_id server_id, 371 DATA_BLOB *data) 372{ 373 uint8 ret; 374 pid_t child_pid; 375 376 DEBUG(10, ("winbindd_msg_validate_cache: got validate-cache " 377 "message.\n")); 378 379 /* 380 * call the validation code from a child: 381 * so we don't block the main winbindd and the validation 382 * code can safely use fork/waitpid... 383 */ 384 child_pid = sys_fork(); 385 386 if (child_pid == -1) { 387 DEBUG(1, ("winbind_msg_validate_cache: Could not fork: %s\n", 388 strerror(errno))); 389 return; 390 } 391 392 if (child_pid != 0) { 393 /* parent */ 394 DEBUG(5, ("winbind_msg_validate_cache: child created with " 395 "pid %d.\n", (int)child_pid)); 396 return; 397 } 398 399 /* child */ 400 401 if (!winbindd_reinit_after_fork(NULL)) { 402 _exit(0); 403 } 404 405 /* install default SIGCHLD handler: validation code uses fork/waitpid */ 406 CatchSignal(SIGCHLD, SIG_DFL); 407 408 ret = (uint8)winbindd_validate_cache_nobackup(); 409 DEBUG(10, ("winbindd_msg_validata_cache: got return value %d\n", ret)); 410 messaging_send_buf(msg_ctx, server_id, MSG_WINBIND_VALIDATE_CACHE, &ret, 411 (size_t)1); 412 _exit(0); 413} 414 415static struct winbindd_dispatch_table { 416 enum winbindd_cmd cmd; 417 void (*fn)(struct winbindd_cli_state *state); 418 const char *winbindd_cmd_name; 419} dispatch_table[] = { 420 421 /* PAM auth functions */ 422 423 { WINBINDD_PAM_AUTH, winbindd_pam_auth, "PAM_AUTH" }, 424 { WINBINDD_PAM_AUTH_CRAP, winbindd_pam_auth_crap, "AUTH_CRAP" }, 425 { WINBINDD_PAM_CHAUTHTOK, winbindd_pam_chauthtok, "CHAUTHTOK" }, 426 { WINBINDD_PAM_LOGOFF, winbindd_pam_logoff, "PAM_LOGOFF" }, 427 { WINBINDD_PAM_CHNG_PSWD_AUTH_CRAP, winbindd_pam_chng_pswd_auth_crap, "CHNG_PSWD_AUTH_CRAP" }, 428 429 /* Enumeration functions */ 430 431 { WINBINDD_LIST_TRUSTDOM, winbindd_list_trusted_domains, 432 "LIST_TRUSTDOM" }, 433 434 /* Miscellaneous */ 435 436 { WINBINDD_INFO, winbindd_info, "INFO" }, 437 { WINBINDD_INTERFACE_VERSION, winbindd_interface_version, 438 "INTERFACE_VERSION" }, 439 { WINBINDD_DOMAIN_NAME, winbindd_domain_name, "DOMAIN_NAME" }, 440 { WINBINDD_DOMAIN_INFO, winbindd_domain_info, "DOMAIN_INFO" }, 441 { WINBINDD_NETBIOS_NAME, winbindd_netbios_name, "NETBIOS_NAME" }, 442 { WINBINDD_PRIV_PIPE_DIR, winbindd_priv_pipe_dir, 443 "WINBINDD_PRIV_PIPE_DIR" }, 444 445 /* Credential cache access */ 446 { WINBINDD_CCACHE_NTLMAUTH, winbindd_ccache_ntlm_auth, "NTLMAUTH" }, 447 { WINBINDD_CCACHE_SAVE, winbindd_ccache_save, "CCACHE_SAVE" }, 448 449 /* WINS functions */ 450 451 { WINBINDD_WINS_BYNAME, winbindd_wins_byname, "WINS_BYNAME" }, 452 { WINBINDD_WINS_BYIP, winbindd_wins_byip, "WINS_BYIP" }, 453 454 /* End of list */ 455 456 { WINBINDD_NUM_CMDS, NULL, "NONE" } 457}; 458 459struct winbindd_async_dispatch_table { 460 enum winbindd_cmd cmd; 461 const char *cmd_name; 462 struct tevent_req *(*send_req)(TALLOC_CTX *mem_ctx, 463 struct tevent_context *ev, 464 struct winbindd_cli_state *cli, 465 struct winbindd_request *request); 466 NTSTATUS (*recv_req)(struct tevent_req *req, 467 struct winbindd_response *presp); 468}; 469 470static struct winbindd_async_dispatch_table async_nonpriv_table[] = { 471 { WINBINDD_PING, "PING", 472 wb_ping_send, wb_ping_recv }, 473 { WINBINDD_LOOKUPSID, "LOOKUPSID", 474 winbindd_lookupsid_send, winbindd_lookupsid_recv }, 475 { WINBINDD_LOOKUPNAME, "LOOKUPNAME", 476 winbindd_lookupname_send, winbindd_lookupname_recv }, 477 { WINBINDD_SID_TO_UID, "SID_TO_UID", 478 winbindd_sid_to_uid_send, winbindd_sid_to_uid_recv }, 479 { WINBINDD_SID_TO_GID, "SID_TO_GID", 480 winbindd_sid_to_gid_send, winbindd_sid_to_gid_recv }, 481 { WINBINDD_UID_TO_SID, "UID_TO_SID", 482 winbindd_uid_to_sid_send, winbindd_uid_to_sid_recv }, 483 { WINBINDD_GID_TO_SID, "GID_TO_SID", 484 winbindd_gid_to_sid_send, winbindd_gid_to_sid_recv }, 485 { WINBINDD_GETPWSID, "GETPWSID", 486 winbindd_getpwsid_send, winbindd_getpwsid_recv }, 487 { WINBINDD_GETPWNAM, "GETPWNAM", 488 winbindd_getpwnam_send, winbindd_getpwnam_recv }, 489 { WINBINDD_GETPWUID, "GETPWUID", 490 winbindd_getpwuid_send, winbindd_getpwuid_recv }, 491 { WINBINDD_GETSIDALIASES, "GETSIDALIASES", 492 winbindd_getsidaliases_send, winbindd_getsidaliases_recv }, 493 { WINBINDD_GETUSERDOMGROUPS, "GETUSERDOMGROUPS", 494 winbindd_getuserdomgroups_send, winbindd_getuserdomgroups_recv }, 495 { WINBINDD_GETGROUPS, "GETGROUPS", 496 winbindd_getgroups_send, winbindd_getgroups_recv }, 497 { WINBINDD_SHOW_SEQUENCE, "SHOW_SEQUENCE", 498 winbindd_show_sequence_send, winbindd_show_sequence_recv }, 499 { WINBINDD_GETGRGID, "GETGRGID", 500 winbindd_getgrgid_send, winbindd_getgrgid_recv }, 501 { WINBINDD_GETGRNAM, "GETGRNAM", 502 winbindd_getgrnam_send, winbindd_getgrnam_recv }, 503 { WINBINDD_GETUSERSIDS, "GETUSERSIDS", 504 winbindd_getusersids_send, winbindd_getusersids_recv }, 505 { WINBINDD_LOOKUPRIDS, "LOOKUPRIDS", 506 winbindd_lookuprids_send, winbindd_lookuprids_recv }, 507 { WINBINDD_SETPWENT, "SETPWENT", 508 winbindd_setpwent_send, winbindd_setpwent_recv }, 509 { WINBINDD_GETPWENT, "GETPWENT", 510 winbindd_getpwent_send, winbindd_getpwent_recv }, 511 { WINBINDD_ENDPWENT, "ENDPWENT", 512 winbindd_endpwent_send, winbindd_endpwent_recv }, 513 { WINBINDD_DSGETDCNAME, "DSGETDCNAME", 514 winbindd_dsgetdcname_send, winbindd_dsgetdcname_recv }, 515 { WINBINDD_GETDCNAME, "GETDCNAME", 516 winbindd_getdcname_send, winbindd_getdcname_recv }, 517 { WINBINDD_SETGRENT, "SETGRENT", 518 winbindd_setgrent_send, winbindd_setgrent_recv }, 519 { WINBINDD_GETGRENT, "GETGRENT", 520 winbindd_getgrent_send, winbindd_getgrent_recv }, 521 { WINBINDD_ENDGRENT, "ENDGRENT", 522 winbindd_endgrent_send, winbindd_endgrent_recv }, 523 { WINBINDD_LIST_USERS, "LIST_USERS", 524 winbindd_list_users_send, winbindd_list_users_recv }, 525 { WINBINDD_LIST_GROUPS, "LIST_GROUPS", 526 winbindd_list_groups_send, winbindd_list_groups_recv }, 527 { WINBINDD_CHECK_MACHACC, "CHECK_MACHACC", 528 winbindd_check_machine_acct_send, winbindd_check_machine_acct_recv }, 529 { WINBINDD_PING_DC, "PING_DC", 530 winbindd_ping_dc_send, winbindd_ping_dc_recv }, 531 532 { 0, NULL, NULL, NULL } 533}; 534 535static struct winbindd_async_dispatch_table async_priv_table[] = { 536 { WINBINDD_ALLOCATE_UID, "ALLOCATE_UID", 537 winbindd_allocate_uid_send, winbindd_allocate_uid_recv }, 538 { WINBINDD_ALLOCATE_GID, "ALLOCATE_GID", 539 winbindd_allocate_gid_send, winbindd_allocate_gid_recv }, 540 { WINBINDD_SET_MAPPING, "SET_MAPPING", 541 winbindd_set_mapping_send, winbindd_set_mapping_recv }, 542 { WINBINDD_REMOVE_MAPPING, "SET_MAPPING", 543 winbindd_remove_mapping_send, winbindd_remove_mapping_recv }, 544 { WINBINDD_SET_HWM, "SET_HWM", 545 winbindd_set_hwm_send, winbindd_set_hwm_recv }, 546 { WINBINDD_CHANGE_MACHACC, "CHANGE_MACHACC", 547 winbindd_change_machine_acct_send, winbindd_change_machine_acct_recv }, 548 549 { 0, NULL, NULL, NULL } 550}; 551 552static void wb_request_done(struct tevent_req *req); 553 554static void process_request(struct winbindd_cli_state *state) 555{ 556 struct winbindd_dispatch_table *table = dispatch_table; 557 struct winbindd_async_dispatch_table *atable; 558 559 state->mem_ctx = talloc_init("winbind request"); 560 if (state->mem_ctx == NULL) 561 return; 562 563 /* Remember who asked us. */ 564 state->pid = state->request->pid; 565 566 state->cmd_name = "unknown request"; 567 state->recv_fn = NULL; 568 569 /* Process command */ 570 571 for (atable = async_nonpriv_table; atable->send_req; atable += 1) { 572 if (state->request->cmd == atable->cmd) { 573 break; 574 } 575 } 576 577 if ((atable->send_req == NULL) && state->privileged) { 578 for (atable = async_priv_table; atable->send_req; 579 atable += 1) { 580 if (state->request->cmd == atable->cmd) { 581 break; 582 } 583 } 584 } 585 586 if (atable->send_req != NULL) { 587 struct tevent_req *req; 588 589 state->cmd_name = atable->cmd_name; 590 state->recv_fn = atable->recv_req; 591 592 DEBUG(10, ("process_request: Handling async request %d:%s\n", 593 (int)state->pid, state->cmd_name)); 594 595 req = atable->send_req(state->mem_ctx, winbind_event_context(), 596 state, state->request); 597 if (req == NULL) { 598 DEBUG(0, ("process_request: atable->send failed for " 599 "%s\n", atable->cmd_name)); 600 request_error(state); 601 return; 602 } 603 tevent_req_set_callback(req, wb_request_done, state); 604 return; 605 } 606 607 state->response = talloc_zero(state->mem_ctx, 608 struct winbindd_response); 609 if (state->response == NULL) { 610 DEBUG(10, ("talloc failed\n")); 611 remove_client(state); 612 return; 613 } 614 state->response->result = WINBINDD_PENDING; 615 state->response->length = sizeof(struct winbindd_response); 616 617 for (table = dispatch_table; table->fn; table++) { 618 if (state->request->cmd == table->cmd) { 619 DEBUG(10,("process_request: request fn %s\n", 620 table->winbindd_cmd_name )); 621 state->cmd_name = table->winbindd_cmd_name; 622 table->fn(state); 623 break; 624 } 625 } 626 627 if (!table->fn) { 628 DEBUG(10,("process_request: unknown request fn number %d\n", 629 (int)state->request->cmd )); 630 request_error(state); 631 } 632} 633 634static void wb_request_done(struct tevent_req *req) 635{ 636 struct winbindd_cli_state *state = tevent_req_callback_data( 637 req, struct winbindd_cli_state); 638 NTSTATUS status; 639 640 state->response = talloc_zero(state->mem_ctx, 641 struct winbindd_response); 642 if (state->response == NULL) { 643 DEBUG(0, ("wb_request_done[%d:%s]: talloc_zero failed - removing client\n", 644 (int)state->pid, state->cmd_name)); 645 remove_client(state); 646 return; 647 } 648 state->response->result = WINBINDD_PENDING; 649 state->response->length = sizeof(struct winbindd_response); 650 651 status = state->recv_fn(req, state->response); 652 TALLOC_FREE(req); 653 654 DEBUG(10,("wb_request_done[%d:%s]: %s\n", 655 (int)state->pid, state->cmd_name, nt_errstr(status))); 656 657 if (!NT_STATUS_IS_OK(status)) { 658 request_error(state); 659 return; 660 } 661 request_ok(state); 662} 663 664/* 665 * This is the main event loop of winbind requests. It goes through a 666 * state-machine of 3 read/write requests, 4 if you have extra data to send. 667 * 668 * An idle winbind client has a read request of 4 bytes outstanding, 669 * finalizing function is request_len_recv, checking the length. request_recv 670 * then processes the packet. The processing function then at some point has 671 * to call request_finished which schedules sending the response. 672 */ 673 674static void request_finished(struct winbindd_cli_state *state); 675 676static void winbind_client_request_read(struct tevent_req *req); 677static void winbind_client_response_written(struct tevent_req *req); 678 679static void request_finished(struct winbindd_cli_state *state) 680{ 681 struct tevent_req *req; 682 683 TALLOC_FREE(state->request); 684 685 req = wb_resp_write_send(state, winbind_event_context(), 686 state->out_queue, state->sock, 687 state->response); 688 if (req == NULL) { 689 DEBUG(10,("request_finished[%d:%s]: wb_resp_write_send() failed\n", 690 (int)state->pid, state->cmd_name)); 691 remove_client(state); 692 return; 693 } 694 tevent_req_set_callback(req, winbind_client_response_written, state); 695} 696 697static void winbind_client_response_written(struct tevent_req *req) 698{ 699 struct winbindd_cli_state *state = tevent_req_callback_data( 700 req, struct winbindd_cli_state); 701 ssize_t ret; 702 int err; 703 704 ret = wb_resp_write_recv(req, &err); 705 TALLOC_FREE(req); 706 if (ret == -1) { 707 close(state->sock); 708 state->sock = -1; 709 DEBUG(2, ("Could not write response[%d:%s] to client: %s\n", 710 (int)state->pid, state->cmd_name, strerror(err))); 711 remove_client(state); 712 return; 713 } 714 715 DEBUG(10,("winbind_client_response_written[%d:%s]: deliverd response to client\n", 716 (int)state->pid, state->cmd_name)); 717 718 TALLOC_FREE(state->mem_ctx); 719 state->response = NULL; 720 state->cmd_name = "no request"; 721 state->recv_fn = NULL; 722 723 req = wb_req_read_send(state, winbind_event_context(), state->sock, 724 WINBINDD_MAX_EXTRA_DATA); 725 if (req == NULL) { 726 remove_client(state); 727 return; 728 } 729 tevent_req_set_callback(req, winbind_client_request_read, state); 730} 731 732void request_error(struct winbindd_cli_state *state) 733{ 734 SMB_ASSERT(state->response->result == WINBINDD_PENDING); 735 state->response->result = WINBINDD_ERROR; 736 request_finished(state); 737} 738 739void request_ok(struct winbindd_cli_state *state) 740{ 741 SMB_ASSERT(state->response->result == WINBINDD_PENDING); 742 state->response->result = WINBINDD_OK; 743 request_finished(state); 744} 745 746/* Process a new connection by adding it to the client connection list */ 747 748static void new_connection(int listen_sock, bool privileged) 749{ 750 struct sockaddr_un sunaddr; 751 struct winbindd_cli_state *state; 752 struct tevent_req *req; 753 socklen_t len; 754 int sock; 755 756 /* Accept connection */ 757 758 len = sizeof(sunaddr); 759 760 do { 761 sock = accept(listen_sock, (struct sockaddr *)(void *)&sunaddr, 762 &len); 763 } while (sock == -1 && errno == EINTR); 764 765 if (sock == -1) 766 return; 767 768 DEBUG(6,("accepted socket %d\n", sock)); 769 770 /* Create new connection structure */ 771 772 if ((state = TALLOC_ZERO_P(NULL, struct winbindd_cli_state)) == NULL) { 773 close(sock); 774 return; 775 } 776 777 state->sock = sock; 778 779 state->out_queue = tevent_queue_create(state, "winbind client reply"); 780 if (state->out_queue == NULL) { 781 close(sock); 782 TALLOC_FREE(state); 783 return; 784 } 785 786 state->last_access = time(NULL); 787 788 state->privileged = privileged; 789 790 req = wb_req_read_send(state, winbind_event_context(), state->sock, 791 WINBINDD_MAX_EXTRA_DATA); 792 if (req == NULL) { 793 TALLOC_FREE(state); 794 close(sock); 795 return; 796 } 797 tevent_req_set_callback(req, winbind_client_request_read, state); 798 799 /* Add to connection list */ 800 801 winbindd_add_client(state); 802} 803 804static void winbind_client_request_read(struct tevent_req *req) 805{ 806 struct winbindd_cli_state *state = tevent_req_callback_data( 807 req, struct winbindd_cli_state); 808 ssize_t ret; 809 int err; 810 811 ret = wb_req_read_recv(req, state, &state->request, &err); 812 TALLOC_FREE(req); 813 if (ret == -1) { 814 if (err == EPIPE) { 815 DEBUG(6, ("closing socket %d, client exited\n", 816 state->sock)); 817 } else { 818 DEBUG(2, ("Could not read client request from fd %d: " 819 "%s\n", state->sock, strerror(err))); 820 } 821 close(state->sock); 822 state->sock = -1; 823 remove_client(state); 824 return; 825 } 826 process_request(state); 827} 828 829/* Remove a client connection from client connection list */ 830 831static void remove_client(struct winbindd_cli_state *state) 832{ 833 char c = 0; 834 int nwritten; 835 836 /* It's a dead client - hold a funeral */ 837 838 if (state == NULL) { 839 return; 840 } 841 842 if (state->sock != -1) { 843 /* tell client, we are closing ... */ 844 nwritten = write(state->sock, &c, sizeof(c)); 845 if (nwritten == -1) { 846 DEBUG(2, ("final write to client failed: %s\n", 847 strerror(errno))); 848 } 849 850 /* Close socket */ 851 852 close(state->sock); 853 state->sock = -1; 854 } 855 856 TALLOC_FREE(state->mem_ctx); 857 858 /* Remove from list and free */ 859 860 winbindd_remove_client(state); 861 TALLOC_FREE(state); 862} 863 864/* Shutdown client connection which has been idle for the longest time */ 865 866static bool remove_idle_client(void) 867{ 868 struct winbindd_cli_state *state, *remove_state = NULL; 869 time_t last_access = 0; 870 int nidle = 0; 871 872 for (state = winbindd_client_list(); state; state = state->next) { 873 if (state->response == NULL && 874 !state->pwent_state && !state->grent_state) { 875 nidle++; 876 if (!last_access || state->last_access < last_access) { 877 last_access = state->last_access; 878 remove_state = state; 879 } 880 } 881 } 882 883 if (remove_state) { 884 DEBUG(5,("Found %d idle client connections, shutting down sock %d, pid %u\n", 885 nidle, remove_state->sock, (unsigned int)remove_state->pid)); 886 remove_client(remove_state); 887 return True; 888 } 889 890 return False; 891} 892 893struct winbindd_listen_state { 894 bool privileged; 895 int fd; 896}; 897 898static void winbindd_listen_fde_handler(struct tevent_context *ev, 899 struct tevent_fd *fde, 900 uint16_t flags, 901 void *private_data) 902{ 903 struct winbindd_listen_state *s = talloc_get_type_abort(private_data, 904 struct winbindd_listen_state); 905 906 while (winbindd_num_clients() > 907 WINBINDD_MAX_SIMULTANEOUS_CLIENTS - 1) { 908 DEBUG(5,("winbindd: Exceeding %d client " 909 "connections, removing idle " 910 "connection.\n", 911 WINBINDD_MAX_SIMULTANEOUS_CLIENTS)); 912 if (!remove_idle_client()) { 913 DEBUG(0,("winbindd: Exceeding %d " 914 "client connections, no idle " 915 "connection found\n", 916 WINBINDD_MAX_SIMULTANEOUS_CLIENTS)); 917 break; 918 } 919 } 920 new_connection(s->fd, s->privileged); 921} 922 923static bool winbindd_setup_listeners(void) 924{ 925 struct winbindd_listen_state *pub_state = NULL; 926 struct winbindd_listen_state *priv_state = NULL; 927 struct tevent_fd *fde; 928 929 pub_state = talloc(winbind_event_context(), 930 struct winbindd_listen_state); 931 if (!pub_state) { 932 goto failed; 933 } 934 935 pub_state->privileged = false; 936 pub_state->fd = open_winbindd_socket(); 937 if (pub_state->fd == -1) { 938 goto failed; 939 } 940 941 fde = tevent_add_fd(winbind_event_context(), pub_state, pub_state->fd, 942 TEVENT_FD_READ, winbindd_listen_fde_handler, 943 pub_state); 944 if (fde == NULL) { 945 close(pub_state->fd); 946 goto failed; 947 } 948 tevent_fd_set_auto_close(fde); 949 950 priv_state = talloc(winbind_event_context(), 951 struct winbindd_listen_state); 952 if (!priv_state) { 953 goto failed; 954 } 955 956 priv_state->privileged = true; 957 priv_state->fd = open_winbindd_priv_socket(); 958 if (priv_state->fd == -1) { 959 goto failed; 960 } 961 962 fde = tevent_add_fd(winbind_event_context(), priv_state, 963 priv_state->fd, TEVENT_FD_READ, 964 winbindd_listen_fde_handler, priv_state); 965 if (fde == NULL) { 966 close(priv_state->fd); 967 goto failed; 968 } 969 tevent_fd_set_auto_close(fde); 970 971 return true; 972failed: 973 TALLOC_FREE(pub_state); 974 TALLOC_FREE(priv_state); 975 return false; 976} 977 978bool winbindd_use_idmap_cache(void) 979{ 980 return !opt_nocache; 981} 982 983bool winbindd_use_cache(void) 984{ 985 return !opt_nocache; 986} 987 988/* Main function */ 989 990int main(int argc, char **argv, char **envp) 991{ 992 static bool is_daemon = False; 993 static bool Fork = True; 994 static bool log_stdout = False; 995 static bool no_process_group = False; 996 enum { 997 OPT_DAEMON = 1000, 998 OPT_FORK, 999 OPT_NO_PROCESS_GROUP, 1000 OPT_LOG_STDOUT 1001 }; 1002 struct poptOption long_options[] = { 1003 POPT_AUTOHELP 1004 { "stdout", 'S', POPT_ARG_NONE, NULL, OPT_LOG_STDOUT, "Log to stdout" }, 1005 { "foreground", 'F', POPT_ARG_NONE, NULL, OPT_FORK, "Daemon in foreground mode" }, 1006 { "no-process-group", 0, POPT_ARG_NONE, NULL, OPT_NO_PROCESS_GROUP, "Don't create a new process group" }, 1007 { "daemon", 'D', POPT_ARG_NONE, NULL, OPT_DAEMON, "Become a daemon (default)" }, 1008 { "interactive", 'i', POPT_ARG_NONE, NULL, 'i', "Interactive mode" }, 1009 { "no-caching", 'n', POPT_ARG_NONE, NULL, 'n', "Disable caching" }, 1010 POPT_COMMON_SAMBA 1011 POPT_TABLEEND 1012 }; 1013 poptContext pc; 1014 int opt; 1015 TALLOC_CTX *frame = talloc_stackframe(); 1016 struct tevent_timer *te; 1017 1018 /* glibc (?) likes to print "User defined signal 1" and exit if a 1019 SIGUSR[12] is received before a handler is installed */ 1020 1021 CatchSignal(SIGUSR1, SIG_IGN); 1022 CatchSignal(SIGUSR2, SIG_IGN); 1023 1024 fault_setup((void (*)(void *))fault_quit ); 1025 dump_core_setup("winbindd"); 1026 1027 load_case_tables(); 1028 1029 /* Initialise for running in non-root mode */ 1030 1031 sec_init(); 1032 1033 set_remote_machine_name("winbindd", False); 1034 1035 /* Set environment variable so we don't recursively call ourselves. 1036 This may also be useful interactively. */ 1037 1038 if ( !winbind_off() ) { 1039 DEBUG(0,("Failed to disable recusive winbindd calls. Exiting.\n")); 1040 exit(1); 1041 } 1042 1043 /* Initialise samba/rpc client stuff */ 1044 1045 pc = poptGetContext("winbindd", argc, (const char **)argv, long_options, 0); 1046 1047 while ((opt = poptGetNextOpt(pc)) != -1) { 1048 switch (opt) { 1049 /* Don't become a daemon */ 1050 case OPT_DAEMON: 1051 is_daemon = True; 1052 break; 1053 case 'i': 1054 interactive = True; 1055 log_stdout = True; 1056 Fork = False; 1057 break; 1058 case OPT_FORK: 1059 Fork = false; 1060 break; 1061 case OPT_NO_PROCESS_GROUP: 1062 no_process_group = true; 1063 break; 1064 case OPT_LOG_STDOUT: 1065 log_stdout = true; 1066 break; 1067 case 'n': 1068 opt_nocache = true; 1069 break; 1070 default: 1071 d_fprintf(stderr, "\nInvalid option %s: %s\n\n", 1072 poptBadOption(pc, 0), poptStrerror(opt)); 1073 poptPrintUsage(pc, stderr, 0); 1074 exit(1); 1075 } 1076 } 1077 1078 if (is_daemon && interactive) { 1079 d_fprintf(stderr,"\nERROR: " 1080 "Option -i|--interactive is not allowed together with -D|--daemon\n\n"); 1081 poptPrintUsage(pc, stderr, 0); 1082 exit(1); 1083 } 1084 1085 if (log_stdout && Fork) { 1086 d_fprintf(stderr, "\nERROR: " 1087 "Can't log to stdout (-S) unless daemon is in foreground +(-F) or interactive (-i)\n\n"); 1088 poptPrintUsage(pc, stderr, 0); 1089 exit(1); 1090 } 1091 1092 poptFreeContext(pc); 1093 1094 if (!override_logfile) { 1095 char *lfile = NULL; 1096 if (asprintf(&lfile,"%s/log.winbindd", 1097 get_dyn_LOGFILEBASE()) > 0) { 1098 lp_set_logfile(lfile); 1099 SAFE_FREE(lfile); 1100 } 1101 } 1102 setup_logging("winbindd", log_stdout); 1103 reopen_logs(); 1104 1105 DEBUG(0,("winbindd version %s started.\n", samba_version_string())); 1106 DEBUGADD(0,("%s\n", COPYRIGHT_STARTUP_MESSAGE)); 1107 1108 if (!lp_load_initial_only(get_dyn_CONFIGFILE())) { 1109 DEBUG(0, ("error opening config file\n")); 1110 exit(1); 1111 } 1112 1113 /* Initialise messaging system */ 1114 1115 if (winbind_messaging_context() == NULL) { 1116 exit(1); 1117 } 1118 1119 if (!reload_services_file(NULL)) { 1120 DEBUG(0, ("error opening config file\n")); 1121 exit(1); 1122 } 1123 1124 if (!directory_exist(lp_lockdir())) { 1125 mkdir(lp_lockdir(), 0755); 1126 } 1127 1128 /* Setup names. */ 1129 1130 if (!init_names()) 1131 exit(1); 1132 1133 load_interfaces(); 1134 1135 if (!secrets_init()) { 1136 1137 DEBUG(0,("Could not initialize domain trust account secrets. Giving up\n")); 1138 return False; 1139 } 1140 1141 /* Enable netbios namecache */ 1142 1143 namecache_enable(); 1144 1145 /* Unblock all signals we are interested in as they may have been 1146 blocked by the parent process. */ 1147 1148 BlockSignals(False, SIGINT); 1149 BlockSignals(False, SIGQUIT); 1150 BlockSignals(False, SIGTERM); 1151 BlockSignals(False, SIGUSR1); 1152 BlockSignals(False, SIGUSR2); 1153 BlockSignals(False, SIGHUP); 1154 BlockSignals(False, SIGCHLD); 1155 1156 if (!interactive) 1157 become_daemon(Fork, no_process_group); 1158 1159 pidfile_create("winbindd"); 1160 1161#if HAVE_SETPGID 1162 /* 1163 * If we're interactive we want to set our own process group for 1164 * signal management. 1165 */ 1166 if (interactive && !no_process_group) 1167 setpgid( (pid_t)0, (pid_t)0); 1168#endif 1169 1170 TimeInit(); 1171 1172 /* Don't use winbindd_reinit_after_fork here as 1173 * we're just starting up and haven't created any 1174 * winbindd-specific resources we must free yet. JRA. 1175 */ 1176 1177 if (!NT_STATUS_IS_OK(reinit_after_fork(winbind_messaging_context(), 1178 winbind_event_context(), 1179 false))) { 1180 DEBUG(0,("reinit_after_fork() failed\n")); 1181 exit(1); 1182 } 1183 1184 /* Setup signal handlers */ 1185 1186 if (!winbindd_setup_sig_term_handler(true)) 1187 exit(1); 1188 if (!winbindd_setup_sig_hup_handler(NULL)) 1189 exit(1); 1190 if (!winbindd_setup_sig_chld_handler()) 1191 exit(1); 1192 if (!winbindd_setup_sig_usr2_handler()) 1193 exit(1); 1194 1195 CatchSignal(SIGPIPE, SIG_IGN); /* Ignore sigpipe */ 1196 1197 /* 1198 * Ensure all cache and idmap caches are consistent 1199 * and initialized before we startup. 1200 */ 1201 if (!winbindd_cache_validate_and_initialize()) { 1202 exit(1); 1203 } 1204 1205 /* get broadcast messages */ 1206 claim_connection(NULL,"",FLAG_MSG_GENERAL|FLAG_MSG_DBWRAP); 1207 1208 /* React on 'smbcontrol winbindd reload-config' in the same way 1209 as to SIGHUP signal */ 1210 messaging_register(winbind_messaging_context(), NULL, 1211 MSG_SMB_CONF_UPDATED, msg_reload_services); 1212 messaging_register(winbind_messaging_context(), NULL, 1213 MSG_SHUTDOWN, msg_shutdown); 1214 1215 /* Handle online/offline messages. */ 1216 messaging_register(winbind_messaging_context(), NULL, 1217 MSG_WINBIND_OFFLINE, winbind_msg_offline); 1218 messaging_register(winbind_messaging_context(), NULL, 1219 MSG_WINBIND_ONLINE, winbind_msg_online); 1220 messaging_register(winbind_messaging_context(), NULL, 1221 MSG_WINBIND_ONLINESTATUS, winbind_msg_onlinestatus); 1222 1223 messaging_register(winbind_messaging_context(), NULL, 1224 MSG_DUMP_EVENT_LIST, winbind_msg_dump_event_list); 1225 1226 messaging_register(winbind_messaging_context(), NULL, 1227 MSG_WINBIND_VALIDATE_CACHE, 1228 winbind_msg_validate_cache); 1229 1230 messaging_register(winbind_messaging_context(), NULL, 1231 MSG_WINBIND_DUMP_DOMAIN_LIST, 1232 winbind_msg_dump_domain_list); 1233 1234 /* Register handler for MSG_DEBUG. */ 1235 messaging_register(winbind_messaging_context(), NULL, 1236 MSG_DEBUG, 1237 winbind_msg_debug); 1238 1239 netsamlogon_cache_init(); /* Non-critical */ 1240 1241 /* clear the cached list of trusted domains */ 1242 1243 wcache_tdc_clear(); 1244 1245 if (!init_domain_list()) { 1246 DEBUG(0,("unable to initialize domain list\n")); 1247 exit(1); 1248 } 1249 1250 init_idmap_child(); 1251 init_locator_child(); 1252 1253 smb_nscd_flush_user_cache(); 1254 smb_nscd_flush_group_cache(); 1255 1256 /* setup listen sockets */ 1257 1258 if (!winbindd_setup_listeners()) { 1259 DEBUG(0,("winbindd_setup_listeners() failed\n")); 1260 exit(1); 1261 } 1262 1263 te = tevent_add_timer(winbind_event_context(), NULL, timeval_zero(), 1264 rescan_trusted_domains, NULL); 1265 if (te == NULL) { 1266 DEBUG(0, ("Could not trigger rescan_trusted_domains()\n")); 1267 exit(1); 1268 } 1269 1270 TALLOC_FREE(frame); 1271 /* Loop waiting for requests */ 1272 while (1) { 1273 frame = talloc_stackframe(); 1274 1275 if (tevent_loop_once(winbind_event_context()) == -1) { 1276 DEBUG(1, ("tevent_loop_once() failed: %s\n", 1277 strerror(errno))); 1278 return 1; 1279 } 1280 1281 TALLOC_FREE(frame); 1282 } 1283 1284 return 0; 1285} 1286