etc/afpd/file.c

   1 /*
   2  * $Id: file.c,v 1.29 2001-09-06 20:00:59 rufustfirefly 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 #ifdef HAVE_UNISTD_H
  15 #include <unistd.h>
  16 #endif /* HAVE_UNISTD_H */
  17
  18 /* STDC check */
  19 #if STDC_HEADERS
  20 #include <string.h>
  21 #else /* STDC_HEADERS */
  22 #ifndef HAVE_STRCHR
  23 #define strchr index
  24 #define strrchr index
  25 #endif /* HAVE_STRCHR */
  26 char *strchr (), *strrchr ();
  27 #ifndef HAVE_MEMCPY
  28 #define memcpy(d,s,n) bcopy ((s), (d), (n))
  29 #define memmove(d,s,n) bcopy ((s), (d), (n))
  30 #endif /* ! HAVE_MEMCPY */
  31 #endif /* STDC_HEADERS */
  32
  33 #include <utime.h>
  34 #ifdef HAVE_FCNTL_H
  35 #include <fcntl.h>
  36 #endif /* HAVE_FCNTL_H */
  37 #include <dirent.h>
  38 #include <sys/mman.h>
  39 #include <errno.h>
  40
  41 #include <sys/syslog.h>
  42 #include <sys/types.h>
  43 #include <sys/time.h>
  44 #include <sys/param.h>
  45 #include <sys/stat.h>
  46
  47 #include <netatalk/endian.h>
  48 #include <atalk/adouble.h>
  49 #include <atalk/afp.h>
  50 #include <atalk/util.h>
  51 #ifdef CNID_DB
  52 #include <atalk/cnid.h>
  53 #endif /* CNID_DB */
  54 #include "directory.h"
  55 #include "desktop.h"
  56 #include "volume.h"
  57 #include "fork.h"
  58 #include "file.h"
  59 #include "filedir.h"
  60 #include "globals.h"
  61
  62 /* check for mtab DID code */
  63 #ifdef DID_MTAB
  64 #include "parse_mtab.h"
  65 #endif /* DID_MTAB */
  66
  67 #ifdef FORCE_UIDGID
  68 #warning UIDGID
  69 #include "uid.h"
  70 #endif /* FORCE_UIDGID */
  71
  72 /* the format for the finderinfo fields (from IM: Toolbox Essentials):
  73  * field         bytes        subfield    bytes
  74  *
  75  * files:
  76  * ioFlFndrInfo  16      ->       type    4  type field
  77  *                             creator    4  creator field
  78  *                               flags    2  finder flags:
  79  *                                           alias, bundle, etc.
  80  *                            location    4  location in window
  81  *                              folder    2  window that contains file
  82  *
  83  * ioFlXFndrInfo 16      ->     iconID    2  icon id
  84  *                              unused    6  reserved
  85  *                              script    1  script system
  86  *                              xflags    1  reserved
  87  *                           commentID    2  comment id
  88  *                           putawayID    4  home directory id
  89  */
  90
  91 const u_char ufinderi[] = {
  92     'T', 'E', 'X', 'T', 'U', 'N', 'I', 'X',
  93     0, 0, 0, 0, 0, 0, 0, 0,
  94     0, 0, 0, 0, 0, 0, 0, 0,
  95     0, 0, 0, 0, 0, 0, 0, 0
  96 };
  97
  98 int getfilparams(struct vol *vol,
  99                  u_int16_t bitmap,
 100                  char *path, struct dir *dir, struct stat *st,
 101                  char *buf, int *buflen )
 102 {
 103 #ifndef USE_LASTDID
 104     struct stat         hst, lst, *lstp;
 105 #else /* USE_LASTDID */
 106     struct stat         hst;
 107 #endif /* USE_LASTDID */
 108     struct adouble      ad, *adp;
 109     struct ofork        *of;
 110     struct extmap       *em;
 111     char                *data, *nameoff = NULL, *upath;
 112     int                 bit = 0, isad = 1;
 113     u_int32_t           aint;
 114     u_int16_t           ashort;
 115     u_char              achar, fdType[4];
 116
 117 #ifdef DEBUG
 118     syslog(LOG_INFO, "begin getfilparams:");
 119 #endif /* DEBUG */
 120
 121     upath = mtoupath(vol, path);
 122     if ((of = of_findname(vol, curdir, path))) {
 123       adp = of->of_ad;
 124     } else {
 125       memset(&ad, 0, sizeof(ad));
 126       adp = &ad;
 127     }
 128
 129     if ( ad_open( upath, ADFLAGS_HF, O_RDONLY, 0, adp) < 0 ) {
 130         isad = 0;
 131     } else if ( fstat( ad_hfileno( adp ), &hst ) < 0 ) {
 132             syslog( LOG_ERR, "getfilparams fstat: %s", strerror(errno) );
 133     }
 134
 135     data = buf;
 136     while ( bitmap != 0 ) {
 137         while (( bitmap & 1 ) == 0 ) {
 138             bitmap = bitmap>>1;
 139             bit++;
 140         }
 141
 142         switch ( bit ) {
 143         case FILPBIT_ATTR :
 144             if ( isad ) {
 145                 ad_getattr(adp, &ashort);
 146             } else if (*upath == '.') {
 147                 ashort = htons(ATTRBIT_INVISIBLE);
 148             } else
 149                 ashort = 0;
 150             memcpy(data, &ashort, sizeof( ashort ));
 151             data += sizeof( u_short );
 152             break;
 153
 154         case FILPBIT_PDID :
 155             memcpy(data, &dir->d_did, sizeof( u_int32_t ));
 156             data += sizeof( u_int32_t );
 157             break;
 158
 159         case FILPBIT_CDATE :
 160             if (!isad || (ad_getdate(adp, AD_DATE_CREATE, &aint) < 0))
 161                 aint = AD_DATE_FROM_UNIX(st->st_mtime);
 162             memcpy(data, &aint, sizeof( aint ));
 163             data += sizeof( aint );
 164             break;
 165
 166         case FILPBIT_MDATE :
 167             if ( isad && (ad_getdate(adp, AD_DATE_MODIFY, &aint) == 0)) {
 168                 if ((st->st_mtime > AD_DATE_TO_UNIX(aint)) &&
 169                     (hst.st_mtime < st->st_mtime)) {
 170                     aint = AD_DATE_FROM_UNIX(st->st_mtime);
 171                 }
 172             } else {
 173                 aint = AD_DATE_FROM_UNIX(st->st_mtime);
 174             }
 175             memcpy(data, &aint, sizeof( int ));
 176             data += sizeof( int );
 177             break;
 178
 179         case FILPBIT_BDATE :
 180             if (!isad || (ad_getdate(adp, AD_DATE_BACKUP, &aint) < 0))
 181                 aint = AD_DATE_START;
 182             memcpy(data, &aint, sizeof( int ));
 183             data += sizeof( int );
 184             break;
 185
 186         case FILPBIT_FINFO :
 187             if (isad)
 188               memcpy(data, ad_entry(adp, ADEID_FINDERI), 32);
 189             else {
 190               memcpy(data, ufinderi, 32);
 191               if (*upath == '.') { /* make it invisible */
 192                 ashort = htons(FINDERINFO_INVISIBLE);
 193                 memcpy(data + FINDERINFO_FRFLAGOFF, &ashort, sizeof(ashort));
 194               }
 195             }
 196
 197             if ((!isad || (memcmp(ad_entry(adp, ADEID_FINDERI),
 198                                   ufinderi, 8 ) == 0)) &&
 199                 (em = getextmap( path ))) {
 200               memcpy(data, em->em_type, sizeof( em->em_type ));
 201               memcpy(data + 4, em->em_creator, sizeof(em->em_creator));
 202             }
 203             data += 32;
 204             break;
 205
 206         case FILPBIT_LNAME :
 207             nameoff = data;
 208             data += sizeof( u_int16_t );
 209             break;
 210
 211         case FILPBIT_SNAME :
 212             memset(data, 0, sizeof(u_int16_t));
 213             data += sizeof( u_int16_t );
 214             break;
 215
 216         case FILPBIT_FNUM :
 217                 aint = 0;
 218 #if AD_VERSION > AD_VERSION1
 219         /* look in AD v2 header */
 220         if (isad)
 221                         memcpy(&aint, ad_entry(adp, ADEID_DID), sizeof(aint));
 222 #endif /* AD_VERSION > AD_VERSION1 */
 223
 224 #ifdef CNID_DB
 225         aint = cnid_add(vol->v_db, st, dir->d_did, upath,
 226                                                         strlen(upath), aint);
 227 #endif /* CNID_DB */
 228
 229                 if (aint == 0) {
 230             /*
 231              * What a fucking mess.  First thing:  DID and FNUMs are
 232              * in the same space for purposes of enumerate (and several
 233              * other wierd places).  While we consider this Apple's bug,
 234              * this is the work-around:  In order to maintain constant and
 235              * unique DIDs and FNUMs, we monotonically generate the DIDs
 236              * during the session, and derive the FNUMs from the filesystem.
 237              * Since the DIDs are small, we insure that the FNUMs are fairly
 238              * large by setting thier high bits to the device number.
 239              *
 240              * AFS already does something very similar to this for the
 241              * inode number, so we don't repeat the procedure.
 242              *
 243              * new algorithm:
 244              * due to complaints over did's being non-persistent,
 245              * here's the current hack to provide semi-persistent
 246              * did's:
 247              *      1) we reserve the first bit for file ids.
 248              *      2) the next 7 bits are for the device.
 249              *      3) the remaining 24 bits are for the inode.
 250              *
 251              * both the inode and device information are actually hashes
 252              * that are then truncated to the requisite bit length.
 253              *
 254              * it should be okay to use lstat to deal with symlinks.
 255              */
 256 #ifdef USE_LASTDID
 257               aint = htonl(( st->st_dev << 16 ) | (st->st_ino & 0x0000ffff));
 258 #else /* USE_LASTDID */
 259               lstp = lstat(upath, &lst) < 0 ? st : &lst;
 260 #ifdef DID_MTAB
 261               aint = htonl( afpd_st_cnid ( lstp ) );
 262 #else /* DID_MTAB */
 263               aint = htonl(CNID(lstp, 1));
 264 #endif /* DID_MTAB */
 265 #endif /* USE_LASTDID */
 266         }
 267
 268                 memcpy(data, &aint, sizeof( aint ));
 269             data += sizeof( aint );
 270             break;
 271
 272         case FILPBIT_DFLEN :
 273             aint = htonl( st->st_size );
 274             memcpy(data, &aint, sizeof( aint ));
 275             data += sizeof( aint );
 276             break;
 277
 278         case FILPBIT_RFLEN :
 279             if ( isad ) {
 280                 aint = htonl( ad_getentrylen( adp, ADEID_RFORK ));
 281             } else {
 282                 aint = 0;
 283             }
 284             memcpy(data, &aint, sizeof( aint ));
 285             data += sizeof( aint );
 286             break;
 287
 288             /* Current client needs ProDOS info block for this file.
 289                Use simple heuristic and let the Mac "type" string tell
 290                us what the PD file code should be.  Everything gets a
 291                subtype of 0x0000 unless the original value was hashed
 292                to "pXYZ" when we created it.  See IA, Ver 2.
 293                <shirsch@ibm.net> */
 294         case FILPBIT_PDINFO :
 295             if ( isad ) {
 296               memcpy(fdType, ad_entry( adp, ADEID_FINDERI ), 4 );
 297
 298               if ( memcmp( fdType, "TEXT", 4 ) == 0 ) {
 299                 achar = '\x04';
 300                 ashort = 0x0000;
 301               }
 302               else if ( memcmp( fdType, "PSYS", 4 ) == 0 ) {
 303                 achar = '\xff';
 304                 ashort = 0x0000;
 305               }
 306               else if ( memcmp( fdType, "PS16", 4 ) == 0 ) {
 307                 achar = '\xb3';
 308                 ashort = 0x0000;
 309               }
 310               else if ( memcmp( fdType, "BINA", 4 ) == 0 ) {
 311                 achar = '\x00';
 312                 ashort = 0x0000;
 313               }
 314               else if ( fdType[0] == 'p' ) {
 315                 achar = fdType[1];
 316                 ashort = (fdType[2] * 256) + fdType[3];
 317               }
 318               else {
 319                 achar = '\x00';
 320                 ashort = 0x0000;
 321               }
 322             }
 323             else {
 324               achar = '\x00';
 325               ashort = 0x0000;
 326             }
 327
 328             *data++ = achar;
 329             *data++ = 0;
 330             memcpy(data, &ashort, sizeof( ashort ));
 331             data += sizeof( ashort );
 332             memset(data, 0, sizeof( ashort ));
 333             data += sizeof( ashort );
 334             break;
 335
 336         default :
 337             if ( isad ) {
 338                 ad_close( adp, ADFLAGS_HF );
 339             }
 340             return( AFPERR_BITMAP );
 341         }
 342         bitmap = bitmap>>1;
 343         bit++;
 344     }
 345     if ( nameoff ) {
 346         ashort = htons( data - buf );
 347         memcpy(nameoff, &ashort, sizeof( ashort ));
 348         if ((aint = strlen( path )) > MACFILELEN)
 349           aint = MACFILELEN;
 350         *data++ = aint;
 351         memcpy(data, path, aint );
 352         data += aint;
 353     }
 354     if ( isad ) {
 355         ad_close( adp, ADFLAGS_HF );
 356     }
 357     *buflen = data - buf;
 358
 359 #ifdef DEBUG
 360     syslog(LOG_INFO, "end getfilparams:");
 361 #endif /* DEBUG */
 362
 363     return( AFP_OK );
 364 }
 365
 366 int afp_createfile(obj, ibuf, ibuflen, rbuf, rbuflen )
 367     AFPObj      *obj;
 368     char        *ibuf, *rbuf;
 369     int         ibuflen, *rbuflen;
 370 {
 371     struct stat         st;
 372     struct adouble      ad, *adp;
 373     struct vol          *vol;
 374     struct dir          *dir;
 375     struct ofork        *of;
 376     char                *path, *upath;
 377     int                 creatf, did, openf, retvalue = AFP_OK;
 378     u_int16_t           vid;
 379 #ifdef FORCE_UIDGID
 380         uidgidset               *uidgid;
 381 #endif /* FORCE_UIDGID */
 382
 383 #ifdef DEBUG
 384     syslog(LOG_INFO, "begin afp_createfile:");
 385 #endif /* DEBUG */
 386
 387     *rbuflen = 0;
 388     ibuf++;
 389     creatf = (unsigned char) *ibuf++;
 390
 391     memcpy(&vid, ibuf, sizeof( vid ));
 392     ibuf += sizeof( vid );
 393
 394     if (( vol = getvolbyvid( vid )) == NULL ) {
 395         return( AFPERR_PARAM );
 396     }
 397
 398     if (vol->v_flags & AFPVOL_RO)
 399         return AFPERR_VLOCK;
 400
 401     memcpy(&did, ibuf, sizeof( did));
 402     ibuf += sizeof( did );
 403
 404     if (( dir = dirsearch( vol, did )) == NULL ) {
 405         return( AFPERR_NOOBJ );
 406     }
 407
 408     if (( path = cname( vol, dir, &ibuf )) == NULL ) {
 409         return( AFPERR_NOOBJ );
 410     }
 411
 412     if ((vol->v_flags & AFPVOL_MSWINDOWS) &&
 413         strpbrk(path, MSWINDOWS_BADCHARS))
 414         return AFPERR_PARAM;
 415
 416     upath = mtoupath(vol, path);
 417
 418     if ((vol->v_flags & AFPVOL_NOHEX) && strchr(upath, '/'))
 419       return AFPERR_PARAM;
 420
 421     if (!validupath(vol, upath))
 422       return AFPERR_EXIST;
 423
 424     /* check for vetoed filenames */
 425     if (veto_file(vol->v_veto, upath))
 426         return AFPERR_EXIST;
 427
 428     if ((of = of_findname(vol, curdir, path))) {
 429       adp = of->of_ad;
 430     } else {
 431       memset(&ad, 0, sizeof(ad));
 432       adp = &ad;
 433     }
 434     if ( creatf) {
 435         /* on a hard create, fail if file exists and is open */
 436         if ((stat(upath, &st) == 0) && of)
 437           return AFPERR_BUSY;
 438         openf = O_RDWR|O_CREAT|O_TRUNC;
 439     } else {
 440         openf = O_RDWR|O_CREAT|O_EXCL;
 441     }
 442
 443 #ifdef FORCE_UIDGID
 444
 445         /* preserve current euid, egid */
 446         save_uidgid ( uidgid );
 447
 448         /* perform all switching of users */
 449         set_uidgid ( vol );
 450
 451 #endif /* FORCE_UIDGID */
 452
 453     if ( ad_open( upath, vol_noadouble(vol)|ADFLAGS_DF|ADFLAGS_HF,
 454                   openf, 0666, adp) < 0 ) {
 455       switch ( errno ) {
 456         case EEXIST :
 457 #ifdef FORCE_UIDGID
 458                 /* bring everything back to old euid, egid */
 459                 restore_uidgid ( uidgid );
 460 #endif /* FORCE_UIDGID */
 461             return( AFPERR_EXIST );
 462         case EACCES :
 463 #ifdef FORCE_UIDGID
 464                 /* bring everything back to old euid, egid */
 465                 restore_uidgid ( uidgid );
 466 #endif /* FORCE_UIDGID */
 467             return( AFPERR_ACCESS );
 468         case ENOENT:
 469             /* on noadouble volumes, just creating the data fork is ok */
 470             if (vol_noadouble(vol) && (stat(upath, &st) == 0))
 471               goto createfile_done;
 472             /* fallthrough */
 473         default :
 474 #ifdef FORCE_UIDGID
 475                 /* bring everything back to old euid, egid */
 476                 restore_uidgid ( uidgid );
 477 #endif /* FORCE_UIDGID */
 478             return( AFPERR_PARAM );
 479         }
 480     }
 481
 482     ad_setentrylen( adp, ADEID_NAME, strlen( path ));
 483     memcpy(ad_entry( adp, ADEID_NAME ), path,
 484            ad_getentrylen( adp, ADEID_NAME ));
 485     ad_flush( adp, ADFLAGS_DF|ADFLAGS_HF );
 486     ad_close( adp, ADFLAGS_DF|ADFLAGS_HF );
 487
 488 createfile_done:
 489
 490 #ifdef DROPKLUDGE
 491     if (vol->v_flags & AFPVOL_DROPBOX) {
 492          retvalue = matchfile2dirperms(upath, vol, did);
 493     }
 494 #endif /* DROPKLUDGE */
 495
 496     setvoltime(obj, vol );
 497
 498 #ifdef DEBUG
 499     syslog(LOG_INFO, "end afp_createfile");
 500 #endif /* DEBUG */
 501
 502 #ifdef FORCE_UIDGID
 503         /* bring everything back to old euid, egid */
 504         restore_uidgid ( uidgid );
 505 #endif /* FORCE_UIDGID */
 506
 507     return (retvalue);
 508 }
 509
 510 int afp_setfilparams(obj, ibuf, ibuflen, rbuf, rbuflen )
 511     AFPObj      *obj;
 512     char        *ibuf, *rbuf;
 513     int         ibuflen, *rbuflen;
 514 {
 515     struct vol  *vol;
 516     struct dir  *dir;
 517     char        *path;
 518     int         did, rc;
 519     u_int16_t   vid, bitmap;
 520
 521 #ifdef DEBUG
 522     syslog(LOG_INFO, "begin afp_setfilparams:");
 523 #endif /* DEBUG */
 524
 525     *rbuflen = 0;
 526     ibuf += 2;
 527
 528     memcpy(&vid, ibuf, sizeof( vid ));
 529     ibuf += sizeof( vid );
 530     if (( vol = getvolbyvid( vid )) == NULL ) {
 531         return( AFPERR_PARAM );
 532     }
 533
 534     if (vol->v_flags & AFPVOL_RO)
 535         return AFPERR_VLOCK;
 536
 537     memcpy(&did, ibuf, sizeof( did ));
 538     ibuf += sizeof( did );
 539     if (( dir = dirsearch( vol, did )) == NULL ) {
 540         return( AFPERR_NOOBJ );
 541     }
 542
 543     memcpy(&bitmap, ibuf, sizeof( bitmap ));
 544     bitmap = ntohs( bitmap );
 545     ibuf += sizeof( bitmap );
 546
 547     if (( path = cname( vol, dir, &ibuf )) == NULL ) {
 548         return( AFPERR_NOOBJ );
 549     }
 550
 551     if ((u_long)ibuf & 1 ) {
 552         ibuf++;
 553     }
 554
 555     if (( rc = setfilparams(vol, path, bitmap, ibuf )) == AFP_OK ) {
 556         setvoltime(obj, vol );
 557     }
 558
 559 #ifdef DEBUG
 560     syslog(LOG_INFO, "end afp_setfilparams:");
 561 #endif /* DEBUG */
 562
 563     return( rc );
 564 }
 565
 566
 567 int setfilparams(struct vol *vol,
 568                  char *path, u_int16_t bitmap, char *buf )
 569 {
 570     struct adouble      ad, *adp;
 571     struct ofork        *of;
 572     struct extmap       *em;
 573     int                 bit = 0, isad = 1, err = AFP_OK;
 574     char                *upath;
 575     u_char              achar, *fdType, xyy[4];
 576     u_int16_t           ashort, bshort;
 577     u_int32_t           aint;
 578     struct utimbuf      ut;
 579
 580 #ifdef FORCE_UIDGID
 581         uidgidset               *uidgid;
 582
 583         uidgid = malloc(sizeof(uidgidset));
 584 #endif /* FORCE_UIDGID */
 585
 586 #ifdef DEBUG
 587     syslog(LOG_INFO, "begin setfilparams:");
 588 #endif /* DEBUG */
 589
 590     upath = mtoupath(vol, path);
 591     if ((of = of_findname(vol, curdir, path))) {
 592       adp = of->of_ad;
 593     } else {
 594       memset(&ad, 0, sizeof(ad));
 595       adp = &ad;
 596     }
 597
 598 #ifdef FORCE_UIDGID
 599         save_uidgid ( uidgid );
 600         set_uidgid ( vol );
 601 #endif /* FORCE_UIDGID */
 602
 603     if (ad_open( upath, vol_noadouble(vol) | ADFLAGS_HF,
 604                  O_RDWR|O_CREAT, 0666, adp) < 0) {
 605       /* for some things, we don't need an adouble header */
 606       if (bitmap & ~(1<<FILPBIT_MDATE)) {
 607 #ifdef FORCE_UIDGID
 608         restore_uidgid ( uidgid );
 609 #endif /* FORCE_UIDGID */
 610         return vol_noadouble(vol) ? AFP_OK : AFPERR_ACCESS;
 611       }
 612       isad = 0;
 613     } else if ((ad_getoflags( adp, ADFLAGS_HF ) & O_CREAT) ) {
 614         ad_setentrylen( adp, ADEID_NAME, strlen( path ));
 615         memcpy(ad_entry( adp, ADEID_NAME ), path,
 616                ad_getentrylen( adp, ADEID_NAME ));
 617     }
 618
 619     while ( bitmap != 0 ) {
 620         while (( bitmap & 1 ) == 0 ) {
 621             bitmap = bitmap>>1;
 622             bit++;
 623         }
 624
 625         switch(  bit ) {
 626         case FILPBIT_ATTR :
 627             memcpy(&ashort, buf, sizeof( ashort ));
 628             ad_getattr(adp, &bshort);
 629             if ( ntohs( ashort ) & ATTRBIT_SETCLR ) {
 630               bshort |= htons( ntohs( ashort ) & ~ATTRBIT_SETCLR );
 631             } else {
 632               bshort &= ~ashort;
 633             }
 634             ad_setattr(adp, bshort);
 635             buf += sizeof( ashort );
 636             break;
 637
 638         case FILPBIT_CDATE :
 639             memcpy(&aint, buf, sizeof(aint));
 640             ad_setdate(adp, AD_DATE_CREATE, aint);
 641             buf += sizeof( aint );
 642             break;
 643
 644         case FILPBIT_MDATE :
 645             memcpy(&aint, buf, sizeof( aint ));
 646             if (isad)
 647               ad_setdate(adp, AD_DATE_MODIFY, aint);
 648             ut.actime = ut.modtime = AD_DATE_TO_UNIX(aint);
 649             utime(upath, &ut);
 650             buf += sizeof( aint );
 651             break;
 652
 653         case FILPBIT_BDATE :
 654             memcpy(&aint, buf, sizeof(aint));
 655             ad_setdate(adp, AD_DATE_BACKUP, aint);
 656             buf += sizeof( aint );
 657             break;
 658
 659         case FILPBIT_FINFO :
 660             if ((memcmp( ad_entry( adp, ADEID_FINDERI ), ufinderi, 8 ) == 0)
 661                 && (em = getextmap( path )) &&
 662                 (memcmp(buf, em->em_type, sizeof( em->em_type )) == 0) &&
 663                 (memcmp(buf + 4, em->em_creator,
 664                         sizeof( em->em_creator )) == 0)) {
 665               memcpy(buf, ufinderi, 8 );
 666             }
 667             memcpy(ad_entry( adp, ADEID_FINDERI ), buf, 32 );
 668             buf += 32;
 669             break;
 670
 671             /* Client needs to set the ProDOS file info for this file.
 672                Use defined strings for the simple cases, and convert
 673                all else into pXYY per Inside Appletalk.  Always set
 674                the creator as "pdos". <shirsch@ibm.net> */
 675         case FILPBIT_PDINFO :
 676             achar = *buf;
 677             buf += 2;
 678             memcpy(&ashort, buf, sizeof( ashort ));
 679             ashort = ntohs( ashort );
 680             buf += 2;
 681
 682             switch ( (unsigned int) achar )
 683               {
 684               case 0x04 :
 685                 fdType = ( u_char *) "TEXT";
 686                 break;
 687
 688               case 0xff :
 689                 fdType = ( u_char *) "PSYS";
 690                 break;
 691
 692               case 0xb3 :
 693                 fdType = ( u_char *) "PS16";
 694                 break;
 695
 696               case 0x00 :
 697                 fdType = ( u_char *) "BINA";
 698                 break;
 699
 700               default :
 701                 xyy[0] = ( u_char ) 'p';
 702                 xyy[1] = achar;
 703                 xyy[2] = ( u_char ) ( ashort >> 8 ) & 0xff;
 704                 xyy[3] = ( u_char ) ashort & 0xff;
 705                 fdType = xyy;
 706                 break;
 707               }
 708
 709             memcpy(ad_entry( adp, ADEID_FINDERI ), fdType, 4 );
 710             memcpy(ad_entry( adp, ADEID_FINDERI ) + 4, "pdos", 4 );
 711             break;
 712
 713
 714         default :
 715             err = AFPERR_BITMAP;
 716             goto setfilparam_done;
 717         }
 718
 719         bitmap = bitmap>>1;
 720         bit++;
 721     }
 722
 723 setfilparam_done:
 724     if (isad) {
 725       ad_flush( adp, ADFLAGS_HF );
 726       ad_close( adp, ADFLAGS_HF );
 727
 728 #ifdef FORCE_UIDGID
 729         restore_uidgid ( uidgid );
 730 #endif /* FORCE_UIDGID */
 731
 732     }
 733
 734 #ifdef DEBUG
 735     syslog(LOG_INFO, "end setfilparams:");
 736 #endif /* DEBUG */
 737
 738     return err;
 739 }
 740
 741 /*
 742  * renamefile and copyfile take the old and new unix pathnames
 743  * and the new mac name.
 744  * NOTE: if we have to copy a file instead of renaming it, locks
 745  *       will break.
 746  */
 747 int renamefile(src, dst, newname, noadouble )
 748     char        *src, *dst, *newname;
 749     const int         noadouble;
 750 {
 751     struct adouble      ad;
 752     char                adsrc[ MAXPATHLEN + 1];
 753     int                 len, rc;
 754
 755     /*
 756      * Note that this is only checking the existance of the data file,
 757      * not the header file.  The thinking is that if the data file doesn't
 758      * exist, but the header file does, the right thing to do is remove
 759      * the data file silently.
 760      */
 761
 762     /* existence check moved to afp_moveandrename */
 763
 764 #ifdef DEBUG
 765     syslog (LOG_INFO, "begin renamefile:");
 766 #endif /* DEBUG */
 767
 768     if ( rename( src, dst ) < 0 ) {
 769         switch ( errno ) {
 770         case ENOENT :
 771             return( AFPERR_NOOBJ );
 772         case EPERM:
 773         case EACCES :
 774             return( AFPERR_ACCESS );
 775         case EROFS:
 776             return AFPERR_VLOCK;
 777         case EXDEV :                    /* Cross device move -- try copy */
 778             if (( rc = copyfile(src, dst, newname, noadouble )) != AFP_OK ) {
 779                 deletefile( dst );
 780                 return( rc );
 781             }
 782             return deletefile( src );
 783         default :
 784             return( AFPERR_PARAM );
 785         }
 786     }
 787
 788     strcpy( adsrc, ad_path( src, 0 ));
 789     rc = 0;
 790 rename_retry:
 791     if (rename( adsrc, ad_path( dst, 0 )) < 0 ) {
 792         struct stat st;
 793
 794         switch ( errno ) {
 795         case ENOENT :
 796           /* check for a source appledouble header. if it exists, make
 797            * a dest appledouble directory and do the rename again. */
 798           memset(&ad, 0, sizeof(ad));
 799           if (rc || stat(adsrc, &st) ||
 800               (ad_open(dst, ADFLAGS_HF, O_RDWR | O_CREAT, 0666, &ad) < 0))
 801             return AFP_OK;
 802           rc++;
 803           ad_close(&ad, ADFLAGS_HF);
 804           goto rename_retry;
 805         case EPERM:
 806         case EACCES :
 807             return( AFPERR_ACCESS );
 808         case EROFS:
 809             return AFPERR_VLOCK;
 810         default :
 811             return( AFPERR_PARAM );
 812         }
 813     }
 814
 815     memset(&ad, 0, sizeof(ad));
 816     if ( ad_open( dst, ADFLAGS_HF, O_RDWR, 0666, &ad) < 0 ) {
 817         switch ( errno ) {
 818         case ENOENT :
 819             return( AFPERR_NOOBJ );
 820         case EACCES :
 821             return( AFPERR_ACCESS );
 822         case EROFS:
 823             return AFPERR_VLOCK;
 824         default :
 825             return( AFPERR_PARAM );
 826         }
 827     }
 828
 829     len = strlen( newname );
 830     ad_setentrylen( &ad, ADEID_NAME, len );
 831     memcpy(ad_entry( &ad, ADEID_NAME ), newname, len );
 832     ad_flush( &ad, ADFLAGS_HF );
 833     ad_close( &ad, ADFLAGS_HF );
 834
 835 #ifdef DEBUG
 836     syslog (LOG_INFO, "end renamefile:");
 837 #endif /* DEBUG */
 838
 839     return( AFP_OK );
 840 }
 841
 842 int afp_copyfile(obj, ibuf, ibuflen, rbuf, rbuflen )
 843     AFPObj      *obj;
 844     char        *ibuf, *rbuf;
 845     int         ibuflen, *rbuflen;
 846 {
 847     struct vol  *vol;
 848     struct dir  *dir;
 849     char        *newname, *path, *p;
 850     u_int32_t   sdid, ddid;
 851     int         plen, err, retvalue = AFP_OK;
 852     u_int16_t   svid, dvid;
 853
 854 #ifdef DEBUG
 855     syslog (LOG_INFO, "begin afp_copyfile:");
 856 #endif /* DEBUG */
 857
 858     *rbuflen = 0;
 859     ibuf += 2;
 860
 861     memcpy(&svid, ibuf, sizeof( svid ));
 862     ibuf += sizeof( svid );
 863     if (( vol = getvolbyvid( svid )) == NULL ) {
 864         return( AFPERR_PARAM );
 865     }
 866
 867     memcpy(&sdid, ibuf, sizeof( sdid ));
 868     ibuf += sizeof( sdid );
 869     if (( dir = dirsearch( vol, sdid )) == NULL ) {
 870         return( AFPERR_PARAM );
 871     }
 872
 873     memcpy(&dvid, ibuf, sizeof( dvid ));
 874     ibuf += sizeof( dvid );
 875     memcpy(&ddid, ibuf, sizeof( ddid ));
 876     ibuf += sizeof( ddid );
 877
 878     if (( path = cname( vol, dir, &ibuf )) == NULL ) {
 879         return( AFPERR_NOOBJ );
 880     }
 881     if ( *path == '\0' ) {
 882         return( AFPERR_BADTYPE );
 883     }
 884
 885     /* don't allow copies when the file is open.
 886      * XXX: the spec only calls for read/deny write access.
 887      *      however, copyfile doesn't have any of that info,
 888      *      and locks need to stay coherent. as a result,
 889      *      we just balk if the file is opened already. */
 890     if (of_findname(vol, curdir, path))
 891       return AFPERR_DENYCONF;
 892
 893     newname = obj->newtmp;
 894     strcpy( newname, path );
 895
 896     p = ctoupath( vol, curdir, newname );
 897
 898     if (( vol = getvolbyvid( dvid )) == NULL ) {
 899         return( AFPERR_PARAM );
 900     }
 901
 902     if (vol->v_flags & AFPVOL_RO)
 903         return AFPERR_VLOCK;
 904
 905     if (( dir = dirsearch( vol, ddid )) == NULL ) {
 906         return( AFPERR_PARAM );
 907     }
 908
 909     if (( path = cname( vol, dir, &ibuf )) == NULL ) {
 910         return( AFPERR_NOOBJ );
 911     }
 912     if ( *path != '\0' ) {
 913         return( AFPERR_BADTYPE );
 914     }
 915
 916     /* one of the handful of places that knows about the path type */
 917     if ( *ibuf++ != 2 ) {
 918         return( AFPERR_PARAM );
 919     }
 920     if (( plen = (unsigned char)*ibuf++ ) != 0 ) {
 921         strncpy( newname, ibuf, plen );
 922         newname[ plen ] = '\0';
 923     }
 924
 925     if ( (err = copyfile(p, mtoupath(vol, newname ), newname,
 926                   vol_noadouble(vol))) < 0 ) {
 927         return err;
 928     }
 929
 930     setvoltime(obj, vol );
 931
 932 #ifdef DROPKLUDGE
 933     if (vol->v_flags & AFPVOL_DROPBOX) {
 934          retvalue=matchfile2dirperms(newname, vol, sdid);
 935     }
 936 #endif /* DROPKLUDGE */
 937
 938 #ifdef DEBUG
 939     syslog (LOG_INFO, "end afp_copyfile:");
 940 #endif /* DEBUG */
 941
 942     return( retvalue );
 943 }
 944
 945
 946 static __inline__ int copy_all(const int dfd, const void *buf,
 947                                size_t buflen)
 948 {
 949   ssize_t cc;
 950
 951 #ifdef DEBUG
 952   syslog(LOG_INFO, "begin copy_all:");
 953 #endif /* DEBUG */
 954
 955   while (buflen > 0) {
 956     if ((cc = write(dfd, buf, buflen)) < 0) {
 957       switch (errno) {
 958       case EINTR:
 959         continue;
 960       case EDQUOT:
 961       case EFBIG:
 962       case ENOSPC:
 963         return AFPERR_DFULL;
 964       case EROFS:
 965         return AFPERR_VLOCK;
 966       default:
 967         return AFPERR_PARAM;
 968       }
 969     }
 970     buflen -= cc;
 971   }
 972
 973 #ifdef DEBUG
 974   syslog(LOG_INFO, "end copy_all:");
 975 #endif /* DEBUG */
 976
 977   return AFP_OK;
 978 }
 979
 980 /* XXX: this needs to use ad_open and ad_lock. so, we need to
 981  * pass in vol and path */
 982 int copyfile(src, dst, newname, noadouble )
 983     char        *src, *dst, *newname;
 984     const int   noadouble;
 985 {
 986     struct adouble      ad;
 987     struct stat         st;
 988     char                filebuf[8192];
 989     int                 sfd, dfd, len, err = AFP_OK;
 990     ssize_t             cc;
 991
 992 #ifdef DEBUG
 993     syslog(LOG_INFO, "begin copyfile:");
 994 #endif /* DEBUG */
 995
 996     if (newname) {
 997       if ((sfd = open( ad_path( src, ADFLAGS_HF ), O_RDONLY, 0 )) < 0 ) {
 998         switch ( errno ) {
 999         case ENOENT :
1000             break; /* just copy the data fork */
1001         case EACCES :
1002             return( AFPERR_ACCESS );
1003         default :
1004             return( AFPERR_PARAM );
1005         }
1006       } else {
1007         if (( dfd = open( ad_path( dst, ADFLAGS_HF ), O_WRONLY|O_CREAT,
1008                 ad_mode( ad_path( dst, ADFLAGS_HF ), 0666 ))) < 0 ) {
1009             close( sfd );
1010             switch ( errno ) {
1011             case ENOENT :
1012                 return( AFPERR_NOOBJ );
1013             case EACCES :
1014                 return( AFPERR_ACCESS );
1015             case EROFS:
1016                 return AFPERR_VLOCK;
1017             default :
1018                 return( AFPERR_PARAM );
1019             }
1020         }
1021
1022         /* copy the file */
1023 #ifdef SENDFILE_FLAVOR_LINUX
1024         if (fstat(sfd, &st) == 0) {
1025           if ((cc = sendfile(dfd, sfd, NULL, st.st_size)) < 0) {
1026             switch (errno) {
1027             case EDQUOT:
1028             case EFBIG:
1029             case ENOSPC:
1030               err = AFPERR_DFULL;
1031               break;
1032             case EROFS:
1033               err = AFPERR_VLOCK;
1034               break;
1035             default:
1036               err = AFPERR_PARAM;
1037             }
1038           }
1039           goto copyheader_done;
1040         }
1041 #endif /* SENDFILE_FLAVOR_LINUX */
1042         while (1) {
1043           if ((cc = read(sfd, filebuf, sizeof(filebuf))) < 0) {
1044             if (errno == EINTR)
1045               continue;
1046             err = AFPERR_PARAM;
1047             break;
1048           }
1049
1050           if (!cc || ((err = copy_all(dfd, filebuf, cc)) < 0))
1051             break;
1052         }
1053
1054 copyheader_done:
1055         close(sfd);
1056         close(dfd);
1057         if (err < 0) {
1058           unlink(ad_path(dst, ADFLAGS_HF));
1059           return err;
1060         }
1061       }
1062     }
1063
1064     /* data fork copying */
1065     if (( sfd = open( src, O_RDONLY, 0 )) < 0 ) {
1066         switch ( errno ) {
1067         case ENOENT :
1068             return( AFPERR_NOOBJ );
1069         case EACCES :
1070             return( AFPERR_ACCESS );
1071         default :
1072             return( AFPERR_PARAM );
1073         }
1074     }
1075
1076     if (( dfd = open( dst, O_WRONLY|O_CREAT, ad_mode( dst, 0666 ))) < 0 ) {
1077         close( sfd );
1078         switch ( errno ) {
1079         case ENOENT :
1080             return( AFPERR_NOOBJ );
1081         case EACCES :
1082             return( AFPERR_ACCESS );
1083         case EROFS:
1084             return AFPERR_VLOCK;
1085         default :
1086             return( AFPERR_PARAM );
1087         }
1088     }
1089
1090 #ifdef SENDFILE_FLAVOR_LINUX
1091     if (fstat(sfd, &st) == 0) {
1092       if ((cc = sendfile(dfd, sfd, NULL, st.st_size)) < 0) {
1093         switch (errno) {
1094         case EDQUOT:
1095         case EFBIG:
1096         case ENOSPC:
1097           err = AFPERR_DFULL;
1098           break;
1099         default:
1100           err = AFPERR_PARAM;
1101         }
1102       }
1103       goto copydata_done;
1104     }
1105 #endif /* SENDFILE_FLAVOR_LINUX */
1106
1107     while (1) {
1108       if ((cc = read( sfd, filebuf, sizeof( filebuf ))) < 0) {
1109         if (errno == EINTR)
1110           continue;
1111
1112         err = AFPERR_PARAM;
1113         break;
1114       }
1115
1116       if (!cc || ((err = copy_all(dfd, filebuf, cc)) < 0)) {
1117         break;
1118       }
1119     }
1120
1121 copydata_done:
1122     close(sfd);
1123     close(dfd);
1124     if (err < 0) {
1125       unlink(ad_path(dst, ADFLAGS_HF));
1126       unlink(dst);
1127       return err;
1128     }
1129
1130     if (newname) {
1131       memset(&ad, 0, sizeof(ad));
1132       if ( ad_open( dst, noadouble | ADFLAGS_HF, O_RDWR|O_CREAT,
1133                     0666, &ad) < 0 ) {
1134         switch ( errno ) {
1135         case ENOENT :
1136           return noadouble ? AFP_OK : AFPERR_NOOBJ;
1137         case EACCES :
1138           return( AFPERR_ACCESS );
1139         case EROFS:
1140           return AFPERR_VLOCK;
1141         default :
1142           return( AFPERR_PARAM );
1143         }
1144       }
1145
1146       len = strlen( newname );
1147       ad_setentrylen( &ad, ADEID_NAME, len );
1148       memcpy(ad_entry( &ad, ADEID_NAME ), newname, len );
1149       ad_flush( &ad, ADFLAGS_HF );
1150       ad_close( &ad, ADFLAGS_HF );
1151     }
1152
1153 #ifdef DEBUG
1154     syslog(LOG_INFO, "end copyfile:");
1155 #endif /* DEBUG */
1156
1157     return( AFP_OK );
1158 }
1159
1160
1161 int deletefile( file )
1162     char                *file;
1163 {
1164     struct adouble      ad;
1165     int                 adflags, err = AFP_OK;
1166     int                 locktype = ADLOCK_WR;
1167     int                 openmode = O_RDWR;
1168
1169 #ifdef DEBUG
1170     syslog(LOG_INFO, "begin deletefile:");
1171 #endif /* DEBUG */
1172
1173     while(1) {
1174         /*
1175          * If can't open read/write then try again read-only.  If it's open
1176          * read-only, we must do a read lock instead of a write lock.
1177          */
1178         /* try to open both at once */
1179         adflags = ADFLAGS_DF|ADFLAGS_HF;
1180         memset(&ad, 0, sizeof(ad));
1181         if ( ad_open( file, adflags, openmode, 0, &ad ) < 0 ) {
1182               switch (errno) {
1183               case ENOENT:
1184                 adflags = ADFLAGS_DF;
1185                 /* that failed. now try to open just the data fork */
1186                 memset(&ad, 0, sizeof(ad));
1187                 if ( ad_open( file, adflags, openmode, 0, &ad ) < 0 ) {
1188                   switch (errno) {
1189                   case ENOENT:
1190                     return AFPERR_NOOBJ;
1191                   case EACCES:
1192                     if(openmode == O_RDWR) {
1193                         openmode = O_RDONLY;
1194                         locktype = ADLOCK_RD;
1195                         continue;
1196                     } else {
1197                         return AFPERR_ACCESS;
1198                     }
1199                   case EROFS:
1200                     return AFPERR_VLOCK;
1201                   default:
1202                     return AFPERR_PARAM;
1203                   }
1204                 }
1205                 break;
1206
1207               case EACCES:
1208                 if(openmode == O_RDWR) {
1209                     openmode = O_RDONLY;
1210                     locktype = ADLOCK_RD;
1211                     continue;
1212                 } else {
1213                     return AFPERR_ACCESS;
1214                 }
1215               case EROFS:
1216                 return AFPERR_VLOCK;
1217               default:
1218                 return( AFPERR_PARAM );
1219               }
1220         }
1221         break;  /* from the while */
1222     }
1223
1224     if ((adflags & ADFLAGS_HF) &&
1225         (ad_tmplock(&ad, ADEID_RFORK, locktype, 0, 0) < 0 )) {
1226       ad_close( &ad, adflags );
1227       return( AFPERR_BUSY );
1228     }
1229
1230     if (ad_tmplock( &ad, ADEID_DFORK, locktype, 0, 0 ) < 0) {
1231       err = AFPERR_BUSY;
1232       goto delete_unlock;
1233     }
1234
1235     if ( unlink( ad_path( file, ADFLAGS_HF )) < 0 ) {
1236         switch ( errno ) {
1237         case EPERM:
1238         case EACCES :
1239             err = AFPERR_ACCESS;
1240             goto delete_unlock;
1241         case EROFS:
1242             err = AFPERR_VLOCK;
1243             goto delete_unlock;
1244         case ENOENT :
1245             break;
1246         default :
1247             err = AFPERR_PARAM;
1248             goto delete_unlock;
1249         }
1250     }
1251
1252     if ( unlink( file ) < 0 ) {
1253         switch ( errno ) {
1254         case EPERM:
1255         case EACCES :
1256             err = AFPERR_ACCESS;
1257             break;
1258         case EROFS:
1259             err = AFPERR_VLOCK;
1260             break;
1261         case ENOENT :
1262             break;
1263         default :
1264             err = AFPERR_PARAM;
1265             break;
1266         }
1267     }
1268
1269 delete_unlock:
1270     if (adflags & ADFLAGS_HF)
1271       ad_tmplock(&ad, ADEID_RFORK, ADLOCK_CLR, 0, 0);
1272     ad_tmplock(&ad, ADEID_DFORK, ADLOCK_CLR, 0, 0);
1273     ad_close( &ad, adflags );
1274
1275 #ifdef DEBUG
1276     syslog(LOG_INFO, "end deletefile:");
1277 #endif /* DEBUG */
1278
1279     return err;
1280 }
1281
1282
1283 #ifdef CNID_DB
1284 /* return a file id */
1285 int afp_createid(obj, ibuf, ibuflen, rbuf, rbuflen )
1286     AFPObj      *obj;
1287     char        *ibuf, *rbuf;
1288     int         ibuflen, *rbuflen;
1289 {
1290     struct stat         st;
1291     struct adouble      ad;
1292     struct vol          *vol;
1293     struct dir          *dir;
1294     char                *path, *upath;
1295     int                 len;
1296     cnid_t              did, id;
1297     u_short             vid;
1298
1299 #ifdef DEBUG
1300     syslog(LOG_INFO, "begin afp_createid:");
1301 #endif /* DEBUG */
1302
1303     *rbuflen = 0;
1304     ibuf += 2;
1305
1306     memcpy(&vid, ibuf, sizeof(vid));
1307     ibuf += sizeof(vid);
1308
1309     if (( vol = getvolbyvid( vid )) == NULL ) {
1310         return( AFPERR_PARAM);
1311     }
1312
1313     if (vol->v_flags & AFPVOL_RO)
1314         return AFPERR_VLOCK;
1315
1316     memcpy(&did, ibuf, sizeof( did ));
1317     ibuf += sizeof(did);
1318
1319     if (( dir = dirsearch( vol, did )) == NULL ) {
1320         return( AFPERR_PARAM );
1321     }
1322
1323     if (( path = cname( vol, dir, &ibuf )) == NULL ) {
1324         return( AFPERR_PARAM );
1325     }
1326
1327     if ( *path == '\0' ) {
1328         return( AFPERR_BADTYPE );
1329     }
1330
1331     upath = mtoupath(vol, path);
1332     if (stat(upath, &st) < 0) {
1333       switch (errno) {
1334       case EPERM:
1335       case EACCES:
1336         return AFPERR_ACCESS;
1337       case ENOENT:
1338         return AFPERR_NOOBJ;
1339       default:
1340         return AFPERR_PARAM;
1341       }
1342     }
1343
1344     if (id = cnid_lookup(vol->v_db, &st, did, upath, len = strlen(upath))) {
1345       memcpy(rbuf, &id, sizeof(id));
1346       *rbuflen = sizeof(id);
1347       return AFPERR_EXISTID;
1348     }
1349
1350 #if AD_VERSION > AD_VERSION1
1351     memset(&ad, 0, sizeof(ad));
1352     if (ad_open( upath, ADFLAGS_HF, O_RDONLY, 0, &ad ) >= 0) {
1353       memcpy(&id, ad_entry(&ad, ADEID_DID), sizeof(id));
1354       ad_close(&ad, ADFLAGS_HF);
1355     }
1356 #endif /* AD_VERSION > AD_VERSION1 */
1357
1358     if (id = cnid_add(vol->v_db, &st, did, upath, len, id)) {
1359       memcpy(rbuf, &id, sizeof(id));
1360       *rbuflen = sizeof(id);
1361       return AFP_OK;
1362     }
1363
1364 #ifdef DEBUG
1365     syslog(LOG_INFO, "ending afp_createid...:");
1366 #endif /* DEBUG */
1367
1368     switch (errno) {
1369     case EROFS:
1370       return AFPERR_VLOCK;
1371       break;
1372     case EPERM:
1373     case EACCES:
1374       return AFPERR_ACCESS;
1375       break;
1376     default:
1377       syslog(LOG_ERR, "afp_createid: cnid_add: %m");
1378       return AFPERR_PARAM;
1379     }
1380 }
1381
1382 /* resolve a file id */
1383 int afp_resolveid(obj, ibuf, ibuflen, rbuf, rbuflen )
1384     AFPObj      *obj;
1385     char        *ibuf, *rbuf;
1386     int         ibuflen, *rbuflen;
1387 {
1388     struct stat         st;
1389     struct vol          *vol;
1390     struct dir          *dir;
1391     char                *upath;
1392     int                 err, buflen;
1393     cnid_t              id;
1394     u_int16_t           vid, bitmap;
1395
1396 #ifdef DEBUG
1397     syslog(LOG_INFO, "begin afp_resolveid:");
1398 #endif /* DEBUG */
1399
1400     *rbuflen = 0;
1401     ibuf += 2;
1402
1403     memcpy(&vid, ibuf, sizeof(vid));
1404     ibuf += sizeof(vid);
1405
1406     if (( vol = getvolbyvid( vid )) == NULL ) {
1407         return( AFPERR_PARAM);
1408     }
1409
1410     memcpy(&id, ibuf, sizeof( id ));
1411     ibuf += sizeof(id);
1412
1413     if ((upath = cnid_resolve(vol->v_db, &id)) == NULL) {
1414       return AFPERR_BADID;
1415     }
1416
1417     if (( dir = dirsearch( vol, id )) == NULL ) {
1418       return( AFPERR_PARAM );
1419     }
1420
1421     if ((movecwd(vol, dir) < 0) || (stat(upath, &st) < 0)) {
1422       switch (errno) {
1423       case EACCES:
1424       case EPERM:
1425         return AFPERR_ACCESS;
1426       case ENOENT:
1427         return AFPERR_NOID;
1428       default:
1429         return AFPERR_PARAM;
1430       }
1431     }
1432
1433     /* directories are bad */
1434     if (S_ISDIR(st.st_mode))
1435       return AFPERR_BADTYPE;
1436
1437     memcpy(&bitmap, ibuf, sizeof(bitmap));
1438     bitmap = ntohs( bitmap );
1439
1440     if ((err = getfilparams(vol, bitmap, utompath(vol, upath), curdir, &st,
1441                            rbuf + sizeof(bitmap), &buflen)) != AFP_OK)
1442       return err;
1443
1444     *rbuflen = buflen + sizeof(bitmap);
1445     memcpy(rbuf, ibuf, sizeof(bitmap));
1446
1447 #ifdef DEBUG
1448     syslog(LOG_INFO, "end afp_resolveid:");
1449 #endif /* DEBUG */
1450
1451     return AFP_OK;
1452 }
1453
1454 int afp_deleteid(obj, ibuf, ibuflen, rbuf, rbuflen )
1455     AFPObj      *obj;
1456     char        *ibuf, *rbuf;
1457     int         ibuflen, *rbuflen;
1458 {
1459     struct stat         st;
1460     struct vol          *vol;
1461     struct dir          *dir;
1462     char                *upath;
1463     int                 err;
1464     cnid_t              id;
1465     u_short             vid;
1466
1467 #ifdef DEBUG
1468     syslog(LOG_INFO, "begin afp_deleteid:");
1469 #endif /* DEBUG */
1470
1471     *rbuflen = 0;
1472     ibuf += 2;
1473
1474     memcpy(&vid, ibuf, sizeof(vid));
1475     ibuf += sizeof(vid);
1476
1477     if (( vol = getvolbyvid( vid )) == NULL ) {
1478         return( AFPERR_PARAM);
1479     }
1480
1481     if (vol->v_flags & AFPVOL_RO)
1482         return AFPERR_VLOCK;
1483
1484     memcpy(&id, ibuf, sizeof( id ));
1485     ibuf += sizeof(id);
1486
1487     if ((upath = cnid_resolve(vol->v_db, &id)) == NULL) {
1488       return AFPERR_NOID;
1489     }
1490
1491     if (( dir = dirsearch( vol, id )) == NULL ) {
1492       return( AFPERR_PARAM );
1493     }
1494
1495     err = AFP_OK;
1496     if ((movecwd(vol, dir) < 0) || (stat(upath, &st) < 0)) {
1497       switch (errno) {
1498       case EACCES:
1499       case EPERM:
1500         return AFPERR_ACCESS;
1501       case ENOENT:
1502         /* still try to delete the id */
1503         err = AFPERR_NOOBJ;
1504         break;
1505       default:
1506         return AFPERR_PARAM;
1507       }
1508     }
1509
1510     /* directories are bad */
1511     if (S_ISDIR(st.st_mode))
1512       return AFPERR_BADTYPE;
1513
1514     if (cnid_delete(vol->v_db, id)) {
1515       switch (errno) {
1516       case EROFS:
1517         return AFPERR_VLOCK;
1518       case EPERM:
1519       case EACCES:
1520         return AFPERR_ACCESS;
1521       default:
1522         return AFPERR_PARAM;
1523       }
1524     }
1525
1526 #ifdef DEBUG
1527     syslog(LOG_INFO, "end afp_deleteid:");
1528 #endif /* DEBUG */
1529
1530     return err;
1531 }
1532 #endif /* CNID_DB */
1533
1534 #define APPLETEMP ".AppleTempXXXXXX"
1535
1536 int afp_exchangefiles(obj, ibuf, ibuflen, rbuf, rbuflen )
1537     AFPObj      *obj;
1538     char        *ibuf, *rbuf;
1539     int         ibuflen, *rbuflen;
1540 {
1541     struct stat         srcst, destst;
1542     struct vol          *vol;
1543     struct dir          *dir, *sdir;
1544     char                *spath, temp[17], *path, *p;
1545     char                *supath, *upath;
1546     int                 err;
1547 #ifdef CNID_DB
1548     int                 slen, dlen;
1549 #endif /* CNID_DB */
1550     u_int32_t           sid, did;
1551     u_int16_t           vid;
1552
1553 #ifdef DEBUG
1554     syslog(LOG_INFO, "begin afp_exchangefiles:");
1555 #endif /* DEBUG */
1556
1557     *rbuflen = 0;
1558     ibuf += 2;
1559
1560     memcpy(&vid, ibuf, sizeof(vid));
1561     ibuf += sizeof(vid);
1562
1563     if (( vol = getvolbyvid( vid )) == NULL ) {
1564         return( AFPERR_PARAM);
1565     }
1566
1567     if (vol->v_flags & AFPVOL_RO)
1568         return AFPERR_VLOCK;
1569
1570     /* source and destination dids */
1571     memcpy(&sid, ibuf, sizeof(sid));
1572     ibuf += sizeof(sid);
1573     memcpy(&did, ibuf, sizeof(did));
1574     ibuf += sizeof(did);
1575
1576     /* source file */
1577     if ((dir = dirsearch( vol, sid )) == NULL ) {
1578         return( AFPERR_PARAM );
1579     }
1580
1581     if (( path = cname( vol, dir, &ibuf )) == NULL ) {
1582         return( AFPERR_PARAM );
1583     }
1584
1585     if ( *path == '\0' ) {
1586         return( AFPERR_BADTYPE );
1587     }
1588
1589     upath = mtoupath(vol, path);
1590     if (stat(upath, &srcst) < 0) {
1591       switch (errno) {
1592       case ENOENT:
1593         return AFPERR_NOID;
1594       case EPERM:
1595       case EACCES:
1596         return AFPERR_ACCESS;
1597       default:
1598         return AFPERR_PARAM;
1599       }
1600     }
1601
1602     /* save some stuff */
1603     sdir = curdir;
1604     spath = obj->oldtmp;
1605     supath = obj->newtmp;
1606     strcpy(spath, path);
1607     strcpy(supath, upath); /* this is for the cnid changing */
1608     p = ctoupath( vol, sdir, spath);
1609
1610     /* look for the source cnid. if it doesn't exist, don't worry about
1611      * it. */
1612 #ifdef CNID_DB
1613     sid = cnid_lookup(vol->v_db, &srcst, sdir->d_did, supath,
1614                       slen = strlen(supath));
1615 #endif /* CNID_DB */
1616
1617     if (( dir = dirsearch( vol, did )) == NULL ) {
1618         return( AFPERR_PARAM );
1619     }
1620
1621     if (( path = cname( vol, dir, &ibuf )) == NULL ) {
1622         return( AFPERR_PARAM );
1623     }
1624
1625     if ( *path == '\0' ) {
1626         return( AFPERR_BADTYPE );
1627     }
1628
1629     /* FPExchangeFiles is the only call that can return the SameObj
1630      * error */
1631     if ((curdir == sdir) && strcmp(spath, path) == 0)
1632       return AFPERR_SAMEOBJ;
1633
1634     upath = mtoupath(vol, path);
1635     if (stat(upath, &destst) < 0) {
1636       switch (errno) {
1637       case ENOENT:
1638         return AFPERR_NOID;
1639       case EPERM:
1640       case EACCES:
1641         return AFPERR_ACCESS;
1642       default:
1643         return AFPERR_PARAM;
1644       }
1645     }
1646
1647 #ifdef CNID_DB
1648     /* look for destination id. */
1649     did = cnid_lookup(vol->v_db, &destst, curdir->d_did, upath,
1650                       dlen = strlen(upath));
1651 #endif /* CNID_DB */
1652
1653     /* construct a temp name.
1654      * NOTE: the temp file will be in the dest file's directory. it
1655      * will also be inaccessible from AFP. */
1656     memcpy(temp, APPLETEMP, sizeof(APPLETEMP));
1657     if (!mktemp(temp))
1658       return AFPERR_MISC;
1659
1660     /* now, quickly rename the file. we error if we can't. */
1661     if ((err = renamefile(p, temp, temp, vol_noadouble(vol))) < 0)
1662       goto err_exchangefile;
1663     of_rename(vol, sdir, spath, curdir, temp);
1664
1665     /* rename destination to source */
1666     if ((err = renamefile(path, p, spath, vol_noadouble(vol))) < 0)
1667       goto err_src_to_tmp;
1668     of_rename(vol, curdir, path, sdir, spath);
1669
1670     /* rename temp to destination */
1671     if ((err = renamefile(temp, upath, path, vol_noadouble(vol))) < 0)
1672       goto err_dest_to_src;
1673     of_rename(vol, curdir, temp, curdir, path);
1674
1675 #ifdef CNID_DB
1676     /* id's need switching. src -> dest and dest -> src. */
1677     if (sid && (cnid_update(vol->v_db, sid, &destst, curdir->d_did,
1678                             upath, dlen) < 0)) {
1679       switch (errno) {
1680       case EPERM:
1681       case EACCES:
1682         err = AFPERR_ACCESS;
1683       default:
1684         err = AFPERR_PARAM;
1685       }
1686       goto err_temp_to_dest;
1687     }
1688
1689     if (did && (cnid_update(vol->v_db, did, &srcst, sdir->d_did,
1690                             supath, slen) < 0)) {
1691       switch (errno) {
1692       case EPERM:
1693       case EACCES:
1694         err = AFPERR_ACCESS;
1695       default:
1696         err = AFPERR_PARAM;
1697       }
1698
1699       if (sid)
1700         cnid_update(vol->v_db, sid, &srcst, sdir->d_did, supath, slen);
1701       goto err_temp_to_dest;
1702     }
1703 #endif /* CNID_DB */
1704
1705 #ifdef DEBUG
1706     syslog(LOG_INFO, "ending afp_exchangefiles:");
1707 #endif /* DEBUG */
1708
1709     return AFP_OK;
1710
1711
1712     /* all this stuff is so that we can unwind a failed operation
1713      * properly. */
1714 err_temp_to_dest:
1715     /* rename dest to temp */
1716     renamefile(upath, temp, temp, vol_noadouble(vol));
1717     of_rename(vol, curdir, upath, curdir, temp);
1718
1719 err_dest_to_src:
1720     /* rename source back to dest */
1721     renamefile(p, upath, path, vol_noadouble(vol));
1722     of_rename(vol, sdir, spath, curdir, path);
1723
1724 err_src_to_tmp:
1725     /* rename temp back to source */
1726     renamefile(temp, p, spath, vol_noadouble(vol));
1727     of_rename(vol, curdir, temp, sdir, spath);
1728
1729 err_exchangefile:
1730     return err;
1731 }