etc/afpd/unix.c

   1 /*
   2  * $Id: unix.c,v 1.36 2002-08-29 18:57:26 didg Exp $
   3  *
   4  * Copyright (c) 1990,1993 Regents of The University of Michigan.
   5  * All Rights Reserved.  See COPYRIGHT.
   6  */
   7
   8 #ifdef HAVE_CONFIG_H
   9 #include "config.h"
  10 #endif /* HAVE_CONFIG_H */
  11
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <unistd.h>
  15 #include <errno.h>
  16 #include <sys/types.h>
  17 #include <sys/param.h>
  18 #include <sys/stat.h>
  19 #include <atalk/logger.h>
  20 #include <netatalk/endian.h>
  21 #include <dirent.h>
  22 #include <limits.h>
  23 #include <atalk/adouble.h>
  24 #include <atalk/afp.h>
  25
  26 /* STDC check */
  27 #if STDC_HEADERS
  28 #include <string.h>
  29 #else /* STDC_HEADERS */
  30 #ifndef HAVE_STRCHR
  31 #define strchr index
  32 #define strrchr index
  33 #endif /* HAVE_STRCHR */
  34 char *strchr (), *strrchr ();
  35 #ifndef HAVE_MEMCPY
  36 #define memcpy(d,s,n) bcopy ((s), (d), (n))
  37 #define memmove(d,s,n) bcopy ((s), (d), (n))
  38 #endif /* ! HAVE_MEMCPY */
  39 #endif /* STDC_HEADERS */
  40
  41 #ifdef HAVE_FCNTL_H
  42 #include <fcntl.h>
  43 #endif /* HAVE_FCNTL_H */
  44 #include "auth.h"
  45 #include "directory.h"
  46 #include "volume.h"
  47 #include "unix.h"
  48
  49 /*
  50  * Get the free space on a partition.
  51  */
  52 int ustatfs_getvolspace( vol, bfree, btotal, bsize )
  53 const struct vol        *vol;
  54 VolSpace    *bfree, *btotal;
  55 u_int32_t   *bsize;
  56 {
  57     VolSpace maxVolSpace = (~(VolSpace)0);
  58
  59 #ifdef ultrix
  60     struct fs_data      sfs;
  61 #else /*ultrix*/
  62     struct statfs       sfs;
  63 #endif /*ultrix*/
  64
  65
  66     if ( statfs( vol->v_path, &sfs ) < 0 ) {
  67         LOG(log_error, logtype_afpd, "ustatfs_getvolspace unable to stat %s", vol->v_path);
  68         return( AFPERR_PARAM );
  69     }
  70
  71 #ifdef ultrix
  72     *bfree = (VolSpace) sfs.fd_req.bfreen;
  73     *bsize = 1024;
  74 #else /* !ultrix */
  75     *bfree = (VolSpace) sfs.f_bavail;
  76     *bsize = sfs.f_frsize;
  77 #endif /* ultrix */
  78
  79     if ( *bfree > maxVolSpace / *bsize ) {
  80         *bfree = maxVolSpace;
  81     } else {
  82         *bfree *= *bsize;
  83     }
  84
  85 #ifdef ultrix
  86     *btotal = (VolSpace)
  87               ( sfs.fd_req.btot - ( sfs.fd_req.bfree - sfs.fd_req.bfreen ));
  88 #else /* !ultrix */
  89     *btotal = (VolSpace)
  90               ( sfs.f_blocks - ( sfs.f_bfree - sfs.f_bavail ));
  91 #endif /* ultrix */
  92
  93     /* see similar block above comments */
  94     if ( *btotal > maxVolSpace / *bsize ) {
  95         *btotal = maxVolSpace;
  96     } else {
  97         *btotal *= *bsize;
  98     }
  99
 100     return( AFP_OK );
 101 }
 102
 103 static __inline__ int utombits( bits )
 104 mode_t  bits;
 105 {
 106     int         mbits;
 107
 108     mbits = 0;
 109
 110     mbits |= ( bits & ( S_IREAD >> 6 )) ? (AR_UREAD | AR_USEARCH) : 0;
 111     mbits |= ( bits & ( S_IWRITE >> 6 )) ? AR_UWRITE : 0;
 112     /* Do we really need this?
 113         mbits |= ( bits & ( S_IEXEC >> 6) ) ? AR_USEARCH : 0; */
 114
 115     return( mbits );
 116 }
 117
 118 /* --------------------------------
 119     cf AFP 3.0 page 63
 120 */
 121 void utommode( stat, ma )
 122 struct stat             *stat;
 123 struct maccess  *ma;
 124 {
 125 mode_t mode;
 126
 127     mode = stat->st_mode;
 128     ma->ma_world = utombits( mode );
 129     mode = mode >> 3;
 130
 131     ma->ma_group = utombits( mode );
 132     mode = mode >> 3;
 133
 134     ma->ma_owner = utombits( mode );
 135
 136     /* ma_user is a union of all permissions */
 137     ma->ma_user = 0;
 138     if ( (uuid == stat->st_uid) || (uuid == 0)) {
 139         ma->ma_user = ma->ma_owner | AR_UOWN;
 140     }
 141     if ( gmem( stat->st_gid )) {
 142         ma->ma_user |= ma->ma_group;
 143     }
 144     ma->ma_user |= ma->ma_world;
 145
 146     /*
 147      * There are certain things the mac won't try if you don't have
 148      * the "owner" bit set, even tho you can do these things on unix wiht
 149      * only write permission.  What were the things?
 150      *
 151      * FIXME and so what ?
 152      */
 153 #if 0
 154     if ( ma->ma_user & AR_UWRITE ) {
 155         ma->ma_user |= AR_UOWN;
 156     }
 157 #endif
 158 }
 159
 160
 161 /*
 162  * Calculate the mode for a directory using a stat() call to
 163  * estimate permission.
 164  *
 165  * Note: the previous method, using access(), does not work correctly
 166  * over NFS.
 167  */
 168 void accessmode( path, ma, dir, st )
 169 char            *path;
 170 struct maccess  *ma;
 171 struct dir      *dir;
 172 struct stat     *st;
 173
 174 {
 175 struct stat     sb;
 176
 177     ma->ma_user = ma->ma_owner = ma->ma_world = ma->ma_group = 0;
 178     if (!st) {
 179         if (stat(path, &sb) != 0)
 180             return;
 181         st = &sb;
 182     }
 183     utommode( st, ma );
 184     return;
 185 }
 186
 187 int gmem( gid )
 188 const gid_t     gid;
 189 {
 190     int         i;
 191
 192     for ( i = 0; i < ngroups; i++ ) {
 193         if ( groups[ i ] == gid ) {
 194             return( 1 );
 195         }
 196     }
 197     return( 0 );
 198 }
 199
 200 static __inline__ mode_t mtoubits( bits )
 201 u_char  bits;
 202 {
 203     mode_t      mode;
 204
 205     mode = 0;
 206
 207     mode |= ( bits & AR_UREAD ) ? ( (S_IREAD | S_IEXEC) >> 6 ) : 0;
 208     mode |= ( bits & AR_UWRITE ) ? ( (S_IWRITE | S_IEXEC) >> 6 ) : 0;
 209     /* I don't think there's a way to set the SEARCH bit by itself on a Mac
 210         mode |= ( bits & AR_USEARCH ) ? ( S_IEXEC >> 6 ) : 0; */
 211
 212     return( mode );
 213 }
 214
 215 /* ----------------------------------
 216    from the finder's share windows (menu--> File--> sharing...)
 217    and from AFP 3.0 spec page 63
 218    the mac mode should be save somewhere
 219 */
 220 mode_t mtoumode( ma )
 221 struct maccess  *ma;
 222 {
 223     mode_t              mode;
 224
 225     mode = 0;
 226     mode |= mtoubits( ma->ma_owner |ma->ma_world);
 227     mode = mode << 3;
 228
 229     mode |= mtoubits( ma->ma_group |ma->ma_world);
 230     mode = mode << 3;
 231
 232     mode |= mtoubits( ma->ma_world );
 233
 234     return( mode );
 235 }
 236
 237 int stickydirmode(name, mode, dropbox)
 238 char * name;
 239 const mode_t mode;
 240 const int dropbox;
 241 {
 242     int retval;
 243 #ifdef DROPKLUDGE
 244     int uid;
 245 #endif /* DROPKLUDGE */
 246
 247     /* Turn on the sticky bit if this is a drop box, also turn off the setgid bit */
 248     retval=0;
 249 #ifdef DROPKLUDGE
 250     if (dropbox) {
 251         if (mode & S_IWOTH) {
 252             if (mode & S_IROTH);
 253             else { /* if S_IWOTH and not S_IROTH */
 254                 uid=geteuid();
 255                 if ( seteuid(0) < 0) {
 256                     LOG(log_error, logtype_afpd, "stickydirmode: unable to seteuid root: %s", strerror(errno));
 257                 }
 258                 if ( retval=chmod( name, ( (DIRBITS | mode | S_ISVTX) & ~default_options.umask) ) < 0) {
 259                     LOG(log_error, logtype_afpd, "stickydirmode: chmod \"%s\": %s", name, strerror(errno) );
 260                     return(AFPERR_ACCESS);
 261                 } else {
 262 #ifdef DEBUG
 263                     LOG(log_info, logtype_afpd, "stickydirmode: (debug) chmod \"%s\": %s", name, strerror(retval) );
 264 #endif /* DEBUG */
 265                     seteuid(uid);
 266                 } /* end getting retval */
 267             } /* end if not & S_IROTH */
 268         } else { /* end if S_IWOTH and not S_IROTH */
 269 #endif /* DROPKLUDGE */
 270
 271             /*
 272             *  Ignore EPERM errors:  We may be dealing with a directory that is
 273             *  group writable, in which case chmod will fail.
 274             */
 275             if ( (chmod( name, (DIRBITS | mode) & ~default_options.umask ) < 0) && errno != EPERM)  {
 276                 LOG(log_error, logtype_afpd, "stickydirmode: chmod \"%s\": %s",
 277                     name, strerror(errno) );
 278                 retval = -1;
 279             }
 280 #ifdef DROPKLUDGE
 281         } /* end if not mode */
 282     } /* end checking for "dropbox" */
 283 #endif /* DROPKLUDGE */
 284     return retval;
 285 }
 286
 287 int setdeskmode( mode )
 288 const mode_t    mode;
 289 {
 290     char                wd[ MAXPATHLEN + 1];
 291     struct stat         st;
 292     char                modbuf[ 12 + 1], *m;
 293     struct dirent       *deskp, *subp;
 294     DIR                 *desk, *sub;
 295
 296     if ( getcwd( wd , MAXPATHLEN) == NULL ) {
 297         return( -1 );
 298     }
 299     if ( chdir( ".AppleDesktop" ) < 0 ) {
 300         return( -1 );
 301     }
 302     if (( desk = opendir( "." )) == NULL ) {
 303         if ( chdir( wd ) < 0 ) {
 304             LOG(log_error, logtype_afpd, "setdeskmode: chdir %s: %s", wd, strerror(errno) );
 305         }
 306         return( -1 );
 307     }
 308     for ( deskp = readdir( desk ); deskp != NULL; deskp = readdir( desk )) {
 309         if ( strcmp( deskp->d_name, "." ) == 0 ||
 310                 strcmp( deskp->d_name, ".." ) == 0 || strlen( deskp->d_name ) > 2 ) {
 311             continue;
 312         }
 313         strcpy( modbuf, deskp->d_name );
 314         strcat( modbuf, "/" );
 315         m = strchr( modbuf, '\0' );
 316         if (( sub = opendir( deskp->d_name )) == NULL ) {
 317             continue;
 318         }
 319         for ( subp = readdir( sub ); subp != NULL; subp = readdir( sub )) {
 320             if ( strcmp( subp->d_name, "." ) == 0 ||
 321                     strcmp( subp->d_name, ".." ) == 0 ) {
 322                 continue;
 323             }
 324             *m = '\0';
 325             strcat( modbuf, subp->d_name );
 326             /* XXX: need to preserve special modes */
 327             if (stat(modbuf, &st) < 0) {
 328                 LOG(log_error, logtype_afpd, "setdeskmode: stat %s: %s",
 329                     modbuf, strerror(errno) );
 330                 continue;
 331             }
 332
 333             if (S_ISDIR(st.st_mode)) {
 334                 if ( chmod( modbuf,  (DIRBITS | mode) & ~default_options.umask ) < 0 && errno != EPERM ) {
 335                     LOG(log_error, logtype_afpd, "setdeskmode: chmod %s: %s",
 336                         modbuf, strerror(errno) );
 337                 }
 338             } else if ( chmod( modbuf,  mode & ~default_options.umask ) < 0 && errno != EPERM ) {
 339                 LOG(log_error, logtype_afpd, "setdeskmode: chmod %s: %s",
 340                     modbuf, strerror(errno) );
 341             }
 342
 343         }
 344         closedir( sub );
 345         /* XXX: need to preserve special modes */
 346         if ( chmod( deskp->d_name,  (DIRBITS | mode) & ~default_options.umask ) < 0 && errno != EPERM ) {
 347             LOG(log_error, logtype_afpd, "setdeskmode: chmod %s: %s",
 348                 deskp->d_name, strerror(errno) );
 349         }
 350     }
 351     closedir( desk );
 352     if ( chdir( wd ) < 0 ) {
 353         LOG(log_error, logtype_afpd, "setdeskmode: chdir %s: %s", wd, strerror(errno) );
 354         return -1;
 355     }
 356     /* XXX: need to preserve special modes */
 357     if ( chmod( ".AppleDesktop",  (DIRBITS | mode) & ~default_options.umask ) < 0 && errno != EPERM ) {
 358         LOG(log_error, logtype_afpd, "setdeskmode: chmod .AppleDesktop: %s", strerror(errno) );
 359     }
 360     return( 0 );
 361 }
 362
 363 int setfilmode(name, mode, st)
 364 char * name;
 365 mode_t mode;
 366 struct stat *st;
 367 {
 368 struct stat sb;
 369 mode_t mask = S_IRUSR |S_IWUSR | S_IRGRP | S_IWGRP |S_IROTH | S_IWOTH;
 370
 371     if (!st) {
 372         if (stat(name, &sb) != 0)
 373             return;
 374         st = &sb;
 375     }
 376    mode &= mask;        /* keep only rw-rw-rw in mode */
 377    mode |= st->st_mode & ~mask; /* keep other bits from previous mode */
 378    if ( chmod( name,  mode & ~default_options.umask ) < 0 && errno != EPERM ) {
 379        return -1;
 380    }
 381    return 0;
 382 }
 383
 384 int setdirmode( mode, noadouble, dropbox )
 385 const mode_t mode;
 386 const int noadouble;
 387 const int dropbox;
 388 {
 389     char                buf[ MAXPATHLEN + 1];
 390     struct stat         st;
 391     char                *m;
 392     struct dirent       *dirp;
 393     DIR                 *dir;
 394
 395     if (( dir = opendir( "." )) == NULL ) {
 396         LOG(log_error, logtype_afpd, "setdirmode: opendir .: %s", strerror(errno) );
 397         return( -1 );
 398     }
 399
 400     for ( dirp = readdir( dir ); dirp != NULL; dirp = readdir( dir )) {
 401         if ( *dirp->d_name == '.' ) {
 402             continue;
 403         }
 404         if ( stat( dirp->d_name, &st ) < 0 ) {
 405             LOG(log_error, logtype_afpd, "setdirmode: stat %s: %s",
 406                 dirp->d_name, strerror(errno) );
 407             continue;
 408         }
 409
 410         if (S_ISREG(st.st_mode)) {
 411            if (setfilmode(dirp->d_name, mode, &st) < 0) {
 412                 LOG(log_error, logtype_afpd, "setdirmode: chmod %s: %s",
 413                     dirp->d_name, strerror(errno) );
 414                 return -1;
 415            }
 416         }
 417 #if 0
 418             /* XXX: need to preserve special modes */
 419         else if (S_ISDIR(st.st_mode)) {
 420                 if (stickydirmode(dirp->d_name, DIRBITS | mode, dropbox) < 0)
 421                     return (-1);
 422             } else if (stickydirmode(dirp->d_name, mode, dropbox) < 0)
 423                 return (-1);
 424         }
 425 #endif
 426     }
 427     closedir( dir );
 428
 429     /* change perm of .AppleDouble's files
 430     */
 431     if (( dir = opendir( ".AppleDouble" )) == NULL ) {
 432         if (noadouble)
 433             goto setdirmode_noadouble;
 434         LOG(log_error, logtype_afpd, "setdirmode: opendir .AppleDouble: %s", strerror(errno) );
 435         return( -1 );
 436     }
 437     strcpy( buf, ".AppleDouble" );
 438     strcat( buf, "/" );
 439     m = strchr( buf, '\0' );
 440     for ( dirp = readdir( dir ); dirp != NULL; dirp = readdir( dir )) {
 441         if ( strcmp( dirp->d_name, "." ) == 0 ||
 442                 strcmp( dirp->d_name, ".." ) == 0 ) {
 443             continue;
 444         }
 445         *m = '\0';
 446         strcat( buf, dirp->d_name );
 447
 448         if ( stat( buf, &st ) < 0 ) {
 449             LOG(log_error, logtype_afpd, "setdirmode: stat %s: %s", buf, strerror(errno) );
 450             continue;
 451         }
 452         if (S_ISREG(st.st_mode)) {
 453            if (setfilmode(dirp->d_name, ad_hf_mode(mode), &st) < 0) {
 454                /* FIXME what do we do then? */
 455            }
 456         }
 457     } /* end for */
 458     closedir( dir );
 459
 460     /* XXX: use special bits to tag directory permissions */
 461
 462     /* XXX: need to preserve special modes */
 463     if ( stickydirmode(".AppleDouble", DIRBITS | mode, dropbox) < 0 )
 464         return( -1 );
 465
 466 setdirmode_noadouble:
 467     /* XXX: need to preserve special modes */
 468     if ( stickydirmode(".", DIRBITS | mode, dropbox) < 0 )
 469         return( -1 );
 470     return( 0 );
 471 }
 472
 473 int setdeskowner( uid, gid )
 474 const uid_t     uid;
 475 const gid_t     gid;
 476 {
 477     char                wd[ MAXPATHLEN + 1];
 478     char                modbuf[12 + 1], *m;
 479     struct dirent       *deskp, *subp;
 480     DIR                 *desk, *sub;
 481
 482     if ( getcwd( wd, MAXPATHLEN ) == NULL ) {
 483         return( -1 );
 484     }
 485     if ( chdir( ".AppleDesktop" ) < 0 ) {
 486         return( -1 );
 487     }
 488     if (( desk = opendir( "." )) == NULL ) {
 489         if ( chdir( wd ) < 0 ) {
 490             LOG(log_error, logtype_afpd, "setdeskowner: chdir %s: %s", wd, strerror(errno) );
 491         }
 492         return( -1 );
 493     }
 494     for ( deskp = readdir( desk ); deskp != NULL; deskp = readdir( desk )) {
 495         if ( strcmp( deskp->d_name, "." ) == 0 ||
 496                 strcmp( deskp->d_name, ".." ) == 0 ||
 497                 strlen( deskp->d_name ) > 2 ) {
 498             continue;
 499         }
 500         strcpy( modbuf, deskp->d_name );
 501         strcat( modbuf, "/" );
 502         m = strchr( modbuf, '\0' );
 503         if (( sub = opendir( deskp->d_name )) == NULL ) {
 504             continue;
 505         }
 506         for ( subp = readdir( sub ); subp != NULL; subp = readdir( sub )) {
 507             if ( strcmp( subp->d_name, "." ) == 0 ||
 508                     strcmp( subp->d_name, ".." ) == 0 ) {
 509                 continue;
 510             }
 511             *m = '\0';
 512             strcat( modbuf, subp->d_name );
 513             /* XXX: add special any uid, ignore group bits */
 514             if ( chown( modbuf, uid, gid ) < 0 && errno != EPERM ) {
 515                 LOG(log_error, logtype_afpd, "setdeskown: chown %s: %s",
 516                     modbuf, strerror(errno) );
 517             }
 518         }
 519         closedir( sub );
 520         /* XXX: add special any uid, ignore group bits */
 521         if ( chown( deskp->d_name, uid, gid ) < 0 && errno != EPERM ) {
 522             LOG(log_error, logtype_afpd, "setdeskowner: chown %s: %s",
 523                 deskp->d_name, strerror(errno) );
 524         }
 525     }
 526     closedir( desk );
 527     if ( chdir( wd ) < 0 ) {
 528         LOG(log_error, logtype_afpd, "setdeskowner: chdir %s: %s", wd, strerror(errno) );
 529         return -1;
 530     }
 531     if ( chown( ".AppleDesktop", uid, gid ) < 0 && errno != EPERM ) {
 532         LOG(log_error, logtype_afpd, "setdeskowner: chown .AppleDesktop: %s",
 533             strerror(errno) );
 534     }
 535     return( 0 );
 536 }
 537
 538
 539 /* uid/gid == 0 need to be handled as special cases. they really mean
 540  * that user/group should inherit from other, but that doesn't fit
 541  * into the unix permission scheme. we can get around this by
 542  * co-opting some bits. */
 543 int setdirowner( uid, gid, noadouble )
 544 const uid_t     uid;
 545 const gid_t     gid;
 546 const int   noadouble;
 547 {
 548     char                buf[ MAXPATHLEN + 1];
 549     struct stat         st;
 550     char                *m;
 551     struct dirent       *dirp;
 552     DIR                 *dir;
 553
 554     if (( dir = opendir( "." )) == NULL ) {
 555         return( -1 );
 556     }
 557     for ( dirp = readdir( dir ); dirp != NULL; dirp = readdir( dir )) {
 558         if ( *dirp->d_name == '.' ) {
 559             continue;
 560         };
 561         if ( stat( dirp->d_name, &st ) < 0 ) {
 562             LOG(log_error, logtype_afpd, "setdirowner: stat %s: %s",
 563                 dirp->d_name, strerror(errno) );
 564             continue;
 565         }
 566         if (( st.st_mode & S_IFMT ) == S_IFREG ) {
 567             if ( chown( dirp->d_name, uid, gid ) < 0 && errno != EPERM ) {
 568                 LOG(log_debug, logtype_afpd, "setdirowner: chown %s: %s",
 569                     dirp->d_name, strerror(errno) );
 570                 /* return ( -1 ); Sometimes this is okay */
 571             }
 572         }
 573     }
 574     closedir( dir );
 575     if (( dir = opendir( ".AppleDouble" )) == NULL ) {
 576         if (noadouble)
 577             goto setdirowner_noadouble;
 578         return( -1 );
 579     }
 580     strcpy( buf, ".AppleDouble" );
 581     strcat( buf, "/" );
 582     m = strchr( buf, '\0' );
 583     for ( dirp = readdir( dir ); dirp != NULL; dirp = readdir( dir )) {
 584         if ( strcmp( dirp->d_name, "." ) == 0 ||
 585                 strcmp( dirp->d_name, ".." ) == 0 ) {
 586             continue;
 587         }
 588         *m = '\0';
 589         strcat( buf, dirp->d_name );
 590         if ( chown( buf, uid, gid ) < 0 && errno != EPERM ) {
 591             LOG(log_debug, logtype_afpd, "setdirowner: chown %d/%d %s: %s",
 592                 uid, gid, buf, strerror(errno) );
 593             /* return ( -1 ); Sometimes this is okay */
 594         }
 595     }
 596     closedir( dir );
 597
 598     /*
 599      * We cheat: we know that chown doesn't do anything.
 600      */
 601     if ( stat( ".AppleDouble", &st ) < 0 ) {
 602         LOG(log_error, logtype_afpd, "setdirowner: stat .AppleDouble: %s", strerror(errno) );
 603         return( -1 );
 604     }
 605     if ( gid && gid != st.st_gid && chown( ".AppleDouble", uid, gid ) < 0 &&
 606             errno != EPERM ) {
 607         LOG(log_debug, logtype_afpd, "setdirowner: chown %d/%d .AppleDouble: %s",
 608             uid, gid, strerror(errno) );
 609         /* return ( -1 ); Sometimes this is okay */
 610     }
 611
 612 setdirowner_noadouble:
 613     if ( stat( ".", &st ) < 0 ) {
 614         return( -1 );
 615     }
 616     if ( gid && gid != st.st_gid && chown( ".", uid, gid ) < 0 &&
 617             errno != EPERM ) {
 618         LOG(log_debug, logtype_afpd, "setdirowner: chown %d/%d .: %s",
 619             uid, gid, strerror(errno) );
 620     }
 621
 622     return( 0 );
 623 }