nsswitch/winbind_nss_aix.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    AIX loadable authentication module, providing identification and
   5    authentication routines against Samba winbind/Windows NT Domain
   6
   7    Copyright (C) Tim Potter 2003
   8    Copyright (C) Steve Roylance 2003
   9    Copyright (C) Andrew Tridgell 2003-2004
  10
  11    This library is free software; you can redistribute it and/or
  12    modify it under the terms of the GNU Lesser General Public
  13    License as published by the Free Software Foundation; either
  14    version 3 of the License, or (at your option) any later version.
  15
  16    This library 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 GNU
  19    Library General Public License for more details.
  20
  21    You should have received a copy of the GNU Lesser General Public License
  22    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  23 */
  24
  25 /*
  26
  27   To install this module copy nsswitch/WINBIND to /usr/lib/security and add
  28   "WINBIND" in /usr/lib/security/methods.cfg and /etc/security/user
  29
  30   Note that this module also provides authentication and password
  31   changing routines, so you do not need to install the winbind PAM
  32   module.
  33
  34   see
  35   http://publib16.boulder.ibm.com/doc_link/en_US/a_doc_lib/aixprggd/kernextc/sec_load_mod.htm
  36   for some information in the interface that this module implements
  37
  38   Many thanks to Julianne Haugh for explaining some of the finer
  39   details of this interface.
  40
  41   To debug this module use uess_test.c (which you can get from tridge)
  42   or set "options=debug" in /usr/lib/security/methods.cfg
  43
  44 */
  45
  46 #include "winbind_client.h"
  47 #include <usersec.h>
  48
  49 /* enable this to log which entry points have not been
  50   completed yet */
  51 #define LOG_UNIMPLEMENTED_CALLS 0
  52
  53
  54 #define WB_AIX_ENCODED '_'
  55
  56 static int debug_enabled;
  57
  58
  59 static void logit(const char *format, ...)
  60 {
  61         va_list ap;
  62         FILE *f;
  63         if (!debug_enabled) {
  64                 return;
  65         }
  66         f = fopen("/tmp/WINBIND_DEBUG.log", "a");
  67         if (!f) return;
  68         va_start(ap, format);
  69         vfprintf(f, format, ap);
  70         va_end(ap);
  71         fclose(f);
  72 }
  73
  74
  75 #define HANDLE_ERRORS(ret) do { \
  76         if ((ret) == NSS_STATUS_NOTFOUND) { \
  77                 errno = ENOENT; \
  78                 return NULL; \
  79         } else if ((ret) != NSS_STATUS_SUCCESS) { \
  80                 errno = EIO; \
  81                 return NULL; \
  82         } \
  83 } while (0)
  84
  85 #define STRCPY_RET(dest, src) \
  86 do { \
  87         if (strlen(src)+1 > sizeof(dest)) { errno = EINVAL; return -1; } \
  88         strncpy(dest, src, sizeof(dest)); \
  89         dest[sizeof(dest)-1] = '\0'; \
  90 } while (0)
  91
  92 #define STRCPY_RETNULL(dest, src) \
  93 do { \
  94         if (strlen(src)+1 > sizeof(dest)) { errno = EINVAL; return NULL; } \
  95         strncpy(dest, src, sizeof(dest)); \
  96         dest[sizeof(dest)-1] = '\0'; \
  97 } while (0)
  98
  99
 100 /* free a passwd structure */
 101 static void free_pwd(struct passwd *pwd)
 102 {
 103         free(pwd->pw_name);
 104         free(pwd->pw_passwd);
 105         free(pwd->pw_gecos);
 106         free(pwd->pw_dir);
 107         free(pwd->pw_shell);
 108         free(pwd);
 109 }
 110
 111 /* free a group structure */
 112 static void free_grp(struct group *grp)
 113 {
 114         int i;
 115
 116         free(grp->gr_name);
 117         free(grp->gr_passwd);
 118
 119         if (!grp->gr_mem) {
 120                 free(grp);
 121                 return;
 122         }
 123
 124         for (i=0; grp->gr_mem[i]; i++) {
 125                 free(grp->gr_mem[i]);
 126         }
 127
 128         free(grp->gr_mem);
 129         free(grp);
 130 }
 131
 132
 133 /* replace commas with nulls, and null terminate */
 134 static void replace_commas(char *s)
 135 {
 136         char *p, *p0=s;
 137         for (p=strchr(s, ','); p; p = strchr(p+1, ',')) {
 138                 *p=0;
 139                 p0 = p+1;
 140         }
 141
 142         p0[strlen(p0)+1] = 0;
 143 }
 144
 145
 146 /* the decode_*() routines are used to cope with the fact that AIX 5.2
 147    and below cannot handle user or group names longer than 8
 148    characters in some interfaces. We use the normalize method to
 149    provide a mapping to a username that fits, by using the form '_UID'
 150    or '_GID'.
 151
 152    this only works if you can guarantee that the WB_AIX_ENCODED char
 153    is not used as the first char of any other username
 154 */
 155 static unsigned decode_id(const char *name)
 156 {
 157         unsigned id;
 158         sscanf(name+1, "%u", &id);
 159         return id;
 160 }
 161
 162 static struct passwd *wb_aix_getpwuid(uid_t uid);
 163
 164 static char *decode_user(const char *name)
 165 {
 166         struct passwd *pwd;
 167         unsigned id;
 168         char *ret;
 169
 170         sscanf(name+1, "%u", &id);
 171         pwd = wb_aix_getpwuid(id);
 172         if (!pwd) {
 173                 return NULL;
 174         }
 175         ret = strdup(pwd->pw_name);
 176
 177         free_pwd(pwd);
 178
 179         logit("decoded '%s' -> '%s'\n", name, ret);
 180
 181         return ret;
 182 }
 183
 184
 185 /*
 186   fill a struct passwd from a winbindd_pw struct, allocating as a single block
 187 */
 188 static struct passwd *fill_pwent(struct winbindd_pw *pw)
 189 {
 190         struct passwd *result;
 191
 192         result = calloc(1, sizeof(struct passwd));
 193         if (!result) {
 194                 errno = ENOMEM;
 195                 return NULL;
 196         }
 197
 198         result->pw_uid = pw->pw_uid;
 199         result->pw_gid = pw->pw_gid;
 200         result->pw_name   = strdup(pw->pw_name);
 201         result->pw_passwd = strdup(pw->pw_passwd);
 202         result->pw_gecos  = strdup(pw->pw_gecos);
 203         result->pw_dir    = strdup(pw->pw_dir);
 204         result->pw_shell  = strdup(pw->pw_shell);
 205
 206         return result;
 207 }
 208
 209
 210 /*
 211   fill a struct group from a winbindd_pw struct, allocating as a single block
 212 */
 213 static struct group *fill_grent(struct winbindd_gr *gr, char *gr_mem)
 214 {
 215         int i;
 216         struct group *result;
 217         char *p, *name;
 218
 219         result = calloc(1, sizeof(struct group));
 220         if (!result) {
 221                 errno = ENOMEM;
 222                 return NULL;
 223         }
 224
 225         result->gr_gid = gr->gr_gid;
 226
 227         result->gr_name   = strdup(gr->gr_name);
 228         result->gr_passwd = strdup(gr->gr_passwd);
 229
 230         /* Group membership */
 231         if ((gr->num_gr_mem < 0) || !gr_mem) {
 232                 gr->num_gr_mem = 0;
 233         }
 234
 235         if (gr->num_gr_mem == 0) {
 236                 /* Group is empty */
 237                 return result;
 238         }
 239
 240         result->gr_mem = (char **)malloc(sizeof(char *) * (gr->num_gr_mem+1));
 241         if (!result->gr_mem) {
 242                 free(result->gr_name);
 243                 free(result->gr_passwd);
 244                 free(result);
 245                 errno = ENOMEM;
 246                 return NULL;
 247         }
 248
 249         /* Start looking at extra data */
 250         i=0;
 251         for (name = strtok_r(gr_mem, ",", &p);
 252              name;
 253              name = strtok_r(NULL, ",", &p)) {
 254                 if (i == gr->num_gr_mem) {
 255                         break;
 256                 }
 257                 result->gr_mem[i] = strdup(name);
 258                 i++;
 259         }
 260
 261         /* Terminate list */
 262         result->gr_mem[i] = NULL;
 263
 264         return result;
 265 }
 266
 267
 268
 269 /* take a group id and return a filled struct group */
 270 static struct group *wb_aix_getgrgid(gid_t gid)
 271 {
 272         struct winbindd_response response;
 273         struct winbindd_request request;
 274         struct group *grp;
 275         NSS_STATUS ret;
 276
 277         logit("getgrgid %d\n", gid);
 278
 279         ZERO_STRUCT(response);
 280         ZERO_STRUCT(request);
 281
 282         request.data.gid = gid;
 283
 284         ret = winbindd_request_response(NULL, WINBINDD_GETGRGID,
 285                                         &request, &response);
 286
 287         logit("getgrgid ret=%d\n", ret);
 288
 289         HANDLE_ERRORS(ret);
 290
 291         grp = fill_grent(&response.data.gr, response.extra_data.data);
 292
 293         winbindd_free_response(&response);
 294
 295         return grp;
 296 }
 297
 298 /* take a group name and return a filled struct group */
 299 static struct group *wb_aix_getgrnam(const char *name)
 300 {
 301         struct winbindd_response response;
 302         struct winbindd_request request;
 303         NSS_STATUS ret;
 304         struct group *grp;
 305
 306         if (*name == WB_AIX_ENCODED) {
 307                 return wb_aix_getgrgid(decode_id(name));
 308         }
 309
 310         logit("getgrnam '%s'\n", name);
 311
 312         ZERO_STRUCT(response);
 313         ZERO_STRUCT(request);
 314
 315         STRCPY_RETNULL(request.data.groupname, name);
 316
 317         ret = winbindd_request_response(NULL, WINBINDD_GETGRNAM,
 318                                         &request, &response);
 319
 320         HANDLE_ERRORS(ret);
 321
 322         grp = fill_grent(&response.data.gr, response.extra_data.data);
 323
 324         winbindd_free_response(&response);
 325
 326         return grp;
 327 }
 328
 329
 330 /* this call doesn't have to fill in the gr_mem, but we do anyway
 331    for simplicity */
 332 static struct group *wb_aix_getgracct(void *id, int type)
 333 {
 334         if (type == 1) {
 335                 return wb_aix_getgrnam((char *)id);
 336         }
 337         if (type == 0) {
 338                 return wb_aix_getgrgid(*(int *)id);
 339         }
 340         errno = EINVAL;
 341         return NULL;
 342 }
 343
 344
 345 /* take a username and return a string containing a comma-separated
 346    list of group id numbers to which the user belongs */
 347 static char *wb_aix_getgrset(char *user)
 348 {
 349         struct winbindd_response response;
 350         struct winbindd_request request;
 351         NSS_STATUS ret;
 352         int i, idx;
 353         char *tmpbuf;
 354         int num_gids;
 355         gid_t *gid_list;
 356         char *r_user = user;
 357
 358         if (*user == WB_AIX_ENCODED) {
 359                 r_user = decode_user(r_user);
 360                 if (!r_user) {
 361                         errno = ENOENT;
 362                         return NULL;
 363                 }
 364         }
 365
 366         logit("getgrset '%s'\n", r_user);
 367
 368         ZERO_STRUCT(response);
 369         ZERO_STRUCT(request);
 370
 371         STRCPY_RETNULL(request.data.username, r_user);
 372
 373         if (*user == WB_AIX_ENCODED) {
 374                 free(r_user);
 375         }
 376
 377         ret = winbindd_request_response(NULL, WINBINDD_GETGROUPS,
 378                                         &request, &response);
 379
 380         HANDLE_ERRORS(ret);
 381
 382         num_gids = response.data.num_entries;
 383         gid_list = (gid_t *)response.extra_data.data;
 384
 385         /* allocate a space large enough to contruct the string */
 386         tmpbuf = malloc(num_gids*12);
 387         if (!tmpbuf) {
 388                 return NULL;
 389         }
 390
 391         for (idx=i=0; i < num_gids-1; i++) {
 392                 idx += sprintf(tmpbuf+idx, "%u,", gid_list[i]);
 393         }
 394         idx += sprintf(tmpbuf+idx, "%u", gid_list[i]);
 395
 396         winbindd_free_response(&response);
 397
 398         return tmpbuf;
 399 }
 400
 401
 402 /* take a uid and return a filled struct passwd */
 403 static struct passwd *wb_aix_getpwuid(uid_t uid)
 404 {
 405         struct winbindd_response response;
 406         struct winbindd_request request;
 407         NSS_STATUS ret;
 408         struct passwd *pwd;
 409
 410         logit("getpwuid '%d'\n", uid);
 411
 412         ZERO_STRUCT(response);
 413         ZERO_STRUCT(request);
 414
 415         request.data.uid = uid;
 416
 417         ret = winbindd_request_response(NULL, WINBINDD_GETPWUID,
 418                                         &request, &response);
 419
 420         HANDLE_ERRORS(ret);
 421
 422         pwd = fill_pwent(&response.data.pw);
 423
 424         winbindd_free_response(&response);
 425
 426         logit("getpwuid gave ptr %p\n", pwd);
 427
 428         return pwd;
 429 }
 430
 431
 432 /* take a username and return a filled struct passwd */
 433 static struct passwd *wb_aix_getpwnam(const char *name)
 434 {
 435         struct winbindd_response response;
 436         struct winbindd_request request;
 437         NSS_STATUS ret;
 438         struct passwd *pwd;
 439
 440         if (*name == WB_AIX_ENCODED) {
 441                 return wb_aix_getpwuid(decode_id(name));
 442         }
 443
 444         logit("getpwnam '%s'\n", name);
 445
 446         ZERO_STRUCT(response);
 447         ZERO_STRUCT(request);
 448
 449         STRCPY_RETNULL(request.data.username, name);
 450
 451         ret = winbindd_request_response(NULL, WINBINDD_GETPWNAM,
 452                                         &request, &response);
 453
 454         HANDLE_ERRORS(ret);
 455
 456         pwd = fill_pwent(&response.data.pw);
 457
 458         winbindd_free_response(&response);
 459
 460         logit("getpwnam gave ptr %p\n", pwd);
 461
 462         return pwd;
 463 }
 464
 465 /*
 466   list users
 467 */
 468 static int wb_aix_lsuser(char *attributes[], attrval_t results[], int size)
 469 {
 470         NSS_STATUS ret;
 471         struct winbindd_request request;
 472         struct winbindd_response response;
 473         int len;
 474         char *s;
 475
 476         if (size != 1 || strcmp(attributes[0], S_USERS) != 0) {
 477                 logit("invalid lsuser op\n");
 478                 errno = EINVAL;
 479                 return -1;
 480         }
 481
 482         ZERO_STRUCT(request);
 483         ZERO_STRUCT(response);
 484
 485         ret = winbindd_request_response(NULL, WINBINDD_LIST_USERS,
 486                                         &request, &response);
 487         if (ret != 0) {
 488                 errno = EINVAL;
 489                 return -1;
 490         }
 491
 492         len = strlen(response.extra_data.data);
 493
 494         s = malloc(len+2);
 495         if (!s) {
 496                 winbindd_free_response(&response);
 497                 errno = ENOMEM;
 498                 return -1;
 499         }
 500
 501         memcpy(s, response.extra_data.data, len+1);
 502
 503         replace_commas(s);
 504
 505         results[0].attr_un.au_char = s;
 506         results[0].attr_flag = 0;
 507
 508         winbindd_free_response(&response);
 509
 510         return 0;
 511 }
 512
 513
 514 /*
 515   list groups
 516 */
 517 static int wb_aix_lsgroup(char *attributes[], attrval_t results[], int size)
 518 {
 519         NSS_STATUS ret;
 520         struct winbindd_request request;
 521         struct winbindd_response response;
 522         int len;
 523         char *s;
 524
 525         if (size != 1 || strcmp(attributes[0], S_GROUPS) != 0) {
 526                 logit("invalid lsgroup op\n");
 527                 errno = EINVAL;
 528                 return -1;
 529         }
 530
 531         ZERO_STRUCT(request);
 532         ZERO_STRUCT(response);
 533
 534         ret = winbindd_request_response(NULL, WINBINDD_LIST_GROUPS,
 535                                         &request, &response);
 536         if (ret != 0) {
 537                 errno = EINVAL;
 538                 return -1;
 539         }
 540
 541         len = strlen(response.extra_data.data);
 542
 543         s = malloc(len+2);
 544         if (!s) {
 545                 winbindd_free_response(&response);
 546                 errno = ENOMEM;
 547                 return -1;
 548         }
 549
 550         memcpy(s, response.extra_data.data, len+1);
 551
 552         replace_commas(s);
 553
 554         results[0].attr_un.au_char = s;
 555         results[0].attr_flag = 0;
 556
 557         winbindd_free_response(&response);
 558
 559         return 0;
 560 }
 561
 562
 563 static attrval_t pwd_to_group(struct passwd *pwd)
 564 {
 565         attrval_t r;
 566         struct group *grp = wb_aix_getgrgid(pwd->pw_gid);
 567
 568         if (!grp) {
 569                 r.attr_flag = EINVAL;
 570         } else {
 571                 r.attr_flag = 0;
 572                 r.attr_un.au_char = strdup(grp->gr_name);
 573                 free_grp(grp);
 574         }
 575
 576         return r;
 577 }
 578
 579 static attrval_t pwd_to_groupsids(struct passwd *pwd)
 580 {
 581         attrval_t r;
 582         char *s, *p;
 583         size_t mlen;
 584
 585         if ( (s = wb_aix_getgrset(pwd->pw_name)) == NULL ) {
 586                 r.attr_flag = EINVAL;
 587                 return r;
 588         }
 589
 590         mlen = strlen(s)+2;
 591         if ( (p = malloc(mlen)) == NULL ) {
 592                 r.attr_flag = ENOMEM;
 593                 return r;
 594         }
 595
 596         strncpy(p, s, mlen);
 597         p[mlen-1] = '\0';
 598         replace_commas(p);
 599         free(s);
 600
 601         r.attr_un.au_char = p;
 602
 603         return r;
 604 }
 605
 606 static attrval_t pwd_to_sid(struct passwd *pwd)
 607 {
 608         struct winbindd_request request;
 609         struct winbindd_response response;
 610         attrval_t r;
 611
 612         ZERO_STRUCT(request);
 613         ZERO_STRUCT(response);
 614
 615         request.data.uid = pwd->pw_uid;
 616
 617 #if 0
 618         /*
 619          * Removed because WINBINDD_UID_TO_SID is replaced by
 620          * WINBINDD_XIDS_TO_SIDS. I don't have an AIX build
 621          * environment around, so I did not convert this call. If
 622          * someone stumbles over this, please contact me:
 623          * vl@samba.org, I'll convert this.
 624          */
 625         if (winbindd_request_response(NULL, WINBINDD_UID_TO_SID,
 626                                       &request, &response) !=
 627             NSS_STATUS_SUCCESS) {
 628                 r.attr_flag = ENOENT;
 629         } else {
 630                 r.attr_flag = 0;
 631                 r.attr_un.au_char = strdup(response.data.sid.sid);
 632         }
 633 #else
 634         r.attr_flag = ENOENT;
 635 #endif
 636
 637         return r;
 638 }
 639
 640 static int wb_aix_user_attrib(const char *key, char *attributes[],
 641                               attrval_t results[], int size)
 642 {
 643         struct passwd *pwd;
 644         int i;
 645
 646         pwd = wb_aix_getpwnam(key);
 647         if (!pwd) {
 648                 errno = ENOENT;
 649                 return -1;
 650         }
 651
 652         for (i=0;i<size;i++) {
 653                 results[i].attr_flag = 0;
 654
 655                 if (strcmp(attributes[i], S_ID) == 0) {
 656                         results[i].attr_un.au_int = pwd->pw_uid;
 657 #ifdef _AIXVERSION_530
 658                 } else if (strcmp(attributes[i], S_PGID) == 0) {
 659                         results[i].attr_un.au_int = pwd->pw_gid;
 660 #endif
 661                 } else if (strcmp(attributes[i], S_PWD) == 0) {
 662                         results[i].attr_un.au_char = strdup(pwd->pw_passwd);
 663                 } else if (strcmp(attributes[i], S_HOME) == 0) {
 664                         results[i].attr_un.au_char = strdup(pwd->pw_dir);
 665                 } else if (strcmp(attributes[i], S_SHELL) == 0) {
 666                         results[i].attr_un.au_char = strdup(pwd->pw_shell);
 667                 } else if (strcmp(attributes[i], S_REGISTRY) == 0) {
 668                         results[i].attr_un.au_char = strdup("WINBIND");
 669                 } else if (strcmp(attributes[i], S_GECOS) == 0) {
 670                         results[i].attr_un.au_char = strdup(pwd->pw_gecos);
 671                 } else if (strcmp(attributes[i], S_PGRP) == 0) {
 672                         results[i] = pwd_to_group(pwd);
 673                 } else if (strcmp(attributes[i], S_GROUPS) == 0) {
 674                         results[i] = pwd_to_groupsids(pwd);
 675                 } else if (strcmp(attributes[i], "SID") == 0) {
 676                         results[i] = pwd_to_sid(pwd);
 677                 } else {
 678                         logit("Unknown user attribute '%s'\n", attributes[i]);
 679                         results[i].attr_flag = EINVAL;
 680                 }
 681         }
 682
 683         free_pwd(pwd);
 684
 685         return 0;
 686 }
 687
 688 static int wb_aix_group_attrib(const char *key, char *attributes[],
 689                                attrval_t results[], int size)
 690 {
 691         struct group *grp;
 692         int i;
 693
 694         grp = wb_aix_getgrnam(key);
 695         if (!grp) {
 696                 errno = ENOENT;
 697                 return -1;
 698         }
 699
 700         for (i=0;i<size;i++) {
 701                 results[i].attr_flag = 0;
 702
 703                 if (strcmp(attributes[i], S_PWD) == 0) {
 704                         results[i].attr_un.au_char = strdup(grp->gr_passwd);
 705                 } else if (strcmp(attributes[i], S_ID) == 0) {
 706                         results[i].attr_un.au_int = grp->gr_gid;
 707                 } else {
 708                         logit("Unknown group attribute '%s'\n", attributes[i]);
 709                         results[i].attr_flag = EINVAL;
 710                 }
 711         }
 712
 713         free_grp(grp);
 714
 715         return 0;
 716 }
 717
 718
 719 /*
 720   called for user/group enumerations
 721 */
 722 static int wb_aix_getentry(char *key, char *table, char *attributes[],
 723                            attrval_t results[], int size)
 724 {
 725         logit("Got getentry with key='%s' table='%s' size=%d attributes[0]='%s'\n",
 726               key, table, size, attributes[0]);
 727
 728         if (strcmp(key, "ALL") == 0 &&
 729             strcmp(table, "user") == 0) {
 730                 return wb_aix_lsuser(attributes, results, size);
 731         }
 732
 733         if (strcmp(key, "ALL") == 0 &&
 734             strcmp(table, "group") == 0) {
 735                 return wb_aix_lsgroup(attributes, results, size);
 736         }
 737
 738         if (strcmp(table, "user") == 0) {
 739                 return wb_aix_user_attrib(key, attributes, results, size);
 740         }
 741
 742         if (strcmp(table, "group") == 0) {
 743                 return wb_aix_group_attrib(key, attributes, results, size);
 744         }
 745
 746         logit("Unknown getentry operation key='%s' table='%s'\n", key, table);
 747
 748         errno = ENOSYS;
 749         return -1;
 750 }
 751
 752
 753
 754 /*
 755   called to start the backend
 756 */
 757 static void *wb_aix_open(const char *name, const char *domain, int mode, char *options)
 758 {
 759         if (strstr(options, "debug")) {
 760                 debug_enabled = 1;
 761         }
 762         logit("open name='%s' mode=%d domain='%s' options='%s'\n", name, domain,
 763               mode, options);
 764         return NULL;
 765 }
 766
 767 static void wb_aix_close(void *token)
 768 {
 769         logit("close\n");
 770         return;
 771 }
 772
 773 #ifdef HAVE_STRUCT_SECMETHOD_TABLE_METHOD_ATTRLIST
 774 /*
 775    return a list of additional attributes supported by the backend
 776 */
 777 static attrlist_t **wb_aix_attrlist(void)
 778 {
 779         /* pretty confusing but we are allocating the array of pointers
 780            and the structures we'll be pointing to all at once.  So
 781            you need N+1 pointers and N structures. */
 782
 783         attrlist_t **ret = NULL;
 784         attrlist_t *offset = NULL;
 785         int i;
 786         int n;
 787         size_t size;
 788
 789         struct attr_types {
 790                 const char *name;
 791                 int flags;
 792                 int type;
 793         } attr_list[] = {
 794                 /* user attributes */
 795                 {S_ID,          AL_USERATTR,    SEC_INT},
 796                 {S_PGRP,        AL_USERATTR,    SEC_CHAR},
 797                 {S_HOME,        AL_USERATTR,    SEC_CHAR},
 798                 {S_SHELL,       AL_USERATTR,    SEC_CHAR},
 799 #ifdef _AIXVERSION_530
 800                 {S_PGID,        AL_USERATTR,    SEC_INT},
 801 #endif
 802                 {S_GECOS,       AL_USERATTR,    SEC_CHAR},
 803                 {S_SHELL,       AL_USERATTR,    SEC_CHAR},
 804                 {S_PGRP,        AL_USERATTR,    SEC_CHAR},
 805                 {S_GROUPS,      AL_USERATTR,    SEC_LIST},
 806                 {"SID",         AL_USERATTR,    SEC_CHAR},
 807
 808                 /* group attributes */
 809                 {S_ID,          AL_GROUPATTR,   SEC_INT}
 810         };
 811
 812         logit("method attrlist called\n");
 813
 814         n = sizeof(attr_list) / sizeof(struct attr_types);
 815         size = (n*sizeof(attrlist_t *));
 816
 817         if ( (ret = malloc( size )) == NULL ) {
 818                 errno = ENOMEM;
 819                 return NULL;
 820         }
 821
 822         /* offset to where the structures start in the buffer */
 823
 824         offset = (attrlist_t *)(ret + n);
 825
 826         /* now loop over the user_attr_list[] array and add
 827            all the members */
 828
 829         for ( i=0; i<n; i++ ) {
 830                 attrlist_t *a = malloc(sizeof(attrlist_t));
 831
 832                 if ( !a ) {
 833                         /* this is bad.  Just bail */
 834                         return NULL;
 835                 }
 836
 837                 a->al_name  = strdup(attr_list[i].name);
 838                 a->al_flags = attr_list[i].flags;
 839                 a->al_type  = attr_list[i].type;
 840
 841                 ret[i] = a;
 842         }
 843         ret[n] = NULL;
 844
 845         return ret;
 846 }
 847 #endif
 848
 849
 850 /*
 851   turn a long username into a short one. Needed to cope with the 8 char
 852   username limit in AIX 5.2 and below
 853 */
 854 static int wb_aix_normalize(char *longname, char *shortname)
 855 {
 856         struct passwd *pwd;
 857
 858         logit("normalize '%s'\n", longname);
 859
 860         /* automatically cope with AIX 5.3 with longer usernames
 861            when it comes out */
 862         if (S_NAMELEN > strlen(longname)) {
 863                 strncpy(shortname, longname, S_NAMELEN);
 864                 shortname[S_NAMELEN-1] = '\0';
 865                 return 1;
 866         }
 867
 868         pwd = wb_aix_getpwnam(longname);
 869         if (!pwd) {
 870                 errno = ENOENT;
 871                 return 0;
 872         }
 873
 874         sprintf(shortname, "%c%07u", WB_AIX_ENCODED, pwd->pw_uid);
 875
 876         free_pwd(pwd);
 877
 878         return 1;
 879 }
 880
 881
 882 /*
 883   authenticate a user
 884  */
 885 static int wb_aix_authenticate(char *user, char *pass,
 886                                int *reenter, char **message)
 887 {
 888         struct winbindd_request request;
 889         struct winbindd_response response;
 890         NSS_STATUS result;
 891         char *r_user = user;
 892
 893         logit("authenticate '%s' response='%s'\n", user, pass);
 894
 895         *reenter = 0;
 896         *message = NULL;
 897
 898         /* Send off request */
 899         ZERO_STRUCT(request);
 900         ZERO_STRUCT(response);
 901
 902         if (*user == WB_AIX_ENCODED) {
 903                 r_user = decode_user(r_user);
 904                 if (!r_user) {
 905                         return AUTH_NOTFOUND;
 906                 }
 907         }
 908
 909         STRCPY_RET(request.data.auth.user, r_user);
 910         STRCPY_RET(request.data.auth.pass, pass);
 911
 912         if (*user == WB_AIX_ENCODED) {
 913                 free(r_user);
 914         }
 915
 916         result = winbindd_request_response(NULL, WINBINDD_PAM_AUTH,
 917                                            &request, &response);
 918
 919         winbindd_free_response(&response);
 920
 921         logit("auth result %d for '%s'\n", result, user);
 922
 923         if (result == NSS_STATUS_SUCCESS) {
 924                 errno = 0;
 925                 return AUTH_SUCCESS;
 926         }
 927
 928         return AUTH_FAILURE;
 929 }
 930
 931
 932 /*
 933   change a user password
 934 */
 935 static int wb_aix_chpass(char *user, char *oldpass, char *newpass, char **message)
 936 {
 937         struct winbindd_request request;
 938         struct winbindd_response response;
 939         NSS_STATUS result;
 940         char *r_user = user;
 941
 942         if (*user == WB_AIX_ENCODED) {
 943                 r_user = decode_user(r_user);
 944                 if (!r_user) {
 945                         errno = ENOENT;
 946                         return -1;
 947                 }
 948         }
 949
 950         logit("chpass '%s' old='%s' new='%s'\n", r_user, oldpass, newpass);
 951
 952         *message = NULL;
 953
 954         /* Send off request */
 955         ZERO_STRUCT(request);
 956         ZERO_STRUCT(response);
 957
 958         STRCPY_RET(request.data.chauthtok.user, r_user);
 959         STRCPY_RET(request.data.chauthtok.oldpass, oldpass);
 960         STRCPY_RET(request.data.chauthtok.newpass, newpass);
 961
 962         if (*user == WB_AIX_ENCODED) {
 963                 free(r_user);
 964         }
 965
 966         result = winbindd_request_response(NULL, WINBINDD_PAM_CHAUTHTOK,
 967                                            &request, &response);
 968
 969         winbindd_free_response(&response);
 970
 971         if (result == NSS_STATUS_SUCCESS) {
 972                 errno = 0;
 973                 return 0;
 974         }
 975
 976         errno = EINVAL;
 977         return -1;
 978 }
 979
 980 /*
 981   don't do any password strength testing for now
 982 */
 983 static int wb_aix_passwdrestrictions(char *user, char *newpass, char *oldpass,
 984                                      char **message)
 985 {
 986         logit("passwdresrictions called for '%s'\n", user);
 987         return 0;
 988 }
 989
 990
 991 static int wb_aix_passwdexpired(char *user, char **message)
 992 {
 993         logit("passwdexpired '%s'\n", user);
 994         /* we should check the account bits here */
 995         return 0;
 996 }
 997
 998
 999 /*
1000   we can't return a crypt() password
1001 */
1002 static char *wb_aix_getpasswd(char *user)
1003 {
1004         logit("getpasswd '%s'\n", user);
1005         errno = ENOSYS;
1006         return NULL;
1007 }
1008
1009 /*
1010   this is called to update things like the last login time. We don't
1011   currently pass this onto the DC
1012 */
1013 static int wb_aix_putentry(char *key, char *table, char *attributes[],
1014                            attrval_t values[], int size)
1015 {
1016         logit("putentry key='%s' table='%s' attrib='%s'\n",
1017               key, table, size>=1?attributes[0]:"<null>");
1018         errno = ENOSYS;
1019         return -1;
1020 }
1021
1022 static int wb_aix_commit(char *key, char *table)
1023 {
1024         logit("commit key='%s' table='%s'\n");
1025         errno = ENOSYS;
1026         return -1;
1027 }
1028
1029 static int wb_aix_getgrusers(char *group, void *result, int type, int *size)
1030 {
1031         logit("getgrusers group='%s'\n", group);
1032         errno = ENOSYS;
1033         return -1;
1034 }
1035
1036
1037 #define DECL_METHOD(x) \
1038 int method_ ## x(void) \
1039 { \
1040         logit("UNIMPLEMENTED METHOD '%s'\n", #x); \
1041         errno = EINVAL; \
1042         return -1; \
1043 }
1044
1045 #if LOG_UNIMPLEMENTED_CALLS
1046 DECL_METHOD(delgroup);
1047 DECL_METHOD(deluser);
1048 DECL_METHOD(newgroup);
1049 DECL_METHOD(newuser);
1050 DECL_METHOD(putgrent);
1051 DECL_METHOD(putgrusers);
1052 DECL_METHOD(putpwent);
1053 DECL_METHOD(lock);
1054 DECL_METHOD(unlock);
1055 DECL_METHOD(getcred);
1056 DECL_METHOD(setcred);
1057 DECL_METHOD(deletecred);
1058 #endif
1059
1060 int wb_aix_init(struct secmethod_table *methods)
1061 {
1062         ZERO_STRUCTP(methods);
1063
1064 #ifdef HAVE_STRUCT_SECMETHOD_TABLE_METHOD_VERSION
1065         methods->method_version = SECMETHOD_VERSION_520;
1066 #endif
1067
1068         methods->method_getgrgid           = wb_aix_getgrgid;
1069         methods->method_getgrnam           = wb_aix_getgrnam;
1070         methods->method_getgrset           = wb_aix_getgrset;
1071         methods->method_getpwnam           = wb_aix_getpwnam;
1072         methods->method_getpwuid           = wb_aix_getpwuid;
1073         methods->method_getentry           = wb_aix_getentry;
1074         methods->method_open               = wb_aix_open;
1075         methods->method_close              = wb_aix_close;
1076         methods->method_normalize          = wb_aix_normalize;
1077         methods->method_passwdexpired      = wb_aix_passwdexpired;
1078         methods->method_putentry           = wb_aix_putentry;
1079         methods->method_getpasswd          = wb_aix_getpasswd;
1080         methods->method_authenticate       = wb_aix_authenticate;
1081         methods->method_commit             = wb_aix_commit;
1082         methods->method_chpass             = wb_aix_chpass;
1083         methods->method_passwdrestrictions = wb_aix_passwdrestrictions;
1084         methods->method_getgracct          = wb_aix_getgracct;
1085         methods->method_getgrusers         = wb_aix_getgrusers;
1086 #ifdef HAVE_STRUCT_SECMETHOD_TABLE_METHOD_ATTRLIST
1087         methods->method_attrlist           = wb_aix_attrlist;
1088 #endif
1089
1090 #if LOG_UNIMPLEMENTED_CALLS
1091         methods->method_delgroup      = method_delgroup;
1092         methods->method_deluser       = method_deluser;
1093         methods->method_newgroup      = method_newgroup;
1094         methods->method_newuser       = method_newuser;
1095         methods->method_putgrent      = method_putgrent;
1096         methods->method_putgrusers    = method_putgrusers;
1097         methods->method_putpwent      = method_putpwent;
1098         methods->method_lock          = method_lock;
1099         methods->method_unlock        = method_unlock;
1100         methods->method_getcred       = method_getcred;
1101         methods->method_setcred       = method_setcred;
1102         methods->method_deletecred    = method_deletecred;
1103 #endif
1104
1105         return AUTH_SUCCESS;
1106 }