etc/afpd/auth.c

   1 /*
   2  * Copyright (c) 1990,1993 Regents of The University of Michigan.
   3  * All Rights Reserved.  See COPYRIGHT.
   4  */
   5
   6 #ifdef HAVE_CONFIG_H
   7 #include "config.h"
   8 #endif /* HAVE_CONFIG_H */
   9
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <errno.h>
  13 #include <unistd.h>
  14 #include <sys/types.h>
  15 #include <sys/param.h>
  16 #include <sys/stat.h>
  17 #include <netatalk/endian.h>
  18 #include <atalk/afp.h>
  19 #include <atalk/compat.h>
  20 #include <atalk/util.h>
  21 #include <limits.h>
  22 #include <string.h>
  23 #include <ctype.h>
  24 #include <time.h>
  25 #include <pwd.h>
  26 #include <grp.h>
  27
  28 #ifdef TRU64
  29 #include <netdb.h>
  30 #include <arpa/inet.h>
  31 #include <sia.h>
  32 #include <siad.h>
  33
  34 extern void afp_get_cmdline( int *ac, char ***av );
  35 #endif /* TRU64 */
  36
  37 #include <atalk/logger.h>
  38 #include <atalk/server_ipc.h>
  39 #include <atalk/uuid.h>
  40
  41 #include "globals.h"
  42 #include "auth.h"
  43 #include "uam_auth.h"
  44 #include "switch.h"
  45 #include "status.h"
  46 #include "fork.h"
  47 #include "extattrs.h"
  48 #ifdef HAVE_ACLS
  49 #include "acls.h"
  50 #endif
  51
  52 int afp_version = 11;
  53 static int afp_version_index;
  54
  55 uid_t   uuid;
  56
  57 #if defined( sun ) && !defined( __svr4__ ) || defined( ultrix )
  58
  59 int *groups;
  60 #define GROUPS_SIZE sizeof(int)
  61
  62 #else /* sun __svr4__ ultrix */
  63
  64 gid_t   *groups;
  65 #define GROUPS_SIZE sizeof(gid_t)
  66 #endif /* sun ultrix */
  67
  68 int ngroups;
  69
  70 /*
  71  * These numbers are scattered throughout the code.
  72  */
  73 static struct afp_versions  afp_versions[] = {
  74 #ifndef NO_DDP
  75     { "AFPVersion 1.1", 11 },
  76     { "AFPVersion 2.0", 20 },
  77     { "AFPVersion 2.1", 21 },
  78 #endif /* ! NO_DDP */
  79     { "AFP2.2", 22 },
  80 #ifdef AFP3x
  81     { "AFPX03", 30 },
  82     { "AFP3.1", 31 },
  83     { "AFP3.2", 32 }
  84 #endif /* AFP3x */
  85 };
  86
  87 static struct uam_mod uam_modules = {NULL, NULL, &uam_modules, &uam_modules};
  88 static struct uam_obj uam_login = {"", "", 0, {{NULL, NULL, NULL, NULL }}, &uam_login,
  89                                    &uam_login};
  90 static struct uam_obj uam_changepw = {"", "", 0, {{NULL, NULL, NULL, NULL}}, &uam_changepw,
  91                                       &uam_changepw};
  92
  93 static struct uam_obj *afp_uam = NULL;
  94
  95
  96 void status_versions( char *data, const ASP asp, const DSI *dsi)
  97 {
  98     char                *start = data;
  99     u_int16_t           status;
 100     int         len, num, i, count = 0;
 101
 102     memcpy(&status, start + AFPSTATUS_VERSOFF, sizeof(status));
 103     num = sizeof( afp_versions ) / sizeof( afp_versions[ 0 ] );
 104
 105     for ( i = 0; i < num; i++ ) {
 106 #ifndef NO_DDP
 107         if ( !asp && (afp_versions[ i ].av_number <= 21)) continue;
 108 #endif /* ! NO_DDP */
 109         if ( !dsi && (afp_versions[ i ].av_number >= 22)) continue;
 110         count++;
 111     }
 112     data += ntohs( status );
 113     *data++ = count;
 114
 115     for ( i = 0; i < num; i++ ) {
 116 #ifndef NO_DDP
 117         if ( !asp && (afp_versions[ i ].av_number <= 21)) continue;
 118 #endif /* ! NO_DDP */
 119         if ( !dsi && (afp_versions[ i ].av_number >= 22)) continue;
 120         len = strlen( afp_versions[ i ].av_name );
 121         *data++ = len;
 122         memcpy( data, afp_versions[ i ].av_name , len );
 123         data += len;
 124     }
 125     status = htons( data - start );
 126     memcpy(start + AFPSTATUS_UAMSOFF, &status, sizeof(status));
 127 }
 128
 129 void status_uams(char *data, const char *authlist)
 130 {
 131     char                *start = data;
 132     u_int16_t           status;
 133     struct uam_obj      *uams;
 134     int         len, num = 0;
 135
 136     memcpy(&status, start + AFPSTATUS_UAMSOFF, sizeof(status));
 137     uams = &uam_login;
 138     while ((uams = uams->uam_prev) != &uam_login) {
 139         if (strstr(authlist, uams->uam_path))
 140             num++;
 141     }
 142
 143     data += ntohs( status );
 144     *data++ = num;
 145     while ((uams = uams->uam_prev) != &uam_login) {
 146         if (strstr(authlist, uams->uam_path)) {
 147             LOG(log_info, logtype_afpd, "uam: \"%s\" available", uams->uam_name);
 148             len = strlen( uams->uam_name);
 149             *data++ = len;
 150             memcpy( data, uams->uam_name, len );
 151             data += len;
 152         }
 153     }
 154
 155     /* icon offset */
 156     status = htons(data - start);
 157     memcpy(start + AFPSTATUS_ICONOFF, &status, sizeof(status));
 158 }
 159
 160 /* handle errors by closing the connection. this is only needed
 161  * by the afp_* functions. */
 162 static int send_reply(const AFPObj *obj, const int err)
 163 {
 164     if ((err == AFP_OK) || (err == AFPERR_AUTHCONT))
 165         return err;
 166
 167     obj->reply(obj->handle, err);
 168     obj->exit(0);
 169
 170     return AFP_OK;
 171 }
 172
 173 static int afp_errpwdexpired(AFPObj *obj _U_, char *ibuf _U_, size_t ibuflen _U_,
 174                              char *rbuf _U_, size_t *rbuflen)
 175 {
 176     *rbuflen = 0;
 177     return AFPERR_PWDEXPR;
 178 }
 179
 180 static int afp_null_nolog(AFPObj *obj _U_, char *ibuf _U_, size_t ibuflen _U_,
 181                           char *rbuf _U_, size_t *rbuflen)
 182 {
 183     *rbuflen = 0;
 184     return( AFPERR_NOOP );
 185 }
 186
 187 static int set_auth_switch(int expired)
 188 {
 189     int i;
 190
 191     if (expired) {
 192         /*
 193          * BF: expired password handling
 194          * to allow the user to change his/her password we have to allow login
 195          * but every following call except for FPChangePassword will be thrown
 196          * away with an AFPERR_PWDEXPR error. (thanks to Leland Wallace from Apple
 197          * for clarifying this)
 198          */
 199
 200         for (i=0; i<=0xff; i++) {
 201             uam_afpserver_action(i, UAM_AFPSERVER_PREAUTH, afp_errpwdexpired, NULL);
 202         }
 203         uam_afpserver_action(AFP_LOGOUT, UAM_AFPSERVER_PREAUTH, afp_logout, NULL);
 204         uam_afpserver_action(AFP_CHANGEPW, UAM_AFPSERVER_PREAUTH, afp_changepw, NULL);
 205     }
 206     else {
 207         afp_switch = postauth_switch;
 208         switch (afp_version) {
 209         case 32:
 210 #ifdef HAVE_ACLS
 211             uam_afpserver_action(AFP_GETACL, UAM_AFPSERVER_POSTAUTH, afp_getacl, NULL);
 212             uam_afpserver_action(AFP_SETACL, UAM_AFPSERVER_POSTAUTH, afp_setacl, NULL);
 213             uam_afpserver_action(AFP_ACCESS, UAM_AFPSERVER_POSTAUTH, afp_access, NULL);
 214 #endif /* HAVE_ACLS */
 215             uam_afpserver_action(AFP_GETEXTATTR, UAM_AFPSERVER_POSTAUTH, afp_getextattr, NULL);
 216             uam_afpserver_action(AFP_SETEXTATTR, UAM_AFPSERVER_POSTAUTH, afp_setextattr, NULL);
 217             uam_afpserver_action(AFP_REMOVEATTR, UAM_AFPSERVER_POSTAUTH, afp_remextattr, NULL);
 218             uam_afpserver_action(AFP_LISTEXTATTR, UAM_AFPSERVER_POSTAUTH, afp_listextattr, NULL);
 219         case 31:
 220             uam_afpserver_action(AFP_SYNCDIR, UAM_AFPSERVER_POSTAUTH, afp_syncdir, NULL);
 221             uam_afpserver_action(AFP_SYNCFORK, UAM_AFPSERVER_POSTAUTH, afp_syncfork, NULL);
 222             uam_afpserver_action(AFP_SPOTLIGHT_PRIVATE, UAM_AFPSERVER_POSTAUTH, afp_null_nolog, NULL);
 223             uam_afpserver_action(AFP_ENUMERATE_EXT2, UAM_AFPSERVER_POSTAUTH, afp_enumerate_ext2, NULL);
 224         case 30:
 225             uam_afpserver_action(AFP_ENUMERATE_EXT, UAM_AFPSERVER_POSTAUTH, afp_enumerate_ext, NULL);
 226             uam_afpserver_action(AFP_BYTELOCK_EXT,  UAM_AFPSERVER_POSTAUTH, afp_bytelock_ext, NULL);
 227             /* catsearch_ext uses the same packet as catsearch FIXME double check this, it wasn't true for enue
 228                enumerate_ext */
 229             uam_afpserver_action(AFP_CATSEARCH_EXT, UAM_AFPSERVER_POSTAUTH, afp_catsearch_ext, NULL);
 230             uam_afpserver_action(AFP_GETSESSTOKEN,  UAM_AFPSERVER_POSTAUTH, afp_getsession, NULL);
 231             uam_afpserver_action(AFP_READ_EXT,      UAM_AFPSERVER_POSTAUTH, afp_read_ext, NULL);
 232             uam_afpserver_action(AFP_WRITE_EXT,     UAM_AFPSERVER_POSTAUTH, afp_write_ext, NULL);
 233             uam_afpserver_action(AFP_DISCTOLDSESS,  UAM_AFPSERVER_POSTAUTH, afp_disconnect, NULL);
 234
 235         case 22:
 236             /*
 237              * If first connection to a server is done in classic AFP2.2 version is used
 238              * but OSX uses AFP3.x FPzzz command !
 239              */
 240             uam_afpserver_action(AFP_ZZZ,  UAM_AFPSERVER_POSTAUTH, afp_zzz, NULL);
 241             break;
 242         }
 243     }
 244
 245     return AFP_OK;
 246 }
 247
 248 static int login(AFPObj *obj, struct passwd *pwd, void (*logout)(void), int expired)
 249 {
 250 #ifdef ADMIN_GRP
 251     int admin = 0;
 252 #endif /* ADMIN_GRP */
 253
 254 #if 0
 255     set_processname("afpd");
 256 #endif
 257
 258     if ( pwd->pw_uid == 0 ) {   /* don't allow root login */
 259         LOG(log_error, logtype_afpd, "login: root login denied!" );
 260         return AFPERR_NOTAUTH;
 261     }
 262
 263     LOG(log_note, logtype_afpd, "%s Login by %s",
 264         afp_versions[afp_version_index].av_name, pwd->pw_name);
 265
 266 #ifndef NO_DDP
 267     if (obj->proto == AFPPROTO_ASP) {
 268         ASP asp = obj->handle;
 269         int addr_net = ntohs( asp->asp_sat.sat_addr.s_net );
 270         int addr_node  = asp->asp_sat.sat_addr.s_node;
 271
 272         if (obj->options.authprintdir) {
 273             if(addr_net && addr_node) { /* Do we have a valid Appletalk address? */
 274                 char nodename[256];
 275                 FILE *fp;
 276                 int mypid = getpid();
 277                 struct stat stat_buf;
 278
 279                 sprintf(nodename, "%s/net%d.%dnode%d", obj->options.authprintdir,
 280                         addr_net / 256, addr_net % 256, addr_node);
 281                 LOG(log_info, logtype_afpd, "registering %s (uid %d) on %u.%u as %s",
 282                     pwd->pw_name, pwd->pw_uid, addr_net, addr_node, nodename);
 283
 284                 if (stat(nodename, &stat_buf) == 0) { /* file exists */
 285                     if (S_ISREG(stat_buf.st_mode)) { /* normal file */
 286                         unlink(nodename);
 287                         fp = fopen(nodename, "w");
 288                         fprintf(fp, "%s:%d\n", pwd->pw_name, mypid);
 289                         fclose(fp);
 290                         chown( nodename, pwd->pw_uid, -1 );
 291                     } else { /* somebody is messing with us */
 292                         LOG(log_error, logtype_afpd, "print authfile %s is not a normal file, it will not be modified", nodename );
 293                     }
 294                 } else { /* file 'nodename' does not exist */
 295                     fp = fopen(nodename, "w");
 296                     fprintf(fp, "%s:%d\n", pwd->pw_name, mypid);
 297                     fclose(fp);
 298                     chown( nodename, pwd->pw_uid, -1 );
 299                 }
 300             } /* if (addr_net && addr_node ) */
 301         } /* if (options->authprintdir) */
 302     } /* if (obj->proto == AFPPROTO_ASP) */
 303 #endif
 304
 305     if (initgroups( pwd->pw_name, pwd->pw_gid ) < 0) {
 306 #ifdef RUN_AS_USER
 307         LOG(log_info, logtype_afpd, "running with uid %d", geteuid());
 308 #else /* RUN_AS_USER */
 309         LOG(log_error, logtype_afpd, "login: %s", strerror(errno));
 310         return AFPERR_BADUAM;
 311 #endif /* RUN_AS_USER */
 312
 313     }
 314
 315     /* Basically if the user is in the admin group, we stay root */
 316
 317     if (( ngroups = getgroups( 0, NULL )) < 0 ) {
 318         LOG(log_error, logtype_afpd, "login: %s getgroups: %s", pwd->pw_name, strerror(errno) );
 319         return AFPERR_BADUAM;
 320     }
 321
 322     if ( NULL == (groups = calloc(ngroups, GROUPS_SIZE)) ) {
 323         LOG(log_error, logtype_afpd, "login: %s calloc: %d", ngroups);
 324         return AFPERR_BADUAM;
 325     }
 326
 327     if (( ngroups = getgroups( ngroups, groups )) < 0 ) {
 328         LOG(log_error, logtype_afpd, "login: %s getgroups: %s", pwd->pw_name, strerror(errno) );
 329         return AFPERR_BADUAM;
 330     }
 331
 332 #ifdef ADMIN_GRP
 333     LOG(log_debug, logtype_afpd, "obj->options.admingid == %d", obj->options.admingid);
 334
 335     if (obj->options.admingid != 0) {
 336         int i;
 337         for (i = 0; i < ngroups; i++) {
 338             if (groups[i] == obj->options.admingid) admin = 1;
 339         }
 340     }
 341     if (admin) {
 342         ad_setfuid(0);
 343         LOG(log_info, logtype_afpd, "admin login -- %s", pwd->pw_name );
 344     }
 345     if (!admin)
 346 #endif /* ADMIN_GRP */
 347 #ifdef TRU64
 348     {
 349         struct DSI *dsi = obj->handle;
 350         struct hostent *hp;
 351         char *clientname;
 352         int argc;
 353         char **argv;
 354         char hostname[256];
 355
 356         afp_get_cmdline( &argc, &argv );
 357
 358         hp = gethostbyaddr( (char *) &dsi->client.sin_addr,
 359                             sizeof( struct in_addr ),
 360                             dsi->client.sin_family );
 361
 362         if( hp )
 363             clientname = hp->h_name;
 364         else
 365             clientname = inet_ntoa( dsi->client.sin_addr );
 366
 367         sprintf( hostname, "%s@%s", pwd->pw_name, clientname );
 368
 369         if( sia_become_user( NULL, argc, argv, hostname, pwd->pw_name,
 370                              NULL, FALSE, NULL, NULL,
 371                              SIA_BEU_REALLOGIN ) != SIASUCCESS )
 372             return AFPERR_BADUAM;
 373
 374         LOG(log_info, logtype_afpd, "session from %s (%s)", hostname,
 375             inet_ntoa( dsi->client.sin_addr ) );
 376
 377         if (setegid( pwd->pw_gid ) < 0 || seteuid( pwd->pw_uid ) < 0) {
 378             LOG(log_error, logtype_afpd, "login: %s %s", pwd->pw_name, strerror(errno) );
 379             return AFPERR_BADUAM;
 380         }
 381     }
 382 #else /* TRU64 */
 383     if (setegid( pwd->pw_gid ) < 0 || seteuid( pwd->pw_uid ) < 0) {
 384         LOG(log_error, logtype_afpd, "login: %s %s", pwd->pw_name, strerror(errno) );
 385         return AFPERR_BADUAM;
 386     }
 387 #endif /* TRU64 */
 388
 389     if (ngroups > 0) {
 390         #define GROUPSTR_BUFSIZE 1024
 391         char groupsstr[GROUPSTR_BUFSIZE];
 392         char *s = groupsstr;
 393         int j = GROUPSTR_BUFSIZE;
 394
 395         int n = snprintf(groupsstr, GROUPSTR_BUFSIZE, "%u", groups[0]);
 396         j -= n;
 397         s += n;
 398
 399         for (int i = 1; i < ngroups; i++) {
 400             n = snprintf(s, j, ", %u", groups[i]);
 401             if (n == j) {
 402                 /* Buffer full */
 403                 LOG(log_debug, logtype_afpd, "login: group string buffer overflow");
 404                 break;
 405             }
 406             j -= n;
 407             s += n;
 408         }
 409         LOG(log_debug, logtype_afpd, "login: %u supplementary groups: %s", ngroups, groupsstr);
 410     }
 411
 412     /* There's probably a better way to do this, but for now, we just play root */
 413 #ifdef ADMIN_GRP
 414     if (admin)
 415         uuid = 0;
 416     else
 417 #endif /* ADMIN_GRP */
 418         uuid = pwd->pw_uid;
 419
 420     set_auth_switch(expired);
 421     /* save our euid, we need it for preexec_close */
 422     obj->uid = geteuid();
 423     obj->logout = logout;
 424
 425 #ifdef FORCE_UIDGID
 426     obj->force_uid = 1;
 427     save_uidgid ( &obj->uidgid );
 428 #endif
 429
 430     return( AFP_OK );
 431 }
 432
 433 /* ---------------------- */
 434 int afp_zzz ( /* Function 122 */
 435     AFPObj       *obj,
 436     char         *ibuf _U_, size_t ibuflen _U_,
 437     char *rbuf, size_t *rbuflen)
 438 {
 439     u_int32_t   retdata;
 440
 441     *rbuflen = 0;
 442
 443     retdata = obj->options.sleep /120;
 444     if (!retdata) {
 445         retdata = 1;
 446     }
 447     *rbuflen = sizeof(retdata);
 448     retdata = htonl(retdata);
 449     memcpy(rbuf, &retdata, sizeof(retdata));
 450     if (obj->sleep)
 451         obj->sleep();
 452     rbuf += sizeof(retdata);
 453     return AFP_OK;
 454 }
 455
 456 /* ---------------------- */
 457 static int create_session_token(AFPObj *obj)
 458 {
 459     pid_t pid;
 460
 461     /* use 8 bytes for token as OSX, don't know if it helps */
 462     if ( sizeof(pid_t) > SESSIONTOKEN_LEN) {
 463         LOG(log_error, logtype_afpd, "sizeof(pid_t) > %u", SESSIONTOKEN_LEN );
 464         return AFPERR_MISC;
 465     }
 466
 467     if ( NULL == (obj->sinfo.sessiontoken = malloc(SESSIONTOKEN_LEN)) )
 468         return AFPERR_MISC;
 469
 470     memset(obj->sinfo.sessiontoken, 0, SESSIONTOKEN_LEN);
 471     obj->sinfo.sessiontoken_len = SESSIONTOKEN_LEN;
 472     pid = getpid();
 473     memcpy(obj->sinfo.sessiontoken, &pid, sizeof(pid_t));
 474
 475     return 0;
 476 }
 477
 478 static int create_session_key(AFPObj *obj)
 479 {
 480     /* create session key */
 481     if (obj->sinfo.sessionkey == NULL) {
 482         if (NULL == (obj->sinfo.sessionkey = malloc(SESSIONKEY_LEN)) )
 483             return AFPERR_MISC;
 484         uam_random_string(obj, obj->sinfo.sessionkey, SESSIONKEY_LEN);
 485         obj->sinfo.sessionkey_len = SESSIONKEY_LEN;
 486     }
 487     return AFP_OK;
 488 }
 489
 490
 491 /* ---------------------- */
 492 int afp_getsession(
 493     AFPObj *obj,
 494     char   *ibuf, size_t ibuflen,
 495     char   *rbuf, size_t *rbuflen)
 496 {
 497     u_int16_t           type;
 498     u_int32_t           idlen = 0;
 499     u_int32_t       boottime;
 500     u_int32_t           tklen, tp;
 501     char                *token;
 502     char                *p;
 503
 504     *rbuflen = 0;
 505     tklen = 0;
 506
 507     if (ibuflen < 2 + sizeof(type)) {
 508         return AFPERR_PARAM;
 509     }
 510
 511     ibuf += 2;
 512     ibuflen -= 2;
 513
 514     memcpy(&type, ibuf, sizeof(type));
 515     type = ntohs(type);
 516     ibuf += sizeof(type);
 517     ibuflen -= sizeof(type);
 518
 519     if ( obj->sinfo.sessiontoken == NULL ) {
 520         if ( create_session_token( obj ) )
 521             return AFPERR_MISC;
 522     }
 523
 524     /*
 525      *
 526      */
 527     switch (type) {
 528     case 0: /* old version ?*/
 529         tklen = obj->sinfo.sessiontoken_len;
 530         token = obj->sinfo.sessiontoken;
 531         break;
 532     case 1: /* disconnect */
 533     case 2: /* reconnect update id */
 534         if (ibuflen >= sizeof(idlen)) {
 535             memcpy(&idlen, ibuf, sizeof(idlen));
 536             idlen = ntohl(idlen);
 537             ibuf += sizeof(idlen);
 538             ibuflen -= sizeof(idlen);
 539             if (ibuflen < idlen) {
 540                 return AFPERR_PARAM;
 541             }
 542             /* memcpy (id, ibuf, idlen) */
 543             tklen = obj->sinfo.sessiontoken_len;
 544             token = obj->sinfo.sessiontoken;
 545         }
 546         break;
 547     case 3: /* Jaguar */
 548     case 4:
 549         if (ibuflen >= 8 ) {
 550             p = ibuf;
 551             memcpy( &idlen, ibuf, sizeof(idlen));
 552             idlen = ntohl(idlen);
 553             ibuf += sizeof(idlen);
 554             ibuflen -= sizeof(idlen);
 555             ibuf += sizeof(boottime);
 556             ibuflen -= sizeof(boottime);
 557             if (ibuflen < idlen || idlen > (90-10)) {
 558                 return AFPERR_PARAM;
 559             }
 560             server_ipc_write(IPC_GETSESSION, idlen+8, p );
 561             tklen = obj->sinfo.sessiontoken_len;
 562             token = obj->sinfo.sessiontoken;
 563         }
 564         break;
 565     case 8: /* Panther Kerberos Token */
 566         tklen = obj->sinfo.cryptedkey_len;
 567         token = obj->sinfo.cryptedkey;
 568         break;
 569     default:
 570         return AFPERR_NOOP;
 571         break;
 572
 573     }
 574
 575     if (tklen == 0)
 576         return AFPERR_MISC;
 577
 578     tp = htonl(tklen);
 579     memcpy(rbuf, &tp, sizeof(tklen));
 580     rbuf += sizeof(tklen);
 581     *rbuflen += sizeof(tklen);
 582
 583     memcpy(rbuf, token, tklen);
 584     *rbuflen += tklen;
 585
 586     return AFP_OK;
 587 }
 588
 589 /* ---------------------- */
 590 int afp_disconnect(AFPObj *obj _U_, char *ibuf, size_t ibuflen _U_, char *rbuf _U_, size_t *rbuflen)
 591 {
 592     u_int16_t           type;
 593
 594     u_int32_t           tklen;
 595     pid_t               token;
 596     int                 i;
 597
 598     *rbuflen = 0;
 599     ibuf += 2;
 600
 601 #if 0
 602     /* check for guest user */
 603     if ( 0 == (strcasecmp(obj->username, obj->options.guest)) ) {
 604         return AFPERR_MISC;
 605     }
 606 #endif
 607
 608     memcpy(&type, ibuf, sizeof(type));
 609     type = ntohs(type);
 610     ibuf += sizeof(type);
 611
 612     memcpy(&tklen, ibuf, sizeof(tklen));
 613     tklen = ntohl(tklen);
 614     ibuf += sizeof(tklen);
 615
 616     if ( sizeof(pid_t) > SESSIONTOKEN_LEN) {
 617         LOG(log_error, logtype_afpd, "sizeof(pid_t) > %u", SESSIONTOKEN_LEN );
 618         return AFPERR_MISC;
 619     }
 620     if (tklen != SESSIONTOKEN_LEN) {
 621         return AFPERR_MISC;
 622     }
 623     tklen = sizeof(pid_t);
 624     memcpy(&token, ibuf, tklen);
 625
 626     /* our stuff is pid + zero pad */
 627     ibuf += tklen;
 628     for (i = tklen; i < SESSIONTOKEN_LEN; i++, ibuf++) {
 629         if (*ibuf != 0) {
 630             return AFPERR_MISC;
 631         }
 632     }
 633
 634     /* killed old session, not easy */
 635     server_ipc_write(IPC_KILLTOKEN, tklen, &token);
 636     sleep(1);
 637
 638     return AFPERR_SESSCLOS;   /* was AFP_OK */
 639 }
 640
 641 /* ---------------------- */
 642 static int get_version(AFPObj *obj, char *ibuf, size_t ibuflen, size_t len)
 643 {
 644     int num,i;
 645
 646     if (!len || len > ibuflen)
 647         return AFPERR_BADVERS;
 648
 649     num = sizeof( afp_versions ) / sizeof( afp_versions[ 0 ]);
 650     for ( i = 0; i < num; i++ ) {
 651         if ( strncmp( ibuf, afp_versions[ i ].av_name , len ) == 0 ) {
 652             afp_version = afp_versions[ i ].av_number;
 653             afp_version_index = i;
 654             break;
 655         }
 656     }
 657     if ( i == num )                 /* An inappropo version */
 658         return AFPERR_BADVERS ;
 659
 660     if (afp_version >= 30 && obj->proto != AFPPROTO_DSI)
 661         return AFPERR_BADVERS ;
 662
 663     /* FIXME Hack */
 664     if (afp_version >= 30 && sizeof(off_t) != 8) {
 665         LOG(log_error, logtype_afpd, "get_version: no LARGE_FILE support recompile!" );
 666         return AFPERR_BADVERS ;
 667     }
 668
 669     return 0;
 670 }
 671
 672 /* ---------------------- */
 673 int afp_login(AFPObj *obj, char *ibuf, size_t ibuflen, char *rbuf, size_t *rbuflen)
 674 {
 675     struct passwd *pwd = NULL;
 676     size_t len;
 677     int     i;
 678
 679     *rbuflen = 0;
 680
 681     if ( nologin & 1)
 682         return send_reply(obj, AFPERR_SHUTDOWN );
 683
 684     if (ibuflen < 2)
 685         return send_reply(obj, AFPERR_BADVERS );
 686
 687     ibuf++;
 688     len = (unsigned char) *ibuf++;
 689     ibuflen -= 2;
 690
 691     i = get_version(obj, ibuf, ibuflen, len);
 692     if (i)
 693         return send_reply(obj, i );
 694
 695     if (ibuflen <= len)
 696         return send_reply(obj, AFPERR_BADUAM);
 697
 698     ibuf += len;
 699     ibuflen -= len;
 700
 701     len = (unsigned char) *ibuf++;
 702     ibuflen--;
 703
 704     if (!len || len > ibuflen)
 705         return send_reply(obj, AFPERR_BADUAM);
 706
 707     if (NULL == (afp_uam = auth_uamfind(UAM_SERVER_LOGIN, ibuf, len)) )
 708         return send_reply(obj, AFPERR_BADUAM);
 709     ibuf += len;
 710     ibuflen -= len;
 711
 712     if (AFP_OK != (i = create_session_key(obj)) )
 713         return send_reply(obj, i);
 714
 715     i = afp_uam->u.uam_login.login(obj, &pwd, ibuf, ibuflen, rbuf, rbuflen);
 716
 717     if (!pwd || ( i != AFP_OK && i != AFPERR_PWDEXPR))
 718         return send_reply(obj, i);
 719
 720     return send_reply(obj, login(obj, pwd, afp_uam->u.uam_login.logout, ((i==AFPERR_PWDEXPR)?1:0)));
 721 }
 722
 723 /* ---------------------- */
 724 int afp_login_ext(AFPObj *obj, char *ibuf, size_t ibuflen, char *rbuf, size_t *rbuflen)
 725 {
 726     struct passwd *pwd = NULL;
 727     size_t  len;
 728     int     i;
 729     char        type;
 730     u_int16_t   len16;
 731     char        *username;
 732
 733     *rbuflen = 0;
 734
 735     if ( nologin & 1)
 736         return send_reply(obj, AFPERR_SHUTDOWN );
 737
 738     if (ibuflen < 5)
 739         return send_reply(obj, AFPERR_BADVERS );
 740
 741     ibuf++;
 742     ibuf++;     /* pad  */
 743     ibuf +=2;   /* flag */
 744
 745     len = (unsigned char) *ibuf;
 746     ibuf++;
 747     ibuflen -= 5;
 748
 749     i = get_version(obj, ibuf, ibuflen, len);
 750     if (i)
 751         return send_reply(obj, i );
 752
 753     if (ibuflen <= len)
 754         return send_reply(obj, AFPERR_BADUAM);
 755
 756     ibuf    += len;
 757     ibuflen -= len;
 758
 759     len = (unsigned char) *ibuf;
 760     ibuf++;
 761     ibuflen--;
 762
 763     if (!len || len > ibuflen)
 764         return send_reply(obj, AFPERR_BADUAM);
 765
 766     if ((afp_uam = auth_uamfind(UAM_SERVER_LOGIN, ibuf, len)) == NULL)
 767         return send_reply(obj, AFPERR_BADUAM);
 768     ibuf    += len;
 769     ibuflen -= len;
 770
 771     if (!afp_uam->u.uam_login.login_ext) {
 772         LOG(log_error, logtype_afpd, "login_ext: uam %s not AFP 3 ready!", afp_uam->uam_name );
 773         return send_reply(obj, AFPERR_BADUAM);
 774     }
 775     /* user name */
 776     if (ibuflen <= 1 +sizeof(len16))
 777         return send_reply(obj, AFPERR_PARAM);
 778     type = *ibuf;
 779     username = ibuf;
 780     ibuf++;
 781     ibuflen--;
 782     if (type != 3)
 783         return send_reply(obj, AFPERR_PARAM);
 784
 785     memcpy(&len16, ibuf, sizeof(len16));
 786     ibuf += sizeof(len16);
 787     ibuflen -= sizeof(len16);
 788     len = ntohs(len16);
 789     if (len > ibuflen)
 790         return send_reply(obj, AFPERR_PARAM);
 791     ibuf += len;
 792     ibuflen -= len;
 793
 794     /* directory service name */
 795     if (!ibuflen)
 796         return send_reply(obj, AFPERR_PARAM);
 797     type = *ibuf;
 798     ibuf++;
 799     ibuflen--;
 800
 801     switch(type) {
 802     case 1:
 803     case 2:
 804         if (!ibuflen)
 805             return send_reply(obj, AFPERR_PARAM);
 806         len = (unsigned char) *ibuf;
 807         ibuf++;
 808         ibuflen--;
 809         break;
 810     case 3:
 811         /* With "No User Authen" it is equal */
 812         if (ibuflen < sizeof(len16))
 813             return send_reply(obj, AFPERR_PARAM);
 814         memcpy(&len16, ibuf, sizeof(len16));
 815         ibuf += sizeof(len16);
 816         ibuflen -= sizeof(len16);
 817         len = ntohs(len16);
 818         break;
 819     default:
 820         return send_reply(obj, AFPERR_PARAM);
 821     }
 822 #if 0
 823     if (len != 0) {
 824         LOG(log_error, logtype_afpd, "login_ext: directory service path not null!" );
 825         return send_reply(obj, AFPERR_PARAM);
 826     }
 827 #endif
 828     ibuf += len;
 829     ibuflen -= len;
 830
 831     /* Pad */
 832     if (ibuflen && ((unsigned long) ibuf & 1)) { /* pad character */
 833         ibuf++;
 834         ibuflen--;
 835     }
 836
 837     if (AFP_OK != (i = create_session_key(obj)) ) {
 838         return send_reply(obj, i);
 839     }
 840
 841     /* FIXME user name are in UTF8 */
 842     i = afp_uam->u.uam_login.login_ext(obj, username, &pwd, ibuf, ibuflen, rbuf, rbuflen);
 843
 844     if (!pwd || ( i != AFP_OK && i != AFPERR_PWDEXPR))
 845         return send_reply(obj, i);
 846
 847     return send_reply(obj, login(obj, pwd, afp_uam->u.uam_login.logout, ((i==AFPERR_PWDEXPR)?1:0)));
 848 }
 849
 850 /* ---------------------- */
 851 int afp_logincont(AFPObj *obj, char *ibuf, size_t ibuflen, char *rbuf, size_t *rbuflen)
 852 {
 853     struct passwd *pwd = NULL;
 854     int err;
 855
 856     if ( afp_uam == NULL || afp_uam->u.uam_login.logincont == NULL || ibuflen < 2 ) {
 857         *rbuflen = 0;
 858         return send_reply(obj, AFPERR_NOTAUTH );
 859     }
 860
 861     ibuf += 2; ibuflen -= 2;
 862     err = afp_uam->u.uam_login.logincont(obj, &pwd, ibuf, ibuflen,
 863                                          rbuf, rbuflen);
 864     if (!pwd || ( err != AFP_OK && err != AFPERR_PWDEXPR))
 865         return send_reply(obj, err);
 866
 867     return send_reply(obj, login(obj, pwd, afp_uam->u.uam_login.logout, ((err==AFPERR_PWDEXPR)?1:0)));
 868 }
 869
 870
 871 int afp_logout(AFPObj *obj, char *ibuf _U_, size_t ibuflen  _U_, char *rbuf  _U_, size_t *rbuflen  _U_)
 872 {
 873     LOG(log_note, logtype_afpd, "AFP logout by %s", obj->username);
 874     close_all_vol();
 875     obj->exit(0);
 876     return AFP_OK;
 877 }
 878
 879
 880
 881 /* change password  --
 882  * NOTE: an FPLogin must already have completed successfully for this
 883  *       to work. this also does a little pre-processing before it hands
 884  *       it off to the uam.
 885  */
 886 int afp_changepw(AFPObj *obj, char *ibuf, size_t ibuflen, char *rbuf, size_t *rbuflen)
 887 {
 888     char username[MACFILELEN + 1], *start = ibuf;
 889     struct uam_obj *uam;
 890     struct passwd *pwd;
 891     size_t len;
 892     int    ret;
 893
 894     *rbuflen = 0;
 895     ibuf += 2;
 896
 897     /* check if password change is allowed, OS-X ignores the flag.
 898      * we shouldn't trust the client on this anyway.
 899      * not sure about the "right" error code, NOOP for now */
 900     if (!(obj->options.passwdbits & PASSWD_SET))
 901         return AFPERR_NOOP;
 902
 903     /* make sure we can deal w/ this uam */
 904     len = (unsigned char) *ibuf++;
 905     if ((uam = auth_uamfind(UAM_SERVER_CHANGEPW, ibuf, len)) == NULL)
 906         return AFPERR_BADUAM;
 907
 908     ibuf += len;
 909     if ((len + 1) & 1) /* pad byte */
 910         ibuf++;
 911
 912     if ( afp_version < 30) {
 913         len = (unsigned char) *ibuf++;
 914         if ( len > sizeof(username) - 1) {
 915             return AFPERR_PARAM;
 916         }
 917         memcpy(username, ibuf, len);
 918         username[ len ] = '\0';
 919         ibuf += len;
 920         if ((len + 1) & 1) /* pad byte */
 921             ibuf++;
 922     } else {
 923         /* AFP > 3.0 doesn't pass the username, APF 3.1 specs page 124 */
 924         if ( ibuf[0] != '\0' || ibuf[1] != '\0')
 925             return AFPERR_PARAM;
 926         ibuf += 2;
 927         len = MIN(sizeof(username), strlen(obj->username));
 928         memcpy(username, obj->username, len);
 929         username[ len ] = '\0';
 930     }
 931
 932
 933     LOG(log_info, logtype_afpd, "changing password for <%s>", username);
 934
 935     if (( pwd = uam_getname( obj, username, sizeof(username))) == NULL )
 936         return AFPERR_PARAM;
 937
 938     /* send it off to the uam. we really don't use ibuflen right now. */
 939     if (ibuflen < (size_t)(ibuf - start))
 940         return AFPERR_PARAM;
 941
 942     ibuflen -= (ibuf - start);
 943     ret = uam->u.uam_changepw(obj, username, pwd, ibuf, ibuflen,
 944                               rbuf, rbuflen);
 945     LOG(log_info, logtype_afpd, "password change %s.",
 946         (ret == AFPERR_AUTHCONT) ? "continued" :
 947         (ret ? "failed" : "succeeded"));
 948     if ( ret == AFP_OK )
 949         set_auth_switch(0);
 950
 951     return ret;
 952 }
 953
 954
 955 /* FPGetUserInfo */
 956 int afp_getuserinfo(AFPObj *obj _U_, char *ibuf, size_t ibuflen _U_, char *rbuf, size_t *rbuflen)
 957 {
 958     u_int8_t  thisuser;
 959     u_int32_t id;
 960     u_int16_t bitmap;
 961     char *bitmapp;
 962
 963     LOG(log_debug, logtype_afpd, "begin afp_getuserinfo:");
 964
 965     *rbuflen = 0;
 966     ibuf++;
 967     thisuser = *ibuf++;
 968     ibuf += sizeof(id); /* userid is not used in AFP 2.0 */
 969     memcpy(&bitmap, ibuf, sizeof(bitmap));
 970     bitmap = ntohs(bitmap);
 971
 972     /* deal with error cases. we don't have to worry about
 973      * AFPERR_ACCESS or AFPERR_NOITEM as geteuid and getegid always
 974      * succeed. */
 975     if (!thisuser)
 976         return AFPERR_PARAM;
 977     if ((bitmap & USERIBIT_ALL) != bitmap)
 978         return AFPERR_BITMAP;
 979
 980     /* remember place where we store the possibly modified bitmap later */
 981     memcpy(rbuf, ibuf, sizeof(bitmap));
 982     bitmapp = rbuf;
 983     rbuf += sizeof(bitmap);
 984     *rbuflen = sizeof(bitmap);
 985
 986     /* copy the user/group info */
 987     if (bitmap & USERIBIT_USER) {
 988         id = htonl(geteuid());
 989         memcpy(rbuf, &id, sizeof(id));
 990         rbuf += sizeof(id);
 991         *rbuflen += sizeof(id);
 992     }
 993
 994     if (bitmap & USERIBIT_GROUP) {
 995         id = htonl(getegid());
 996         memcpy(rbuf, &id, sizeof(id));
 997         rbuf += sizeof(id);
 998         *rbuflen += sizeof(id);
 999     }
1000
1001     if (bitmap & USERIBIT_UUID) {
1002         if ( ! (obj->options.flags & OPTION_UUID)) {
1003             bitmap &= ~USERIBIT_UUID;
1004             bitmap = htons(bitmap);
1005             memcpy(bitmapp, &bitmap, sizeof(bitmap));
1006         } else {
1007             LOG(log_debug, logtype_afpd, "afp_getuserinfo: get UUID for \'%s\'", obj->username);
1008             int ret;
1009             atalk_uuid_t uuid;
1010             ret = getuuidfromname( obj->username, UUID_USER, uuid);
1011             if (ret != 0) {
1012                 LOG(log_info, logtype_afpd, "afp_getuserinfo: error getting UUID !");
1013                 return AFPERR_NOITEM;
1014             }
1015             LOG(log_debug, logtype_afpd, "afp_getuserinfo: got UUID: %s", uuid_bin2string(uuid));
1016
1017             memcpy(rbuf, uuid, UUID_BINSIZE);
1018             rbuf += UUID_BINSIZE;
1019             *rbuflen += UUID_BINSIZE;
1020         }
1021     }
1022
1023     LOG(log_debug, logtype_afpd, "END afp_getuserinfo:");
1024     return AFP_OK;
1025 }
1026
1027 #define UAM_LIST(type) (((type) == UAM_SERVER_LOGIN || (type) == UAM_SERVER_LOGIN_EXT) ? &uam_login : \
1028                         (((type) == UAM_SERVER_CHANGEPW) ?              \
1029                          &uam_changepw : NULL))
1030
1031 /* just do a linked list search. this could be sped up with a hashed
1032  * list, but i doubt anyone's going to have enough uams to matter. */
1033 struct uam_obj *auth_uamfind(const int type, const char *name,
1034                              const int len)
1035 {
1036     struct uam_obj *prev, *start;
1037
1038     if (!name || !(start = UAM_LIST(type)))
1039         return NULL;
1040
1041     prev = start;
1042     while ((prev = prev->uam_prev) != start)
1043         if (strndiacasecmp(prev->uam_name, name, len) == 0)
1044             return prev;
1045
1046     return NULL;
1047 }
1048
1049 int auth_register(const int type, struct uam_obj *uam)
1050 {
1051     struct uam_obj *start;
1052
1053     if (!uam || !uam->uam_name || (*uam->uam_name == '\0'))
1054         return -1;
1055
1056     if (!(start = UAM_LIST(type)))
1057         return 1; /* we don't know what to do with it, caller must free it */
1058
1059     uam_attach(start, uam);
1060     return 0;
1061 }
1062
1063 /* load all of the modules */
1064 int auth_load(const char *path, const char *list)
1065 {
1066     char name[MAXPATHLEN + 1], buf[MAXPATHLEN + 1], *p;
1067     struct uam_mod *mod;
1068     struct stat st;
1069     size_t len;
1070
1071     if (!path || !*path || !list || (len = strlen(path)) > sizeof(name) - 2)
1072         return -1;
1073
1074     strlcpy(buf, list, sizeof(buf));
1075     if ((p = strtok(buf, ",")) == NULL)
1076         return -1;
1077
1078     strcpy(name, path);
1079     if (name[len - 1] != '/') {
1080         strcat(name, "/");
1081         len++;
1082     }
1083
1084     while (p) {
1085         strlcpy(name + len, p, sizeof(name) - len);
1086         LOG(log_debug, logtype_afpd, "uam: loading (%s)", name);
1087         /*
1088           if ((stat(name, &st) == 0) && (mod = uam_load(name, p))) {
1089         */
1090         if (stat(name, &st) == 0) {
1091             if ((mod = uam_load(name, p))) {
1092                 uam_attach(&uam_modules, mod);
1093                 LOG(log_debug, logtype_afpd, "uam: %s loaded", p);
1094             } else {
1095                 LOG(log_error, logtype_afpd, "uam: %s load failure",p);
1096             }
1097         } else {
1098             LOG(log_info, logtype_afpd, "uam: uam not found (status=%d)", stat(name, &st));
1099         }
1100         p = strtok(NULL, ",");
1101     }
1102
1103     return 0;
1104 }
1105
1106 /* get rid of all of the uams */
1107 void auth_unload(void)
1108 {
1109     struct uam_mod *mod, *prev, *start = &uam_modules;
1110
1111     prev = start->uam_prev;
1112     while ((mod = prev) != start) {
1113         prev = prev->uam_prev;
1114         uam_detach(mod);
1115         uam_unload(mod);
1116     }
1117 }