nsswitch/wb_common.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    winbind client common code
   5
   6    Copyright (C) Tim Potter 2000
   7    Copyright (C) Andrew Tridgell 2000
   8    Copyright (C) Andrew Bartlett 2002
   9    Copyright (C) Matthew Newton 2015
  10
  11
  12    This library is free software; you can redistribute it and/or
  13    modify it under the terms of the GNU Lesser General Public
  14    License as published by the Free Software Foundation; either
  15    version 3 of the License, or (at your option) any later version.
  16
  17    This library is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20    Library General Public License for more details.
  21
  22    You should have received a copy of the GNU Lesser General Public License
  23    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  24 */
  25
  26 #include "replace.h"
  27 #include "system/select.h"
  28 #include "winbind_client.h"
  29 #include "lib/util/dlinklist.h"
  30 #include <assert.h>
  31
  32 #ifdef HAVE_PTHREAD_H
  33 #include <pthread.h>
  34 #endif
  35
  36 static __thread char client_name[32];
  37
  38 /* Global context */
  39
  40 struct winbindd_context {
  41         struct winbindd_context *prev, *next;
  42         int winbindd_fd;        /* winbind file descriptor */
  43         bool is_privileged;     /* using the privileged socket? */
  44         pid_t our_pid;          /* calling process pid */
  45         bool autofree;          /* this is a thread global context */
  46 };
  47
  48 static struct wb_global_ctx {
  49 #ifdef HAVE_PTHREAD
  50         pthread_once_t control;
  51         pthread_key_t key;
  52         bool key_initialized;
  53 #ifdef PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
  54 #define WB_GLOBAL_MUTEX_INITIALIZER PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP
  55 #else
  56 #define WB_GLOBAL_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER
  57 #endif
  58 #define WB_GLOBAL_LIST_LOCK do { \
  59         int __pret = pthread_mutex_lock(&wb_global_ctx.list_mutex); \
  60         assert(__pret == 0); \
  61 } while(0)
  62 #define WB_GLOBAL_LIST_UNLOCK do { \
  63         int __pret = pthread_mutex_unlock(&wb_global_ctx.list_mutex); \
  64         assert(__pret == 0); \
  65 } while(0)
  66         pthread_mutex_t list_mutex;
  67 #else /* => not HAVE_PTHREAD */
  68 #define WB_GLOBAL_LIST_LOCK do { } while(0)
  69 #define WB_GLOBAL_LIST_UNLOCK do { } while(0)
  70 #endif /* not HAVE_PTHREAD */
  71         struct winbindd_context *list;
  72 } wb_global_ctx = {
  73 #ifdef HAVE_PTHREAD
  74         .control = PTHREAD_ONCE_INIT,
  75         .list_mutex = WB_GLOBAL_MUTEX_INITIALIZER,
  76 #endif
  77         .list = NULL,
  78 };
  79
  80 static void winbind_close_sock(struct winbindd_context *ctx);
  81 static void winbind_ctx_free_locked(struct winbindd_context *ctx);
  82 static void winbind_cleanup_list(void);
  83
  84 #ifdef HAVE_PTHREAD
  85 static void wb_thread_ctx_initialize(void);
  86
  87 static void wb_atfork_prepare(void)
  88 {
  89         WB_GLOBAL_LIST_LOCK;
  90 }
  91
  92 static void wb_atfork_parent(void)
  93 {
  94         WB_GLOBAL_LIST_UNLOCK;
  95 }
  96
  97 static void wb_atfork_child(void)
  98 {
  99         wb_global_ctx.list_mutex = (pthread_mutex_t)WB_GLOBAL_MUTEX_INITIALIZER;
 100
 101         if (wb_global_ctx.key_initialized) {
 102                 int ret;
 103
 104                 /*
 105                  * After a fork the child still believes
 106                  * it is the same thread as in the parent.
 107                  * So pthread_getspecific() would return the
 108                  * value of the thread that called fork().
 109                  *
 110                  * But we don't want that behavior, so
 111                  * we just clear the reference and let
 112                  * winbind_cleanup_list() below 'autofree'
 113                  * the parent threads global context.
 114                  */
 115                 ret = pthread_setspecific(wb_global_ctx.key, NULL);
 116                 assert(ret == 0);
 117         }
 118
 119         /*
 120          * But we need to close/cleanup the global state
 121          * of the parents threads.
 122          */
 123         winbind_cleanup_list();
 124 }
 125
 126 static void wb_thread_ctx_destructor(void *p)
 127 {
 128         struct winbindd_context *ctx = (struct winbindd_context *)p;
 129
 130         winbindd_ctx_free(ctx);
 131 }
 132
 133 static void wb_thread_ctx_initialize(void)
 134 {
 135         int ret;
 136
 137         ret = pthread_atfork(wb_atfork_prepare,
 138                              wb_atfork_parent,
 139                              wb_atfork_child);
 140         assert(ret == 0);
 141
 142         ret = pthread_key_create(&wb_global_ctx.key,
 143                                  wb_thread_ctx_destructor);
 144         assert(ret == 0);
 145
 146         wb_global_ctx.key_initialized = true;
 147 }
 148
 149 static struct winbindd_context *get_wb_thread_ctx(void)
 150 {
 151         struct winbindd_context *ctx = NULL;
 152         int ret;
 153
 154         ret = pthread_once(&wb_global_ctx.control,
 155                            wb_thread_ctx_initialize);
 156         assert(ret == 0);
 157
 158         ctx = (struct winbindd_context *)pthread_getspecific(
 159                 wb_global_ctx.key);
 160         if (ctx != NULL) {
 161                 return ctx;
 162         }
 163
 164         ctx = malloc(sizeof(struct winbindd_context));
 165         if (ctx == NULL) {
 166                 return NULL;
 167         }
 168
 169         *ctx = (struct winbindd_context) {
 170                 .winbindd_fd = -1,
 171                 .is_privileged = false,
 172                 .our_pid = 0,
 173                 .autofree = true,
 174         };
 175
 176         WB_GLOBAL_LIST_LOCK;
 177         DLIST_ADD_END(wb_global_ctx.list, ctx);
 178         WB_GLOBAL_LIST_UNLOCK;
 179
 180         ret = pthread_setspecific(wb_global_ctx.key, ctx);
 181         if (ret != 0) {
 182                 free(ctx);
 183                 return NULL;
 184         }
 185         return ctx;
 186 }
 187 #endif /* HAVE_PTHREAD */
 188
 189 static struct winbindd_context *get_wb_global_ctx(void)
 190 {
 191         struct winbindd_context *ctx = NULL;
 192 #ifndef HAVE_PTHREAD
 193         static struct winbindd_context _ctx = {
 194                 .winbindd_fd = -1,
 195                 .is_privileged = false,
 196                 .our_pid = 0,
 197                 .autofree = false,
 198         };
 199 #endif
 200
 201 #ifdef HAVE_PTHREAD
 202         ctx = get_wb_thread_ctx();
 203 #else
 204         ctx = &_ctx;
 205         if (ctx->prev == NULL && ctx->next == NULL) {
 206                 DLIST_ADD_END(wb_global_ctx.list, ctx);
 207         }
 208 #endif
 209
 210         return ctx;
 211 }
 212
 213 void winbind_set_client_name(const char *name)
 214 {
 215         if (name == NULL || strlen(name) == 0) {
 216                 return;
 217         }
 218
 219         (void)snprintf(client_name, sizeof(client_name), "%s", name);
 220 }
 221
 222 static const char *winbind_get_client_name(void)
 223 {
 224         if (client_name[0] == '\0') {
 225                 const char *progname = getprogname();
 226                 int len;
 227
 228                 if (progname == NULL) {
 229                         progname = "<unknown>";
 230                 }
 231
 232                 len = snprintf(client_name,
 233                                sizeof(client_name),
 234                                "%s",
 235                                progname);
 236                 if (len <= 0) {
 237                         return progname;
 238                 }
 239         }
 240
 241         return client_name;
 242 }
 243
 244 /* Initialise a request structure */
 245
 246 static void winbindd_init_request(struct winbindd_request *request,
 247                                   int request_type)
 248 {
 249         request->length = sizeof(struct winbindd_request);
 250
 251         request->cmd = (enum winbindd_cmd)request_type;
 252         request->pid = getpid();
 253
 254         (void)snprintf(request->client_name,
 255                        sizeof(request->client_name),
 256                        "%s",
 257                        winbind_get_client_name());
 258 }
 259
 260 /* Initialise a response structure */
 261
 262 static void init_response(struct winbindd_response *response)
 263 {
 264         /* Initialise return value */
 265
 266         response->result = WINBINDD_ERROR;
 267 }
 268
 269 /* Close established socket */
 270
 271 static void winbind_close_sock(struct winbindd_context *ctx)
 272 {
 273         if (!ctx) {
 274                 return;
 275         }
 276
 277         if (ctx->winbindd_fd != -1) {
 278                 close(ctx->winbindd_fd);
 279                 ctx->winbindd_fd = -1;
 280         }
 281 }
 282
 283 static void winbind_ctx_free_locked(struct winbindd_context *ctx)
 284 {
 285         winbind_close_sock(ctx);
 286         DLIST_REMOVE(wb_global_ctx.list, ctx);
 287         free(ctx);
 288 }
 289
 290 static void winbind_cleanup_list(void)
 291 {
 292         struct winbindd_context *ctx = NULL, *next = NULL;
 293
 294         WB_GLOBAL_LIST_LOCK;
 295         for (ctx = wb_global_ctx.list; ctx != NULL; ctx = next) {
 296                 next = ctx->next;
 297
 298                 if (ctx->autofree) {
 299                         winbind_ctx_free_locked(ctx);
 300                 } else {
 301                         winbind_close_sock(ctx);
 302                 }
 303         }
 304         WB_GLOBAL_LIST_UNLOCK;
 305 }
 306
 307 /* Destructor for global context to ensure fd is closed */
 308
 309 #ifdef HAVE_DESTRUCTOR_ATTRIBUTE
 310 __attribute__((destructor))
 311 #elif defined (HAVE_PRAGMA_FINI)
 312 #pragma fini (winbind_destructor)
 313 #endif
 314 static void winbind_destructor(void)
 315 {
 316 #ifdef HAVE_PTHREAD
 317         if (wb_global_ctx.key_initialized) {
 318                 int ret;
 319                 ret = pthread_key_delete(wb_global_ctx.key);
 320                 assert(ret == 0);
 321                 wb_global_ctx.key_initialized = false;
 322         }
 323
 324         wb_global_ctx.control = (pthread_once_t)PTHREAD_ONCE_INIT;
 325 #endif /* HAVE_PTHREAD */
 326
 327         winbind_cleanup_list();
 328 }
 329
 330 #define CONNECT_TIMEOUT 30
 331
 332 /* Make sure socket handle isn't stdin, stdout or stderr */
 333 #define RECURSION_LIMIT 3
 334
 335 static int make_nonstd_fd_internals(int fd, int limit /* Recursion limiter */)
 336 {
 337         int new_fd;
 338         if (fd >= 0 && fd <= 2) {
 339 #ifdef F_DUPFD
 340                 if ((new_fd = fcntl(fd, F_DUPFD, 3)) == -1) {
 341                         return -1;
 342                 }
 343                 /* Paranoia */
 344                 if (new_fd < 3) {
 345                         close(new_fd);
 346                         return -1;
 347                 }
 348                 close(fd);
 349                 return new_fd;
 350 #else
 351                 if (limit <= 0)
 352                         return -1;
 353
 354                 new_fd = dup(fd);
 355                 if (new_fd == -1)
 356                         return -1;
 357
 358                 /* use the program stack to hold our list of FDs to close */
 359                 new_fd = make_nonstd_fd_internals(new_fd, limit - 1);
 360                 close(fd);
 361                 return new_fd;
 362 #endif
 363         }
 364         return fd;
 365 }
 366
 367 /****************************************************************************
 368  Set a fd into blocking/nonblocking mode. Uses POSIX O_NONBLOCK if available,
 369  else
 370  if SYSV use O_NDELAY
 371  if BSD use FNDELAY
 372  Set close on exec also.
 373 ****************************************************************************/
 374
 375 static int make_safe_fd(int fd)
 376 {
 377         int result, flags;
 378         int new_fd = make_nonstd_fd_internals(fd, RECURSION_LIMIT);
 379         if (new_fd == -1) {
 380                 close(fd);
 381                 return -1;
 382         }
 383
 384         /* Socket should be nonblocking. */
 385 #ifdef O_NONBLOCK
 386 #define FLAG_TO_SET O_NONBLOCK
 387 #else
 388 #ifdef SYSV
 389 #define FLAG_TO_SET O_NDELAY
 390 #else /* BSD */
 391 #define FLAG_TO_SET FNDELAY
 392 #endif
 393 #endif
 394
 395         if ((flags = fcntl(new_fd, F_GETFL)) == -1) {
 396                 close(new_fd);
 397                 return -1;
 398         }
 399
 400         flags |= FLAG_TO_SET;
 401         if (fcntl(new_fd, F_SETFL, flags) == -1) {
 402                 close(new_fd);
 403                 return -1;
 404         }
 405
 406 #undef FLAG_TO_SET
 407
 408         /* Socket should be closed on exec() */
 409 #ifdef FD_CLOEXEC
 410         result = flags = fcntl(new_fd, F_GETFD, 0);
 411         if (flags >= 0) {
 412                 flags |= FD_CLOEXEC;
 413                 result = fcntl( new_fd, F_SETFD, flags );
 414         }
 415         if (result < 0) {
 416                 close(new_fd);
 417                 return -1;
 418         }
 419 #endif
 420         return new_fd;
 421 }
 422
 423 /**
 424  * @internal
 425  *
 426  * @brief Check if we talk to the privileged pipe which should be owned by root.
 427  *
 428  * This checks if we have uid_wrapper running and if this is the case it will
 429  * allow one to connect to the winbind privileged pipe even it is not owned by root.
 430  *
 431  * @param[in]  uid      The uid to check if we can safely talk to the pipe.
 432  *
 433  * @return              If we have access it returns true, else false.
 434  */
 435 static bool winbind_privileged_pipe_is_root(uid_t uid)
 436 {
 437         if (uid == 0) {
 438                 return true;
 439         }
 440
 441         if (uid_wrapper_enabled()) {
 442                 return true;
 443         }
 444
 445         return false;
 446 }
 447
 448 /* Connect to winbindd socket */
 449
 450 static int winbind_named_pipe_sock(const char *dir)
 451 {
 452         struct sockaddr_un sunaddr;
 453         struct stat st;
 454         int fd;
 455         int wait_time;
 456         int slept;
 457         int ret;
 458
 459         /* Check permissions on unix socket directory */
 460
 461         if (lstat(dir, &st) == -1) {
 462                 errno = ENOENT;
 463                 return -1;
 464         }
 465
 466         /*
 467          * This tells us that the pipe is owned by a privileged
 468          * process, as we will be sending passwords to it.
 469          */
 470         if (!S_ISDIR(st.st_mode) ||
 471             !winbind_privileged_pipe_is_root(st.st_uid)) {
 472                 errno = ENOENT;
 473                 return -1;
 474         }
 475
 476         /* Connect to socket */
 477
 478         sunaddr = (struct sockaddr_un) { .sun_family = AF_UNIX };
 479
 480         ret = snprintf(sunaddr.sun_path, sizeof(sunaddr.sun_path),
 481                        "%s/%s", dir, WINBINDD_SOCKET_NAME);
 482         if ((ret == -1) || (ret >= sizeof(sunaddr.sun_path))) {
 483                 errno = ENAMETOOLONG;
 484                 return -1;
 485         }
 486
 487         /* If socket file doesn't exist, don't bother trying to connect
 488            with retry.  This is an attempt to make the system usable when
 489            the winbindd daemon is not running. */
 490
 491         if (lstat(sunaddr.sun_path, &st) == -1) {
 492                 errno = ENOENT;
 493                 return -1;
 494         }
 495
 496         /* Check permissions on unix socket file */
 497
 498         /*
 499          * This tells us that the pipe is owned by a privileged
 500          * process, as we will be sending passwords to it.
 501          */
 502         if (!S_ISSOCK(st.st_mode) ||
 503             !winbind_privileged_pipe_is_root(st.st_uid)) {
 504                 errno = ENOENT;
 505                 return -1;
 506         }
 507
 508         /* Connect to socket */
 509
 510         if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
 511                 return -1;
 512         }
 513
 514         /* Set socket non-blocking and close on exec. */
 515
 516         if ((fd = make_safe_fd( fd)) == -1) {
 517                 return fd;
 518         }
 519
 520         for (wait_time = 0; connect(fd, (struct sockaddr *)&sunaddr, sizeof(sunaddr)) == -1;
 521                         wait_time += slept) {
 522                 struct pollfd pfd;
 523                 int connect_errno = 0;
 524                 socklen_t errnosize;
 525
 526                 if (wait_time >= CONNECT_TIMEOUT)
 527                         goto error_out;
 528
 529                 switch (errno) {
 530                         case EINPROGRESS:
 531                                 pfd.fd = fd;
 532                                 pfd.events = POLLOUT;
 533
 534                                 ret = poll(&pfd, 1, (CONNECT_TIMEOUT - wait_time) * 1000);
 535
 536                                 if (ret > 0) {
 537                                         errnosize = sizeof(connect_errno);
 538
 539                                         ret = getsockopt(fd, SOL_SOCKET,
 540                                                         SO_ERROR, &connect_errno, &errnosize);
 541
 542                                         if (ret >= 0 && connect_errno == 0) {
 543                                                 /* Connect succeed */
 544                                                 goto out;
 545                                         }
 546                                 }
 547
 548                                 slept = CONNECT_TIMEOUT;
 549                                 break;
 550                         case EAGAIN:
 551                                 slept = rand() % 3 + 1;
 552                                 sleep(slept);
 553                                 break;
 554                         default:
 555                                 goto error_out;
 556                 }
 557
 558         }
 559
 560   out:
 561
 562         return fd;
 563
 564   error_out:
 565
 566         close(fd);
 567         return -1;
 568 }
 569
 570 static const char *winbindd_socket_dir(void)
 571 {
 572         if (nss_wrapper_enabled()) {
 573                 const char *env_dir;
 574
 575                 env_dir = getenv("SELFTEST_WINBINDD_SOCKET_DIR");
 576                 if (env_dir != NULL) {
 577                         return env_dir;
 578                 }
 579         }
 580
 581         return WINBINDD_SOCKET_DIR;
 582 }
 583
 584 /* Connect to winbindd socket */
 585
 586 static int winbind_open_pipe_sock(struct winbindd_context *ctx,
 587                                   int recursing, int need_priv)
 588 {
 589 #ifdef HAVE_UNIXSOCKET
 590         struct winbindd_request request;
 591         struct winbindd_response response;
 592
 593         ZERO_STRUCT(request);
 594         ZERO_STRUCT(response);
 595
 596         if (!ctx) {
 597                 return -1;
 598         }
 599
 600         if (ctx->our_pid != getpid()) {
 601                 winbind_close_sock(ctx);
 602                 ctx->our_pid = getpid();
 603         }
 604
 605         if ((need_priv != 0) && !ctx->is_privileged) {
 606                 winbind_close_sock(ctx);
 607         }
 608
 609         if (ctx->winbindd_fd != -1) {
 610                 return ctx->winbindd_fd;
 611         }
 612
 613         if (recursing) {
 614                 return -1;
 615         }
 616
 617         ctx->winbindd_fd = winbind_named_pipe_sock(winbindd_socket_dir());
 618
 619         if (ctx->winbindd_fd == -1) {
 620                 return -1;
 621         }
 622
 623         ctx->is_privileged = false;
 624
 625         /* version-check the socket */
 626
 627         request.wb_flags = WBFLAG_RECURSE;
 628         if ((winbindd_request_response(ctx, WINBINDD_INTERFACE_VERSION, &request,
 629                                        &response) != NSS_STATUS_SUCCESS) ||
 630             (response.data.interface_version != WINBIND_INTERFACE_VERSION)) {
 631                 winbind_close_sock(ctx);
 632                 return -1;
 633         }
 634
 635         if (need_priv == 0) {
 636                 return ctx->winbindd_fd;
 637         }
 638
 639         /* try and get priv pipe */
 640
 641         request.wb_flags = WBFLAG_RECURSE;
 642
 643         /* Note that response needs to be initialized to avoid
 644          * crashing on clean up after WINBINDD_PRIV_PIPE_DIR call failed
 645          * as interface version (from the first request) returned as a fstring,
 646          * thus response.extra_data.data will not be NULL even though
 647          * winbindd response did not write over it due to a failure */
 648         ZERO_STRUCT(response);
 649         if (winbindd_request_response(ctx, WINBINDD_PRIV_PIPE_DIR, &request,
 650                                       &response) == NSS_STATUS_SUCCESS) {
 651                 int fd;
 652                 fd = winbind_named_pipe_sock((char *)response.extra_data.data);
 653                 if (fd != -1) {
 654                         close(ctx->winbindd_fd);
 655                         ctx->winbindd_fd = fd;
 656                         ctx->is_privileged = true;
 657                 }
 658
 659                 SAFE_FREE(response.extra_data.data);
 660         }
 661
 662         if (!ctx->is_privileged) {
 663                 return -1;
 664         }
 665
 666         return ctx->winbindd_fd;
 667 #else
 668         return -1;
 669 #endif /* HAVE_UNIXSOCKET */
 670 }
 671
 672 /* Write data to winbindd socket */
 673
 674 static int winbind_write_sock(struct winbindd_context *ctx, void *buffer,
 675                               int count, int recursing, int need_priv)
 676 {
 677         int fd, result, nwritten;
 678
 679         /* Open connection to winbind daemon */
 680
 681  restart:
 682
 683         fd = winbind_open_pipe_sock(ctx, recursing, need_priv);
 684         if (fd == -1) {
 685                 errno = ENOENT;
 686                 return -1;
 687         }
 688
 689         /* Write data to socket */
 690
 691         nwritten = 0;
 692
 693         while(nwritten < count) {
 694                 struct pollfd pfd;
 695                 int ret;
 696
 697                 /* Catch pipe close on other end by checking if a read()
 698                    call would not block by calling poll(). */
 699
 700                 pfd.fd = fd;
 701                 pfd.events = POLLIN|POLLOUT|POLLHUP;
 702
 703                 ret = poll(&pfd, 1, -1);
 704                 if (ret == -1) {
 705                         winbind_close_sock(ctx);
 706                         return -1;                   /* poll error */
 707                 }
 708
 709                 /* Write should be OK if fd not available for reading */
 710
 711                 if ((ret == 1) && (pfd.revents & (POLLIN|POLLHUP|POLLERR))) {
 712
 713                         /* Pipe has closed on remote end */
 714
 715                         winbind_close_sock(ctx);
 716                         goto restart;
 717                 }
 718
 719                 /* Do the write */
 720
 721                 result = write(fd, (char *)buffer + nwritten,
 722                                count - nwritten);
 723
 724                 if ((result == -1) || (result == 0)) {
 725
 726                         /* Write failed */
 727
 728                         winbind_close_sock(ctx);
 729                         return -1;
 730                 }
 731
 732                 nwritten += result;
 733         }
 734
 735         return nwritten;
 736 }
 737
 738 /* Read data from winbindd socket */
 739
 740 static int winbind_read_sock(struct winbindd_context *ctx,
 741                              void *buffer, int count)
 742 {
 743         int fd;
 744         int nread = 0;
 745         int total_time = 0;
 746
 747         fd = winbind_open_pipe_sock(ctx, false, false);
 748         if (fd == -1) {
 749                 return -1;
 750         }
 751
 752         /* Read data from socket */
 753         while(nread < count) {
 754                 struct pollfd pfd;
 755                 int ret;
 756
 757                 /* Catch pipe close on other end by checking if a read()
 758                    call would not block by calling poll(). */
 759
 760                 pfd.fd = fd;
 761                 pfd.events = POLLIN|POLLHUP;
 762
 763                 /* Wait for 5 seconds for a reply. May need to parameterise this... */
 764
 765                 ret = poll(&pfd, 1, 5000);
 766                 if (ret == -1) {
 767                         winbind_close_sock(ctx);
 768                         return -1;                   /* poll error */
 769                 }
 770
 771                 if (ret == 0) {
 772                         /* Not ready for read yet... */
 773                         if (total_time >= 300) {
 774                                 /* Timeout */
 775                                 winbind_close_sock(ctx);
 776                                 return -1;
 777                         }
 778                         total_time += 5;
 779                         continue;
 780                 }
 781
 782                 if ((ret == 1) && (pfd.revents & (POLLIN|POLLHUP|POLLERR))) {
 783
 784                         /* Do the Read */
 785
 786                         int result = read(fd, (char *)buffer + nread,
 787                               count - nread);
 788
 789                         if ((result == -1) || (result == 0)) {
 790
 791                                 /* Read failed.  I think the only useful thing we
 792                                    can do here is just return -1 and fail since the
 793                                    transaction has failed half way through. */
 794
 795                                 winbind_close_sock(ctx);
 796                                 return -1;
 797                         }
 798
 799                         nread += result;
 800
 801                 }
 802         }
 803
 804         return nread;
 805 }
 806
 807 /* Read reply */
 808
 809 static int winbindd_read_reply(struct winbindd_context *ctx,
 810                                struct winbindd_response *response)
 811 {
 812         int result1, result2 = 0;
 813
 814         if (!response) {
 815                 return -1;
 816         }
 817
 818         /* Read fixed length response */
 819
 820         result1 = winbind_read_sock(ctx, response,
 821                                     sizeof(struct winbindd_response));
 822
 823         /* We actually send the pointer value of the extra_data field from
 824            the server.  This has no meaning in the client's address space
 825            so we clear it out. */
 826
 827         response->extra_data.data = NULL;
 828
 829         if (result1 == -1) {
 830                 return -1;
 831         }
 832
 833         if (response->length < sizeof(struct winbindd_response)) {
 834                 return -1;
 835         }
 836
 837         /* Read variable length response */
 838
 839         if (response->length > sizeof(struct winbindd_response)) {
 840                 int extra_data_len = response->length -
 841                         sizeof(struct winbindd_response);
 842
 843                 /* Mallocate memory for extra data */
 844
 845                 if (!(response->extra_data.data = malloc(extra_data_len))) {
 846                         return -1;
 847                 }
 848
 849                 result2 = winbind_read_sock(ctx, response->extra_data.data,
 850                                             extra_data_len);
 851                 if (result2 == -1) {
 852                         winbindd_free_response(response);
 853                         return -1;
 854                 }
 855         }
 856
 857         /* Return total amount of data read */
 858
 859         return result1 + result2;
 860 }
 861
 862 /*
 863  * send simple types of requests
 864  */
 865
 866 static NSS_STATUS winbindd_send_request(
 867         struct winbindd_context *ctx,
 868         int req_type,
 869         int need_priv,
 870         struct winbindd_request *request)
 871 {
 872         struct winbindd_request lrequest;
 873
 874         /* Check for our tricky environment variable */
 875
 876         if (winbind_env_set()) {
 877                 return NSS_STATUS_NOTFOUND;
 878         }
 879
 880         if (!request) {
 881                 ZERO_STRUCT(lrequest);
 882                 request = &lrequest;
 883         }
 884
 885         /* Fill in request and send down pipe */
 886
 887         winbindd_init_request(request, req_type);
 888
 889         if (winbind_write_sock(ctx, request, sizeof(*request),
 890                                request->wb_flags & WBFLAG_RECURSE,
 891                                need_priv) == -1)
 892         {
 893                 /* Set ENOENT for consistency.  Required by some apps */
 894                 errno = ENOENT;
 895
 896                 return NSS_STATUS_UNAVAIL;
 897         }
 898
 899         if ((request->extra_len != 0) &&
 900             (winbind_write_sock(ctx, request->extra_data.data,
 901                                 request->extra_len,
 902                                 request->wb_flags & WBFLAG_RECURSE,
 903                                 need_priv) == -1))
 904         {
 905                 /* Set ENOENT for consistency.  Required by some apps */
 906                 errno = ENOENT;
 907
 908                 return NSS_STATUS_UNAVAIL;
 909         }
 910
 911         return NSS_STATUS_SUCCESS;
 912 }
 913
 914 /*
 915  * Get results from winbindd request
 916  */
 917
 918 static NSS_STATUS winbindd_get_response(struct winbindd_context *ctx,
 919                                         struct winbindd_response *response)
 920 {
 921         struct winbindd_response lresponse;
 922
 923         if (!response) {
 924                 ZERO_STRUCT(lresponse);
 925                 response = &lresponse;
 926         }
 927
 928         init_response(response);
 929
 930         /* Wait for reply */
 931         if (winbindd_read_reply(ctx, response) == -1) {
 932                 /* Set ENOENT for consistency.  Required by some apps */
 933                 errno = ENOENT;
 934
 935                 return NSS_STATUS_UNAVAIL;
 936         }
 937
 938         /* Throw away extra data if client didn't request it */
 939         if (response == &lresponse) {
 940                 winbindd_free_response(response);
 941         }
 942
 943         /* Copy reply data from socket */
 944         if (response->result != WINBINDD_OK) {
 945                 return NSS_STATUS_NOTFOUND;
 946         }
 947
 948         return NSS_STATUS_SUCCESS;
 949 }
 950
 951 /* Handle simple types of requests */
 952
 953 NSS_STATUS winbindd_request_response(struct winbindd_context *ctx,
 954                                      int req_type,
 955                                      struct winbindd_request *request,
 956                                      struct winbindd_response *response)
 957 {
 958         NSS_STATUS status = NSS_STATUS_UNAVAIL;
 959
 960         if (ctx == NULL) {
 961                 ctx = get_wb_global_ctx();
 962         }
 963
 964         status = winbindd_send_request(ctx, req_type, 0, request);
 965         if (status != NSS_STATUS_SUCCESS) {
 966                 goto out;
 967         }
 968         status = winbindd_get_response(ctx, response);
 969
 970 out:
 971         return status;
 972 }
 973
 974 NSS_STATUS winbindd_priv_request_response(struct winbindd_context *ctx,
 975                                           int req_type,
 976                                           struct winbindd_request *request,
 977                                           struct winbindd_response *response)
 978 {
 979         NSS_STATUS status = NSS_STATUS_UNAVAIL;
 980
 981         if (ctx == NULL) {
 982                 ctx = get_wb_global_ctx();
 983         }
 984
 985         status = winbindd_send_request(ctx, req_type, 1, request);
 986         if (status != NSS_STATUS_SUCCESS) {
 987                 goto out;
 988         }
 989         status = winbindd_get_response(ctx, response);
 990
 991 out:
 992         return status;
 993 }
 994
 995 /* Create and free winbindd context */
 996
 997 struct winbindd_context *winbindd_ctx_create(void)
 998 {
 999         struct winbindd_context *ctx;
1000
1001         ctx = calloc(1, sizeof(struct winbindd_context));
1002
1003         if (!ctx) {
1004                 return NULL;
1005         }
1006
1007         ctx->winbindd_fd = -1;
1008
1009         WB_GLOBAL_LIST_LOCK;
1010         DLIST_ADD_END(wb_global_ctx.list, ctx);
1011         WB_GLOBAL_LIST_UNLOCK;
1012
1013         return ctx;
1014 }
1015
1016 void winbindd_ctx_free(struct winbindd_context *ctx)
1017 {
1018         WB_GLOBAL_LIST_LOCK;
1019         winbind_ctx_free_locked(ctx);
1020         WB_GLOBAL_LIST_UNLOCK;
1021 }