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