nsswitch/winbind_nss_irix.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Windows NT Domain nsswitch module
   5
   6    Copyright (C) Tim Potter 2000
   7    Copyright (C) James Peach 2006
   8
   9    This library is free software; you can redistribute it and/or
  10    modify it under the terms of the GNU Lesser General Public
  11    License as published by the Free Software Foundation; either
  12    version 3 of the License, or (at your option) any later version.
  13
  14    This library is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17    Library General Public License for more details.
  18
  19    You should have received a copy of the GNU Lesser General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 #include "winbind_client.h"
  24
  25 #ifndef PRINTF_ATTRIBUTE
  26 #define PRINTF_ATTRIBUTE(m, n)
  27 #endif
  28
  29 #ifndef HAVE_ASPRINTF_DECL
  30 /*PRINTFLIKE2 */
  31 int asprintf(char **,const char *, ...) PRINTF_ATTRIBUTE(2,3);
  32 #endif
  33
  34 #ifdef HAVE_NS_API_H
  35 #undef STATIC
  36 #undef DYNAMIC
  37 #include <ns_daemon.h>
  38 #endif
  39
  40 /* Maximum number of users to pass back over the unix domain socket
  41    per call. This is not a static limit on the total number of users
  42    or groups returned in total. */
  43
  44 #define MAX_GETPWENT_USERS 250
  45 #define MAX_GETGRENT_USERS 250
  46
  47 /* Prototypes from wb_common.c */
  48
  49 extern int winbindd_fd;
  50
  51 #ifdef HAVE_NS_API_H
  52
  53 /* IRIX version */
  54
  55 static int send_next_request(nsd_file_t *, struct winbindd_request *);
  56 static int do_list(int state, nsd_file_t *rq);
  57
  58 static nsd_file_t *current_rq = NULL;
  59 static int current_winbind_xid = 0;
  60 static int next_winbind_xid = 0;
  61
  62 typedef struct winbind_xid {
  63         int                     xid;
  64         nsd_file_t              *rq;
  65         struct winbindd_request *request;
  66         struct winbind_xid      *next;
  67 } winbind_xid_t;
  68
  69 static winbind_xid_t *winbind_xids = (winbind_xid_t *)0;
  70
  71 static int
  72 winbind_xid_new(int xid, nsd_file_t *rq, struct winbindd_request *request)
  73 {
  74         winbind_xid_t *new;
  75
  76         nsd_logprintf(NSD_LOG_LOW,
  77                 "entering winbind_xid_new xid = %d rq = 0x%x, request = 0x%x\n",
  78                 xid, rq, request);
  79         new = (winbind_xid_t *)nsd_calloc(1,sizeof(winbind_xid_t));
  80         if (!new) {
  81                 nsd_logprintf(NSD_LOG_RESOURCE,"winbind_xid_new: failed malloc\n");
  82                 return NSD_ERROR;
  83         }
  84
  85         new->xid = xid;
  86         new->rq = rq;
  87         new->request = request;
  88         new->next = winbind_xids;
  89         winbind_xids = new;
  90
  91         return NSD_CONTINUE;
  92 }
  93
  94 /*
  95 ** This routine will look down the xid list and return the request
  96 ** associated with an xid.  We remove the record if it is found.
  97 */
  98 nsd_file_t *
  99 winbind_xid_lookup(int xid, struct winbindd_request **requestp)
 100 {
 101         winbind_xid_t **last, *dx;
 102         nsd_file_t *result=0;
 103
 104         for (last = &winbind_xids, dx = winbind_xids; dx && (dx->xid != xid);
 105             last = &dx->next, dx = dx->next);
 106         if (dx) {
 107                 *last = dx->next;
 108                 result = dx->rq;
 109                 *requestp = dx->request;
 110                 SAFE_FREE(dx);
 111         }
 112         nsd_logprintf(NSD_LOG_LOW,
 113                 "entering winbind_xid_lookup xid = %d rq = 0x%x, request = 0x%x\n",
 114                 xid, result, dx->request);
 115
 116         return result;
 117 }
 118
 119 static int
 120 winbind_startnext_timeout(nsd_file_t **rqp, nsd_times_t *to)
 121 {
 122         nsd_file_t *rq;
 123         struct winbindd_request *request;
 124
 125         nsd_logprintf(NSD_LOG_MIN, "timeout (winbind startnext)\n");
 126         rq = to->t_file;
 127         *rqp = rq;
 128         nsd_timeout_remove(rq);
 129         request = to->t_clientdata;
 130         return(send_next_request(rq, request));
 131 }
 132
 133 static void
 134 dequeue_request(void)
 135 {
 136         nsd_file_t *rq;
 137         struct winbindd_request *request;
 138
 139         /*
 140          * Check for queued requests
 141          */
 142         if (winbind_xids) {
 143             nsd_logprintf(NSD_LOG_MIN, "timeout (winbind) unqueue xid %d\n",
 144                         current_winbind_xid);
 145             rq = winbind_xid_lookup(current_winbind_xid++, &request);
 146             /* cause a timeout on the queued request so we can send it */
 147             nsd_timeout_new(rq,1,winbind_startnext_timeout,request);
 148         }
 149 }
 150
 151 static int
 152 do_request(nsd_file_t *rq, struct winbindd_request *request)
 153 {
 154         if (winbind_xids == NULL) {
 155                 /*
 156                  * No outstanding requests.
 157                  * Send off the request to winbindd
 158                  */
 159                 nsd_logprintf(NSD_LOG_MIN, "lookup (winbind) sending request\n");
 160                 return(send_next_request(rq, request));
 161         } else {
 162                 /*
 163                  * Just queue it up for now - previous callout or timout
 164                  * will start it up
 165                  */
 166                 nsd_logprintf(NSD_LOG_MIN,
 167                         "lookup (winbind): queue request xid = %d\n",
 168                         next_winbind_xid);
 169                 return(winbind_xid_new(next_winbind_xid++, rq, request));
 170         }
 171 }
 172
 173 static int
 174 winbind_callback(nsd_file_t **rqp, int fd)
 175 {
 176         struct winbindd_response response;
 177         nsd_file_t *rq;
 178         NSS_STATUS status;
 179         char * result = NULL;
 180         size_t rlen;
 181
 182         dequeue_request();
 183
 184         nsd_logprintf(NSD_LOG_MIN, "entering callback (winbind)\n");
 185
 186         rq = current_rq;
 187         *rqp = rq;
 188
 189         nsd_timeout_remove(rq);
 190         nsd_callback_remove(fd);
 191
 192         ZERO_STRUCT(response);
 193         status = winbindd_get_response(&response);
 194
 195         if (status != NSS_STATUS_SUCCESS) {
 196                 /* free any extra data area in response structure */
 197                 winbindd_free_response(&response);
 198                 nsd_logprintf(NSD_LOG_MIN,
 199                         "callback (winbind) returning not found, status = %d\n",
 200                         status);
 201
 202                 switch (status) {
 203                     case NSS_STATUS_UNAVAIL:
 204                         rq->f_status = NS_UNAVAIL;
 205                         break;
 206                     case NSS_STATUS_TRYAGAIN:
 207                         rq->f_status = NS_TRYAGAIN;
 208                         break;
 209                     case NSS_STATUS_NOTFOUND:
 210                         /* FALLTHRU */
 211                     default:
 212                         rq->f_status = NS_NOTFOUND;
 213                 }
 214
 215                 return NSD_NEXT;
 216         }
 217
 218         switch ((int)rq->f_cmd_data) {
 219             case WINBINDD_WINS_BYNAME:
 220             case WINBINDD_WINS_BYIP:
 221                 nsd_logprintf(NSD_LOG_MIN,
 222                         "callback (winbind) WINS_BYNAME | WINS_BYIP\n");
 223
 224                 rlen = asprintf(&result, "%s\n", response.data.winsresp);
 225                 if (rlen == 0 || result == NULL) {
 226                         return NSD_ERROR;
 227                 }
 228
 229                 winbindd_free_response(&response);
 230
 231                 nsd_logprintf(NSD_LOG_MIN, "    %s\n", result);
 232                 nsd_set_result(rq, NS_SUCCESS, result, rlen, DYNAMIC);
 233                 return NSD_OK;
 234
 235             case WINBINDD_GETPWUID:
 236             case WINBINDD_GETPWNAM:
 237             {
 238                 struct winbindd_pw *pw = &response.data.pw;
 239
 240                 nsd_logprintf(NSD_LOG_MIN,
 241                         "callback (winbind) GETPWUID | GETPWUID\n");
 242
 243                 rlen = asprintf(&result,"%s:%s:%d:%d:%s:%s:%s\n",
 244                                 pw->pw_name,
 245                                 pw->pw_passwd,
 246                                 pw->pw_uid,
 247                                 pw->pw_gid,
 248                                 pw->pw_gecos,
 249                                 pw->pw_dir,
 250                                 pw->pw_shell);
 251                 if (rlen == 0 || result == NULL)
 252                     return NSD_ERROR;
 253
 254                 winbindd_free_response(&response);
 255
 256                 nsd_logprintf(NSD_LOG_MIN, "    %s\n", result);
 257                 nsd_set_result(rq, NS_SUCCESS, result, rlen, DYNAMIC);
 258                 return NSD_OK;
 259             }
 260
 261             case WINBINDD_GETGRNAM:
 262             case WINBINDD_GETGRGID:
 263             {
 264                 const struct winbindd_gr *gr = &response.data.gr;
 265                 const char * members;
 266
 267                 nsd_logprintf(NSD_LOG_MIN,
 268                         "callback (winbind) GETGRNAM | GETGRGID\n");
 269
 270                 if (gr->num_gr_mem && response.extra_data.data) {
 271                         members = response.extra_data.data;
 272                 } else {
 273                         members = "";
 274                 }
 275
 276                 rlen = asprintf(&result, "%s:%s:%d:%s\n",
 277                             gr->gr_name, gr->gr_passwd, gr->gr_gid, members);
 278                 if (rlen == 0 || result == NULL)
 279                     return NSD_ERROR;
 280
 281                 winbindd_free_response(&response);
 282
 283                 nsd_logprintf(NSD_LOG_MIN, "    %s\n", result);
 284                 nsd_set_result(rq, NS_SUCCESS, result, rlen, DYNAMIC);
 285                 return NSD_OK;
 286             }
 287
 288             case WINBINDD_SETGRENT:
 289             case WINBINDD_SETPWENT:
 290                 nsd_logprintf(NSD_LOG_MIN,
 291                         "callback (winbind) SETGRENT | SETPWENT\n");
 292                 winbindd_free_response(&response);
 293                 return(do_list(1,rq));
 294
 295             case WINBINDD_GETGRENT:
 296             case WINBINDD_GETGRLST:
 297             {
 298                 int entries;
 299
 300                 nsd_logprintf(NSD_LOG_MIN,
 301                     "callback (winbind) GETGRENT | GETGRLIST %d responses\n",
 302                     response.data.num_entries);
 303
 304                 if (response.data.num_entries) {
 305                     const struct winbindd_gr *gr = &response.data.gr;
 306                     const char * members;
 307                     fstring grp_name;
 308                     int     i;
 309
 310                     gr = (struct winbindd_gr *)response.extra_data.data;
 311                     if (! gr ) {
 312                         nsd_logprintf(NSD_LOG_MIN, "     no extra_data\n");
 313                         winbindd_free_response(&response);
 314                         return NSD_ERROR;
 315                     }
 316
 317                     members = (char *)response.extra_data.data +
 318                         (response.data.num_entries * sizeof(struct winbindd_gr));
 319
 320                     for (i = 0; i < response.data.num_entries; i++) {
 321                         snprintf(grp_name, sizeof(grp_name) - 1, "%s:%s:%d:",
 322                                     gr->gr_name, gr->gr_passwd, gr->gr_gid);
 323
 324                         nsd_append_element(rq, NS_SUCCESS, result, rlen);
 325                         nsd_append_result(rq, NS_SUCCESS,
 326                                 &members[gr->gr_mem_ofs],
 327                                 strlen(&members[gr->gr_mem_ofs]));
 328
 329                         /* Don't log the whole list, because it might be
 330                          * _really_ long and we probably don't want to clobber
 331                          * the log with it.
 332                          */
 333                         nsd_logprintf(NSD_LOG_MIN, "    %s (...)\n", grp_name);
 334
 335                         gr++;
 336                     }
 337                 }
 338
 339                 entries = response.data.num_entries;
 340                 winbindd_free_response(&response);
 341                 if (entries < MAX_GETPWENT_USERS)
 342                     return(do_list(2,rq));
 343                 else
 344                     return(do_list(1,rq));
 345             }
 346
 347             case WINBINDD_GETPWENT:
 348             {
 349                 int entries;
 350
 351                 nsd_logprintf(NSD_LOG_MIN,
 352                         "callback (winbind) GETPWENT  %d responses\n",
 353                         response.data.num_entries);
 354
 355                 if (response.data.num_entries) {
 356                     struct winbindd_pw *pw = &response.data.pw;
 357                     int i;
 358
 359                     pw = (struct winbindd_pw *)response.extra_data.data;
 360                     if (! pw ) {
 361                         nsd_logprintf(NSD_LOG_MIN, "     no extra_data\n");
 362                         winbindd_free_response(&response);
 363                         return NSD_ERROR;
 364                     }
 365                     for (i = 0; i < response.data.num_entries; i++) {
 366                         result = NULL;
 367                         rlen = asprintf(&result, "%s:%s:%d:%d:%s:%s:%s",
 368                                         pw->pw_name,
 369                                         pw->pw_passwd,
 370                                         pw->pw_uid,
 371                                         pw->pw_gid,
 372                                         pw->pw_gecos,
 373                                         pw->pw_dir,
 374                                         pw->pw_shell);
 375
 376                         if (rlen != 0 && result != NULL) {
 377                             nsd_logprintf(NSD_LOG_MIN, "    %s\n",result);
 378                             nsd_append_element(rq, NS_SUCCESS, result, rlen);
 379                             free(result);
 380                         }
 381
 382                         pw++;
 383                     }
 384                 }
 385
 386                 entries = response.data.num_entries;
 387                 winbindd_free_response(&response);
 388                 if (entries < MAX_GETPWENT_USERS)
 389                     return(do_list(2,rq));
 390                 else
 391                     return(do_list(1,rq));
 392             }
 393
 394             case WINBINDD_ENDGRENT:
 395             case WINBINDD_ENDPWENT:
 396                 nsd_logprintf(NSD_LOG_MIN, "callback (winbind) ENDGRENT | ENDPWENT\n");
 397                 nsd_append_element(rq, NS_SUCCESS, "\n", 1);
 398                 winbindd_free_response(&response);
 399                 return NSD_NEXT;
 400
 401             default:
 402                 winbindd_free_response(&response);
 403                 nsd_logprintf(NSD_LOG_MIN, "callback (winbind) invalid command %d\n", (int)rq->f_cmd_data);
 404                 return NSD_NEXT;
 405         }
 406 }
 407
 408 static int
 409 winbind_timeout(nsd_file_t **rqp, nsd_times_t *to)
 410 {
 411         nsd_file_t *rq;
 412
 413         dequeue_request();
 414
 415         nsd_logprintf(NSD_LOG_MIN, "timeout (winbind)\n");
 416
 417         rq = to->t_file;
 418         *rqp = rq;
 419
 420         /* Remove the callback and timeout */
 421         nsd_callback_remove(winbindd_fd);
 422         nsd_timeout_remove(rq);
 423
 424         rq->f_status = NS_NOTFOUND;
 425         return NSD_NEXT;
 426 }
 427
 428 static int
 429 send_next_request(nsd_file_t *rq, struct winbindd_request *request)
 430 {
 431         NSS_STATUS status;
 432         long timeout;
 433
 434         switch (rq->f_index) {
 435                 case LOOKUP:
 436                         timeout = nsd_attr_fetch_long(rq->f_attrs,
 437                                         "lookup_timeout", 10, 10);
 438                         break;
 439                 case LIST:
 440                         timeout = nsd_attr_fetch_long(rq->f_attrs,
 441                                         "list_timeout", 10, 10);
 442                         break;
 443                 default:
 444                         nsd_logprintf(NSD_LOG_OPER,
 445                                 "send_next_request (winbind) "
 446                                 "invalid request type %d\n", rq->f_index);
 447                         rq->f_status = NS_BADREQ;
 448                         return NSD_NEXT;
 449         }
 450
 451         nsd_logprintf(NSD_LOG_MIN,
 452                 "send_next_request (winbind) %d, timeout = %d sec\n",
 453                         rq->f_cmd_data, timeout);
 454         status = winbindd_send_request((int)rq->f_cmd_data,0,request);
 455         SAFE_FREE(request);
 456
 457         if (status != NSS_STATUS_SUCCESS) {
 458                 nsd_logprintf(NSD_LOG_MIN,
 459                         "send_next_request (winbind) error status = %d\n",
 460                         status);
 461                 rq->f_status = status;
 462                 return NSD_NEXT;
 463         }
 464
 465         current_rq = rq;
 466
 467         /*
 468          * Set up callback and timeouts
 469          */
 470         nsd_logprintf(NSD_LOG_MIN, "send_next_request (winbind) fd = %d\n",
 471                 winbindd_fd);
 472
 473         nsd_callback_new(winbindd_fd, winbind_callback, NSD_READ);
 474         nsd_timeout_new(rq, timeout * 1000, winbind_timeout, NULL);
 475         return NSD_CONTINUE;
 476 }
 477
 478 int init(void)
 479 {
 480         nsd_logprintf(NSD_LOG_MIN, "entering init (winbind)\n");
 481         return(NSD_OK);
 482 }
 483
 484 int lookup(nsd_file_t *rq)
 485 {
 486         char *map;
 487         char *key;
 488         struct winbindd_request *request;
 489
 490         nsd_logprintf(NSD_LOG_MIN, "entering lookup (winbind)\n");
 491         if (! rq)
 492                 return NSD_ERROR;
 493
 494         map = nsd_attr_fetch_string(rq->f_attrs, "table", (char*)0);
 495         key = nsd_attr_fetch_string(rq->f_attrs, "key", (char*)0);
 496         if (! map || ! key) {
 497                 nsd_logprintf(NSD_LOG_MIN, "lookup (winbind) table or key not defined\n");
 498                 rq->f_status = NS_BADREQ;
 499                 return NSD_ERROR;
 500         }
 501
 502         nsd_logprintf(NSD_LOG_MIN, "lookup (winbind %s)\n",map);
 503
 504         request = (struct winbindd_request *)nsd_calloc(1,sizeof(struct winbindd_request));
 505         if (! request) {
 506                 nsd_logprintf(NSD_LOG_RESOURCE,
 507                         "lookup (winbind): failed malloc\n");
 508                 return NSD_ERROR;
 509         }
 510
 511         if (strcasecmp(map,"passwd.byuid") == 0) {
 512             request->data.uid = atoi(key);
 513             rq->f_cmd_data = (void *)WINBINDD_GETPWUID;
 514         } else if (strcasecmp(map,"passwd.byname") == 0) {
 515             strncpy(request->data.username, key,
 516                 sizeof(request->data.username) - 1);
 517             request->data.username[sizeof(request->data.username) - 1] = '\0';
 518             rq->f_cmd_data = (void *)WINBINDD_GETPWNAM;
 519         } else if (strcasecmp(map,"group.byname") == 0) {
 520             strncpy(request->data.groupname, key,
 521                 sizeof(request->data.groupname) - 1);
 522             request->data.groupname[sizeof(request->data.groupname) - 1] = '\0';
 523             rq->f_cmd_data = (void *)WINBINDD_GETGRNAM;
 524         } else if (strcasecmp(map,"group.bygid") == 0) {
 525             request->data.gid = atoi(key);
 526             rq->f_cmd_data = (void *)WINBINDD_GETGRGID;
 527         } else if (strcasecmp(map,"hosts.byname") == 0) {
 528             strncpy(request->data.winsreq, key, sizeof(request->data.winsreq) - 1);
 529             request->data.winsreq[sizeof(request->data.winsreq) - 1] = '\0';
 530             rq->f_cmd_data = (void *)WINBINDD_WINS_BYNAME;
 531         } else if (strcasecmp(map,"hosts.byaddr") == 0) {
 532             strncpy(request->data.winsreq, key, sizeof(request->data.winsreq) - 1);
 533             request->data.winsreq[sizeof(request->data.winsreq) - 1] = '\0';
 534             rq->f_cmd_data = (void *)WINBINDD_WINS_BYIP;
 535         } else {
 536                 /*
 537                  * Don't understand this map - just return not found
 538                  */
 539                 nsd_logprintf(NSD_LOG_MIN, "lookup (winbind) unknown table\n");
 540                 SAFE_FREE(request);
 541                 rq->f_status = NS_NOTFOUND;
 542                 return NSD_NEXT;
 543         }
 544
 545         return(do_request(rq, request));
 546 }
 547
 548 int list(nsd_file_t *rq)
 549 {
 550         char *map;
 551
 552         nsd_logprintf(NSD_LOG_MIN, "entering list (winbind)\n");
 553         if (! rq)
 554                 return NSD_ERROR;
 555
 556         map = nsd_attr_fetch_string(rq->f_attrs, "table", (char*)0);
 557         if (! map ) {
 558                 nsd_logprintf(NSD_LOG_MIN, "list (winbind) table not defined\n");
 559                 rq->f_status = NS_BADREQ;
 560                 return NSD_ERROR;
 561         }
 562
 563         nsd_logprintf(NSD_LOG_MIN, "list (winbind %s)\n",map);
 564
 565         return (do_list(0,rq));
 566 }
 567
 568 static int
 569 do_list(int state, nsd_file_t *rq)
 570 {
 571         char *map;
 572         struct winbindd_request *request;
 573
 574         nsd_logprintf(NSD_LOG_MIN, "entering do_list (winbind) state = %d\n",state);
 575
 576         map = nsd_attr_fetch_string(rq->f_attrs, "table", (char*)0);
 577         request = (struct winbindd_request *)nsd_calloc(1,sizeof(struct winbindd_request));
 578         if (! request) {
 579                 nsd_logprintf(NSD_LOG_RESOURCE,
 580                         "do_list (winbind): failed malloc\n");
 581                 return NSD_ERROR;
 582         }
 583
 584         if (strcasecmp(map,"passwd.byname") == 0) {
 585             switch (state) {
 586                 case 0:
 587                     rq->f_cmd_data = (void *)WINBINDD_SETPWENT;
 588                     break;
 589                 case 1:
 590                     request->data.num_entries = MAX_GETPWENT_USERS;
 591                     rq->f_cmd_data = (void *)WINBINDD_GETPWENT;
 592                     break;
 593                 case 2:
 594                     rq->f_cmd_data = (void *)WINBINDD_ENDPWENT;
 595                     break;
 596                 default:
 597                     nsd_logprintf(NSD_LOG_MIN, "do_list (winbind) unknown state\n");
 598                     SAFE_FREE(request);
 599                     rq->f_status = NS_NOTFOUND;
 600                     return NSD_NEXT;
 601             }
 602         } else if (strcasecmp(map,"group.byname") == 0) {
 603             switch (state) {
 604                 case 0:
 605                     rq->f_cmd_data = (void *)WINBINDD_SETGRENT;
 606                     break;
 607                 case 1:
 608                     request->data.num_entries = MAX_GETGRENT_USERS;
 609                     rq->f_cmd_data = (void *)WINBINDD_GETGRENT;
 610                     break;
 611                 case 2:
 612                     rq->f_cmd_data = (void *)WINBINDD_ENDGRENT;
 613                     break;
 614                 default:
 615                     nsd_logprintf(NSD_LOG_MIN, "do_list (winbind) unknown state\n");
 616                     SAFE_FREE(request);
 617                     rq->f_status = NS_NOTFOUND;
 618                     return NSD_NEXT;
 619             }
 620         } else {
 621                 /*
 622                  * Don't understand this map - just return not found
 623                  */
 624                 nsd_logprintf(NSD_LOG_MIN, "do_list (winbind) unknown table\n");
 625                 SAFE_FREE(request);
 626                 rq->f_status = NS_NOTFOUND;
 627                 return NSD_NEXT;
 628         }
 629
 630         return(do_request(rq, request));
 631 }
 632
 633 #endif /* HAVE_NS_API_H */