etc/afpd/fork.c

   1 /*
   2  * Copyright (c) 1990,1993 Regents of The University of Michigan.
   3  * Copyright (c) 2010      Frank Lahm
   4  *
   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 <string.h>
  14 #include <errno.h>
  15 #include <sys/param.h>
  16 #include <sys/socket.h>
  17 #include <inttypes.h>
  18
  19 #include <atalk/dsi.h>
  20 #include <atalk/afp.h>
  21 #include <atalk/adouble.h>
  22 #include <atalk/logger.h>
  23 #include <atalk/util.h>
  24 #include <atalk/cnid.h>
  25 #include <atalk/bstradd.h>
  26 #include <atalk/globals.h>
  27 #include <atalk/netatalk_conf.h>
  28 #include <atalk/ea.h>
  29
  30 #include "fork.h"
  31 #include "file.h"
  32 #include "directory.h"
  33 #include "desktop.h"
  34 #include "volume.h"
  35
  36 #ifdef AFS
  37 struct ofork *writtenfork;
  38 #endif
  39
  40 static int getforkparams(const AFPObj *obj, struct ofork *ofork, uint16_t bitmap, char *buf, size_t *buflen)
  41 {
  42     struct path         path;
  43     struct stat     *st;
  44
  45     struct adouble  *adp;
  46     struct dir      *dir;
  47     struct vol      *vol;
  48
  49
  50     /* can only get the length of the opened fork */
  51     if ( ( (bitmap & ((1<<FILPBIT_DFLEN) | (1<<FILPBIT_EXTDFLEN)))
  52            && (ofork->of_flags & AFPFORK_RSRC))
  53          ||
  54          ( (bitmap & ((1<<FILPBIT_RFLEN) | (1<<FILPBIT_EXTRFLEN)))
  55            && (ofork->of_flags & AFPFORK_DATA))) {
  56         return( AFPERR_BITMAP );
  57     }
  58
  59     if (! AD_META_OPEN(ofork->of_ad)) {
  60         adp = NULL;
  61     } else {
  62         adp = ofork->of_ad;
  63     }
  64
  65     vol = ofork->of_vol;
  66     dir = dirlookup(vol, ofork->of_did);
  67
  68     if (NULL == (path.m_name = utompath(vol, of_name(ofork), dir->d_did, utf8_encoding(obj)))) {
  69         return( AFPERR_MISC );
  70     }
  71     path.u_name = of_name(ofork);
  72     path.id = 0;
  73     st = &path.st;
  74     if ( bitmap & ( (1<<FILPBIT_DFLEN) | (1<<FILPBIT_EXTDFLEN) |
  75                     (1<<FILPBIT_FNUM) | (1 << FILPBIT_CDATE) |
  76                     (1 << FILPBIT_MDATE) | (1 << FILPBIT_BDATE))) {
  77         if ( ad_data_fileno( ofork->of_ad ) <= 0 ) {
  78             /* 0 is for symlink */
  79             if (movecwd(vol, dir) < 0)
  80                 return( AFPERR_NOOBJ );
  81             if ( lstat( path.u_name, st ) < 0 )
  82                 return( AFPERR_NOOBJ );
  83         } else {
  84             if ( fstat( ad_data_fileno( ofork->of_ad ), st ) < 0 ) {
  85                 return( AFPERR_BITMAP );
  86             }
  87         }
  88     }
  89     return getmetadata(obj, vol, bitmap, &path, dir, buf, buflen, adp );
  90 }
  91
  92 static off_t get_off_t(char **ibuf, int is64)
  93 {
  94     uint32_t             temp;
  95     off_t                 ret;
  96
  97     ret = 0;
  98     memcpy(&temp, *ibuf, sizeof( temp ));
  99     ret = ntohl(temp); /* ntohl is unsigned */
 100     *ibuf += sizeof(temp);
 101
 102     if (is64) {
 103         memcpy(&temp, *ibuf, sizeof( temp ));
 104         *ibuf += sizeof(temp);
 105         ret = ntohl(temp)| (ret << 32);
 106     }
 107     else {
 108         ret = (int)ret; /* sign extend */
 109     }
 110     return ret;
 111 }
 112
 113 static int set_off_t(off_t offset, char *rbuf, int is64)
 114 {
 115     uint32_t  temp;
 116     int        ret;
 117
 118     ret = 0;
 119     if (is64) {
 120         temp = htonl(offset >> 32);
 121         memcpy(rbuf, &temp, sizeof( temp ));
 122         rbuf += sizeof(temp);
 123         ret = sizeof( temp );
 124         offset &= 0xffffffff;
 125     }
 126     temp = htonl(offset);
 127     memcpy(rbuf, &temp, sizeof( temp ));
 128     ret += sizeof( temp );
 129
 130     return ret;
 131 }
 132
 133 static int is_neg(int is64, off_t val)
 134 {
 135     if (val < 0 || (sizeof(off_t) == 8 && !is64 && (val & 0x80000000U)))
 136         return 1;
 137     return 0;
 138 }
 139
 140 static int sum_neg(int is64, off_t offset, off_t reqcount)
 141 {
 142     if (is_neg(is64, offset +reqcount) )
 143         return 1;
 144     return 0;
 145 }
 146
 147 static int fork_setmode(const AFPObj *obj, struct adouble *adp, int eid, int access, int ofrefnum)
 148 {
 149     int ret;
 150     int readset;
 151     int writeset;
 152     int denyreadset;
 153     int denywriteset;
 154
 155 #ifdef HAVE_FSHARE_T
 156     fshare_t shmd;
 157
 158     if (obj->options.flags & OPTION_SHARE_RESERV) {
 159         shmd.f_access = (access & OPENACC_RD ? F_RDACC : 0) | (access & OPENACC_WR ? F_WRACC : 0);
 160         if (shmd.f_access == 0)
 161             /* we must give an access mode, otherwise fcntl will complain */
 162             shmd.f_access = F_RDACC;
 163         shmd.f_deny = (access & OPENACC_DRD ? F_RDDNY : F_NODNY) | (access & OPENACC_DWR) ? F_WRDNY : 0;
 164         shmd.f_id = ofrefnum;
 165
 166         int fd = (eid == ADEID_DFORK) ? ad_data_fileno(adp) : ad_reso_fileno(adp);
 167
 168         if (fd != -1 && fd != -2 && fcntl(fd, F_SHARE, &shmd) != 0) {
 169             LOG(log_debug, logtype_afpd, "fork_setmode: fcntl: %s", strerror(errno));
 170             errno = EACCES;
 171             return -1;
 172         }
 173     }
 174 #endif
 175
 176     if (! (access & (OPENACC_WR | OPENACC_RD | OPENACC_DWR | OPENACC_DRD))) {
 177         return ad_lock(adp, eid, ADLOCK_RD | ADLOCK_FILELOCK, AD_FILELOCK_OPEN_NONE, 1, ofrefnum);
 178     }
 179
 180     if ((access & (OPENACC_RD | OPENACC_DRD))) {
 181         if ((readset = ad_testlock(adp, eid, AD_FILELOCK_OPEN_RD)) <0)
 182             return readset;
 183         if ((denyreadset = ad_testlock(adp, eid, AD_FILELOCK_DENY_RD)) <0)
 184             return denyreadset;
 185
 186         if ((access & OPENACC_RD) && denyreadset) {
 187             errno = EACCES;
 188             return -1;
 189         }
 190         if ((access & OPENACC_DRD) && readset) {
 191             errno = EACCES;
 192             return -1;
 193         }
 194         /* boolean logic is not enough, because getforkmode is not always telling the
 195          * true
 196          */
 197         if ((access & OPENACC_RD)) {
 198             ret = ad_lock(adp, eid, ADLOCK_RD | ADLOCK_FILELOCK, AD_FILELOCK_OPEN_RD, 1, ofrefnum);
 199             if (ret)
 200                 return ret;
 201         }
 202         if ((access & OPENACC_DRD)) {
 203             ret = ad_lock(adp, eid, ADLOCK_RD | ADLOCK_FILELOCK, AD_FILELOCK_DENY_RD, 1, ofrefnum);
 204             if (ret)
 205                 return ret;
 206         }
 207     }
 208     /* ------------same for writing -------------- */
 209     if ((access & (OPENACC_WR | OPENACC_DWR))) {
 210         if ((writeset = ad_testlock(adp, eid, AD_FILELOCK_OPEN_WR)) <0)
 211             return writeset;
 212         if ((denywriteset = ad_testlock(adp, eid, AD_FILELOCK_DENY_WR)) <0)
 213             return denywriteset;
 214
 215         if ((access & OPENACC_WR) && denywriteset) {
 216             errno = EACCES;
 217             return -1;
 218         }
 219         if ((access & OPENACC_DWR) && writeset) {
 220             errno = EACCES;
 221             return -1;
 222         }
 223         if ((access & OPENACC_WR)) {
 224             ret = ad_lock(adp, eid, ADLOCK_RD | ADLOCK_FILELOCK, AD_FILELOCK_OPEN_WR, 1, ofrefnum);
 225             if (ret)
 226                 return ret;
 227         }
 228         if ((access & OPENACC_DWR)) {
 229             ret = ad_lock(adp, eid, ADLOCK_RD | ADLOCK_FILELOCK, AD_FILELOCK_DENY_WR, 1, ofrefnum);
 230             if (ret)
 231                 return ret;
 232         }
 233     }
 234
 235     return 0;
 236 }
 237
 238 /* ----------------------- */
 239 int afp_openfork(AFPObj *obj _U_, char *ibuf, size_t ibuflen _U_, char *rbuf, size_t *rbuflen)
 240 {
 241     struct vol      *vol;
 242     struct dir      *dir;
 243     struct ofork    *ofork, *opened;
 244     struct adouble  *adsame = NULL;
 245     size_t          buflen;
 246     int             ret, adflags, eid;
 247     uint32_t        did;
 248     uint16_t        vid, bitmap, access, ofrefnum;
 249     char            fork, *path, *upath;
 250     struct stat     *st;
 251     uint16_t        bshort;
 252     struct path     *s_path;
 253     struct stat xxx;
 254
 255     ibuf++;
 256     fork = *ibuf++;
 257     memcpy(&vid, ibuf, sizeof( vid ));
 258     ibuf += sizeof(vid);
 259
 260     *rbuflen = 0;
 261     if (NULL == ( vol = getvolbyvid( vid ))) {
 262         return( AFPERR_PARAM );
 263     }
 264
 265     memcpy(&did, ibuf, sizeof( did ));
 266     ibuf += sizeof( int );
 267
 268     if (NULL == ( dir = dirlookup( vol, did ))) {
 269         return afp_errno;
 270     }
 271
 272     memcpy(&bitmap, ibuf, sizeof( bitmap ));
 273     bitmap = ntohs( bitmap );
 274     ibuf += sizeof( bitmap );
 275     memcpy(&access, ibuf, sizeof( access ));
 276     access = ntohs( access );
 277     ibuf += sizeof( access );
 278
 279     if ((vol->v_flags & AFPVOL_RO) && (access & OPENACC_WR)) {
 280         return AFPERR_VLOCK;
 281     }
 282
 283     if (NULL == ( s_path = cname( vol, dir, &ibuf ))) {
 284         return get_afp_errno(AFPERR_PARAM);
 285     }
 286
 287     if (*s_path->m_name == '\0') {
 288         /* it's a dir ! */
 289         return  AFPERR_BADTYPE;
 290     }
 291
 292     /* stat() data fork st is set because it's not a dir */
 293     switch ( s_path->st_errno ) {
 294     case 0:
 295         break;
 296     case ENOENT:
 297         return AFPERR_NOOBJ;
 298     case EACCES:
 299         return (access & OPENACC_WR) ? AFPERR_LOCK : AFPERR_ACCESS;
 300     default:
 301         LOG(log_error, logtype_afpd, "afp_openfork(%s): %s", s_path->m_name, strerror(errno));
 302         return AFPERR_PARAM;
 303     }
 304     /* FIXME should we check it first ? */
 305     upath = s_path->u_name;
 306     if (!vol_unix_priv(vol)) {
 307         if (check_access(obj, vol, upath, access ) < 0) {
 308             return AFPERR_ACCESS;
 309         }
 310     } else {
 311         if (file_access(obj, vol, s_path, access ) < 0) {
 312             return AFPERR_ACCESS;
 313         }
 314     }
 315
 316     st   = &s_path->st;
 317     /* XXX: this probably isn't the best way to do this. the already
 318        open bits should really be set if the fork is opened by any
 319        program, not just this one. however, that's problematic to do
 320        if we can't write lock files somewhere. opened is also passed to
 321        ad_open so that we can keep file locks together.
 322        FIXME: add the fork we are opening?
 323     */
 324     if ((opened = of_findname(s_path))) {
 325         adsame = opened->of_ad;
 326     }
 327
 328     if ( fork == OPENFORK_DATA ) {
 329         eid = ADEID_DFORK;
 330         adflags = ADFLAGS_DF | ADFLAGS_HF | ADFLAGS_NOHF;
 331     } else {
 332         eid = ADEID_RFORK;
 333         adflags = ADFLAGS_RF | ADFLAGS_HF | ADFLAGS_NOHF;
 334         if (!(access & OPENACC_WR))
 335             adflags |= ADFLAGS_NORF;
 336     }
 337
 338     path = s_path->m_name;
 339     if (( ofork = of_alloc(vol, curdir, path, &ofrefnum, eid,
 340                            adsame, st)) == NULL ) {
 341         return( AFPERR_NFILE );
 342     }
 343
 344     LOG(log_debug, logtype_afpd, "afp_openfork(\"%s\", %s, %s)",
 345         fullpathname(s_path->u_name),
 346         (fork == OPENFORK_DATA) ? "data" : "reso",
 347         !(access & OPENACC_WR) ? "O_RDONLY" : "O_RDWR");
 348
 349     ret = AFPERR_NOOBJ;
 350     if (access & OPENACC_WR) {
 351         /* try opening in read-write mode */
 352         if (ad_open(ofork->of_ad, upath,
 353                     adflags | ADFLAGS_RDWR | ADFLAGS_SETSHRMD) < 0) {
 354             switch ( errno ) {
 355             case EROFS:
 356                 ret = AFPERR_VLOCK;
 357             case EACCES:
 358                 goto openfork_err;
 359             case ENOENT:
 360                 if (fork == OPENFORK_DATA) {
 361                     /* try to open only the data fork */
 362                     if (ad_open(ofork->of_ad, upath,
 363                                 ADFLAGS_DF | ADFLAGS_RDWR | ADFLAGS_SETSHRMD) < 0) {
 364                         goto openfork_err;
 365                     }
 366                     adflags = ADFLAGS_DF;
 367                 } else {
 368                     /* here's the deal. we only try to create the resource
 369                      * fork if the user wants to open it for write acess. */
 370                     if (ad_open(ofork->of_ad, upath,
 371                                 adflags | ADFLAGS_RDWR | ADFLAGS_SETSHRMD | ADFLAGS_CREATE, 0666) < 0)
 372                         goto openfork_err;
 373                     ofork->of_flags |= AFPFORK_META;
 374                 }
 375                 break;
 376             case EMFILE :
 377             case ENFILE :
 378                 ret = AFPERR_NFILE;
 379                 goto openfork_err;
 380             case EISDIR :
 381                 ret = AFPERR_BADTYPE;
 382                 goto openfork_err;
 383             default:
 384                 LOG(log_error, logtype_afpd, "afp_openfork(%s): ad_open: %s", s_path->m_name, strerror(errno) );
 385                 ret = AFPERR_PARAM;
 386                 goto openfork_err;
 387             }
 388         }
 389         else {
 390             /* the ressource fork is open too */
 391             ofork->of_flags |= AFPFORK_META;
 392         }
 393     } else {
 394         /* try opening in read-only mode */
 395         ret = AFPERR_NOOBJ;
 396         if (ad_open(ofork->of_ad, upath, adflags | ADFLAGS_RDONLY | ADFLAGS_SETSHRMD) < 0) {
 397             switch ( errno ) {
 398             case EROFS:
 399                 ret = AFPERR_VLOCK;
 400                 goto openfork_err;
 401             case EACCES:
 402                 goto openfork_err;
 403             case ENOENT:
 404                 /* see if client asked for a read only data fork */
 405                 if (fork == OPENFORK_DATA) {
 406                     if (ad_open(ofork->of_ad, upath, ADFLAGS_DF | ADFLAGS_RDONLY | ADFLAGS_SETSHRMD) < 0) {
 407                         goto openfork_err;
 408                     }
 409                     adflags = ADFLAGS_DF;
 410                 }
 411                 /* else we don't set AFPFORK_META because there's no ressource fork file
 412                  * We need to check AFPFORK_META in afp_closefork(). eg fork open read-only
 413                  * then create in open read-write.
 414                  * FIXME , it doesn't play well with byte locking example:
 415                  * ressource fork open read only
 416                  * locking set on it (no effect, there's no file!)
 417                  * ressource fork open read write now
 418                  */
 419                 break;
 420             case EMFILE :
 421             case ENFILE :
 422                 ret = AFPERR_NFILE;
 423                 goto openfork_err;
 424             case EISDIR :
 425                 ret = AFPERR_BADTYPE;
 426                 goto openfork_err;
 427             default:
 428                 LOG(log_error, logtype_afpd, "afp_openfork(\"%s\"): %s",
 429                     fullpathname(s_path->m_name), strerror(errno) );
 430                 goto openfork_err;
 431             }
 432         } else {
 433             ofork->of_flags |= AFPFORK_META;
 434         }
 435     }
 436
 437     if ((adflags & ADFLAGS_RF) && (ad_get_RF_flags( ofork->of_ad) & O_CREAT)) {
 438         if (ad_setname(ofork->of_ad, path)) {
 439             ad_flush( ofork->of_ad );
 440         }
 441     }
 442
 443     if ((ret = getforkparams(obj, ofork, bitmap, rbuf + 2 * sizeof(int16_t), &buflen)) != AFP_OK) {
 444         ad_close( ofork->of_ad, adflags | ADFLAGS_SETSHRMD);
 445         goto openfork_err;
 446     }
 447
 448     *rbuflen = buflen + 2 * sizeof( uint16_t );
 449     bitmap = htons( bitmap );
 450     memcpy(rbuf, &bitmap, sizeof( uint16_t ));
 451     rbuf += sizeof( uint16_t );
 452
 453     /* check  WriteInhibit bit if we have a ressource fork
 454      * the test is done here, after some Mac trafic capture
 455      */
 456     if (ad_meta_fileno(ofork->of_ad) != -1) {   /* META */
 457         ad_getattr(ofork->of_ad, &bshort);
 458         if ((bshort & htons(ATTRBIT_NOWRITE)) && (access & OPENACC_WR)) {
 459             ad_close( ofork->of_ad, adflags | ADFLAGS_SETSHRMD);
 460             of_dealloc(ofork);
 461             ofrefnum = 0;
 462             memcpy(rbuf, &ofrefnum, sizeof(ofrefnum));
 463             return(AFPERR_OLOCK);
 464         }
 465     }
 466
 467     /*
 468      * synchronization locks:
 469      */
 470
 471     /* don't try to lock non-existent rforks. */
 472     if ((eid == ADEID_DFORK)
 473         || (ad_reso_fileno(ofork->of_ad) != -1)
 474         || (ofork->of_ad->ad_vers == AD_VERSION_EA)) {
 475         ret = fork_setmode(obj, ofork->of_ad, eid, access, ofrefnum);
 476         /* can we access the fork? */
 477         if (ret < 0) {
 478             ofork->of_flags |= AFPFORK_ERROR;
 479             ret = errno;
 480             ad_close( ofork->of_ad, adflags | ADFLAGS_SETSHRMD);
 481             of_dealloc(ofork);
 482             switch (ret) {
 483             case EAGAIN: /* return data anyway */
 484             case EACCES:
 485             case EINVAL:
 486                 ofrefnum = 0;
 487                 memcpy(rbuf, &ofrefnum, sizeof(ofrefnum));
 488                 return( AFPERR_DENYCONF );
 489                 break;
 490             default:
 491                 *rbuflen = 0;
 492                 LOG(log_error, logtype_afpd, "afp_openfork(%s): ad_lock: %s", s_path->m_name, strerror(ret) );
 493                 return( AFPERR_PARAM );
 494             }
 495         }
 496         if ((access & OPENACC_WR))
 497             ofork->of_flags |= AFPFORK_ACCWR;
 498     }
 499     /* the file may be open read only without ressource fork */
 500     if ((access & OPENACC_RD))
 501         ofork->of_flags |= AFPFORK_ACCRD;
 502
 503     memcpy(rbuf, &ofrefnum, sizeof(ofrefnum));
 504     return( AFP_OK );
 505
 506 openfork_err:
 507     of_dealloc(ofork);
 508     if (errno == EACCES)
 509         return (access & OPENACC_WR) ? AFPERR_LOCK : AFPERR_ACCESS;
 510     return ret;
 511 }
 512
 513 int afp_setforkparams(AFPObj *obj, char *ibuf, size_t ibuflen, char *rbuf _U_, size_t *rbuflen)
 514 {
 515     struct ofork    *ofork;
 516     off_t       size;
 517     uint16_t       ofrefnum, bitmap;
 518     int                 err;
 519     int                 is64;
 520     int                 eid;
 521     off_t       st_size;
 522
 523     ibuf += 2;
 524
 525     memcpy(&ofrefnum, ibuf, sizeof( ofrefnum ));
 526     ibuf += sizeof( ofrefnum );
 527
 528     memcpy(&bitmap, ibuf, sizeof(bitmap));
 529     bitmap = ntohs(bitmap);
 530     ibuf += sizeof( bitmap );
 531
 532     *rbuflen = 0;
 533     if (NULL == ( ofork = of_find( ofrefnum )) ) {
 534         LOG(log_error, logtype_afpd, "afp_setforkparams: of_find(%d) could not locate fork", ofrefnum );
 535         return( AFPERR_PARAM );
 536     }
 537
 538     if (ofork->of_vol->v_flags & AFPVOL_RO)
 539         return AFPERR_VLOCK;
 540
 541     if ((ofork->of_flags & AFPFORK_ACCWR) == 0)
 542         return AFPERR_ACCESS;
 543
 544     if ( ofork->of_flags & AFPFORK_DATA) {
 545         eid = ADEID_DFORK;
 546     } else if (ofork->of_flags & AFPFORK_RSRC) {
 547         eid = ADEID_RFORK;
 548     } else
 549         return AFPERR_PARAM;
 550
 551     if ( ( (bitmap & ( (1<<FILPBIT_DFLEN) | (1<<FILPBIT_EXTDFLEN) ))
 552            && eid == ADEID_RFORK
 553              ) ||
 554          ( (bitmap & ( (1<<FILPBIT_RFLEN) | (1<<FILPBIT_EXTRFLEN) ))
 555            && eid == ADEID_DFORK)) {
 556         return AFPERR_BITMAP;
 557     }
 558
 559     is64 = 0;
 560     if ((bitmap & ( (1<<FILPBIT_EXTDFLEN) | (1<<FILPBIT_EXTRFLEN) ))) {
 561         if (obj->afp_version >= 30) {
 562             is64 = 4;
 563         }
 564         else
 565             return AFPERR_BITMAP;
 566     }
 567
 568     if (ibuflen < 2+ sizeof(ofrefnum) + sizeof(bitmap) + is64 +4)
 569         return AFPERR_PARAM ;
 570
 571     size = get_off_t(&ibuf, is64);
 572
 573     if (size < 0)
 574         return AFPERR_PARAM; /* Some MacOS don't return an error they just don't change the size! */
 575
 576
 577     if (bitmap == (1<<FILPBIT_DFLEN) || bitmap == (1<<FILPBIT_EXTDFLEN)) {
 578         st_size = ad_size(ofork->of_ad, eid);
 579         err = -2;
 580         if (st_size > size &&
 581             ad_tmplock(ofork->of_ad, eid, ADLOCK_WR, size, st_size -size, ofork->of_refnum) < 0)
 582             goto afp_setfork_err;
 583
 584         err = ad_dtruncate( ofork->of_ad, size );
 585         if (st_size > size)
 586             ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, size, st_size -size, ofork->of_refnum);
 587         if (err < 0)
 588             goto afp_setfork_err;
 589     } else if (bitmap == (1<<FILPBIT_RFLEN) || bitmap == (1<<FILPBIT_EXTRFLEN)) {
 590         ad_refresh(NULL, ofork->of_ad );
 591
 592         st_size = ad_size(ofork->of_ad, eid);
 593         err = -2;
 594         if (st_size > size &&
 595             ad_tmplock(ofork->of_ad, eid, ADLOCK_WR, size, st_size -size, ofork->of_refnum) < 0) {
 596             goto afp_setfork_err;
 597         }
 598
 599         err = ad_rtruncate(ofork->of_ad, size);
 600         if (st_size > size)
 601             ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, size, st_size -size, ofork->of_refnum);
 602         if (err < 0)
 603             goto afp_setfork_err;
 604
 605         if (ad_flush( ofork->of_ad ) < 0) {
 606             LOG(log_error, logtype_afpd, "afp_setforkparams(%s): ad_flush: %s", of_name(ofork), strerror(errno) );
 607             return AFPERR_PARAM;
 608         }
 609     } else
 610         return AFPERR_BITMAP;
 611
 612 #ifdef AFS
 613     if ( flushfork( ofork ) < 0 ) {
 614         LOG(log_error, logtype_afpd, "afp_setforkparams(%s): flushfork: %s", of_name(ofork), strerror(errno) );
 615     }
 616 #endif /* AFS */
 617
 618     return( AFP_OK );
 619
 620 afp_setfork_err:
 621     if (err == -2)
 622         return AFPERR_LOCK;
 623     else {
 624         switch (errno) {
 625         case EROFS:
 626             return AFPERR_VLOCK;
 627         case EPERM:
 628         case EACCES:
 629             return AFPERR_ACCESS;
 630         case EDQUOT:
 631         case EFBIG:
 632         case ENOSPC:
 633             return AFPERR_DFULL;
 634         default:
 635             return AFPERR_PARAM;
 636         }
 637     }
 638 }
 639
 640 /* for this to work correctly, we need to check for locks before each
 641  * read and write. that's most easily handled by always doing an
 642  * appropriate check before each ad_read/ad_write. other things
 643  * that can change files like truncate are handled internally to those
 644  * functions.
 645  */
 646 #define ENDBIT(a)  ((a) & 0x80)
 647 #define UNLOCKBIT(a) ((a) & 0x01)
 648
 649
 650 /* ---------------------- */
 651 static int byte_lock(AFPObj *obj _U_, char *ibuf, size_t ibuflen _U_, char *rbuf, size_t *rbuflen, int is64)
 652 {
 653     struct ofork    *ofork;
 654     off_t               offset, length;
 655     int                 eid;
 656     uint16_t       ofrefnum;
 657     uint8_t            flags;
 658     int                 lockop;
 659
 660     *rbuflen = 0;
 661
 662     /* figure out parameters */
 663     ibuf++;
 664     flags = *ibuf; /* first bit = endflag, lastbit = lockflag */
 665     ibuf++;
 666     memcpy(&ofrefnum, ibuf, sizeof(ofrefnum));
 667     ibuf += sizeof(ofrefnum);
 668
 669     if (NULL == ( ofork = of_find( ofrefnum )) ) {
 670         LOG(log_error, logtype_afpd, "byte_lock: of_find(%d) could not locate fork", ofrefnum );
 671         return( AFPERR_PARAM );
 672     }
 673
 674     if ( ofork->of_flags & AFPFORK_DATA) {
 675         eid = ADEID_DFORK;
 676     } else if (ofork->of_flags & AFPFORK_RSRC) {
 677         eid = ADEID_RFORK;
 678     } else
 679         return AFPERR_PARAM;
 680
 681     offset = get_off_t(&ibuf, is64);
 682     length = get_off_t(&ibuf, is64);
 683
 684     if (length == -1)
 685         length = BYTELOCK_MAX;
 686     else if (!length || is_neg(is64, length)) {
 687         return AFPERR_PARAM;
 688     } else if ((length >= AD_FILELOCK_BASE) && -1 == (ad_reso_fileno(ofork->of_ad))) { /* HF ?*/
 689         return AFPERR_LOCK;
 690     }
 691
 692     if (ENDBIT(flags)) {
 693         offset += ad_size(ofork->of_ad, eid);
 694         /* FIXME what do we do if file size > 2 GB and
 695            it's not byte_lock_ext?
 696         */
 697     }
 698     if (offset < 0)    /* error if we have a negative offset */
 699         return AFPERR_PARAM;
 700
 701     /* if the file is a read-only file, we use read locks instead of
 702      * write locks. that way, we can prevent anyone from initiating
 703      * a write lock. */
 704     lockop = UNLOCKBIT(flags) ? ADLOCK_CLR : ADLOCK_WR;
 705     if (ad_lock(ofork->of_ad, eid, lockop, offset, length,
 706                 ofork->of_refnum) < 0) {
 707         switch (errno) {
 708         case EACCES:
 709         case EAGAIN:
 710             return UNLOCKBIT(flags) ? AFPERR_NORANGE : AFPERR_LOCK;
 711             break;
 712         case ENOLCK:
 713             return AFPERR_NLOCK;
 714             break;
 715         case EINVAL:
 716             return UNLOCKBIT(flags) ? AFPERR_NORANGE : AFPERR_RANGEOVR;
 717             break;
 718         case EBADF:
 719         default:
 720             return AFPERR_PARAM;
 721             break;
 722         }
 723     }
 724     *rbuflen = set_off_t (offset, rbuf, is64);
 725     return( AFP_OK );
 726 }
 727
 728 /* --------------------------- */
 729 int afp_bytelock(AFPObj *obj, char *ibuf, size_t ibuflen, char *rbuf, size_t *rbuflen)
 730 {
 731     return byte_lock ( obj, ibuf, ibuflen, rbuf, rbuflen , 0);
 732 }
 733
 734 /* --------------------------- */
 735 int afp_bytelock_ext(AFPObj *obj, char *ibuf, size_t ibuflen, char *rbuf, size_t *rbuflen)
 736 {
 737     return byte_lock ( obj, ibuf, ibuflen, rbuf, rbuflen , 1);
 738 }
 739
 740 #undef UNLOCKBIT
 741
 742 /*!
 743  * Read *rbuflen bytes from fork at offset
 744  *
 745  * @param ofork    (r)  fork handle
 746  * @param eid      (r)  data fork or ressource fork entry id
 747  * @param offset   (r)  offset
 748  * @param rbuf     (r)  data buffer
 749  * @param rbuflen  (rw) in: number of bytes to read, out: bytes read
 750  *
 751  * @return         AFP status code
 752  */
 753 static int read_file(const struct ofork *ofork, int eid, off_t offset, char *rbuf, size_t *rbuflen)
 754 {
 755     ssize_t cc;
 756     int eof = 0;
 757     char *p, *q;
 758
 759     cc = ad_read(ofork->of_ad, eid, offset, rbuf, *rbuflen);
 760     if ( cc < 0 ) {
 761         LOG(log_error, logtype_afpd, "afp_read(%s): ad_read: %s", of_name(ofork), strerror(errno) );
 762         *rbuflen = 0;
 763         return( AFPERR_PARAM );
 764     }
 765     *rbuflen = cc;
 766
 767     if ((size_t)cc < *rbuflen)
 768         return AFPERR_EOF;
 769     return AFP_OK;
 770 }
 771
 772 static int read_fork(AFPObj *obj, char *ibuf, size_t ibuflen _U_, char *rbuf, size_t *rbuflen, int is64)
 773 {
 774     DSI          *dsi = obj->dsi;
 775     struct ofork *ofork;
 776     off_t        offset, saveoff, reqcount, savereqcount, size;
 777     ssize_t      cc, err;
 778     int          eid;
 779     uint16_t     ofrefnum;
 780
 781     /* we break the AFP spec here by not supporting nlmask and nlchar anymore */
 782
 783     ibuf += 2;
 784     memcpy(&ofrefnum, ibuf, sizeof( ofrefnum ));
 785     ibuf += sizeof( u_short );
 786
 787     if (NULL == ( ofork = of_find( ofrefnum )) ) {
 788         LOG(log_error, logtype_afpd, "afp_read: of_find(%d) could not locate fork", ofrefnum );
 789         err = AFPERR_PARAM;
 790         goto afp_read_err;
 791     }
 792
 793     if ((ofork->of_flags & AFPFORK_ACCRD) == 0) {
 794         err = AFPERR_ACCESS;
 795         goto afp_read_err;
 796     }
 797
 798     if ( ofork->of_flags & AFPFORK_DATA) {
 799         eid = ADEID_DFORK;
 800     } else if (ofork->of_flags & AFPFORK_RSRC) {
 801         eid = ADEID_RFORK;
 802     } else { /* fork wasn't opened. this should never really happen. */
 803         err = AFPERR_ACCESS;
 804         goto afp_read_err;
 805     }
 806
 807     offset   = get_off_t(&ibuf, is64);
 808     reqcount = get_off_t(&ibuf, is64);
 809
 810     /* reqcount isn't always truthful. we need to deal with that. */
 811     size = ad_size(ofork->of_ad, eid);
 812
 813     LOG(log_debug, logtype_afpd,
 814         "afp_read(off: %" PRIu64 ", len: %" PRIu64 ", fork: %s, size: %" PRIu64 ")",
 815         offset, reqcount, (ofork->of_flags & AFPFORK_DATA) ? "d" : "r", size);
 816
 817     /* subtract off the offset */
 818     if (reqcount + offset > size) {
 819         reqcount = size - offset;
 820         err = AFPERR_EOF;
 821     }
 822
 823     savereqcount = reqcount;
 824     saveoff = offset;
 825
 826     LOG(log_debug, logtype_afpd,
 827         "afp_read(off: %" PRIu64 ", len: %" PRIu64 ", fork: %s)",
 828         offset, reqcount, (ofork->of_flags & AFPFORK_DATA) ? "d" : "r");
 829
 830     if (reqcount < 0 || offset < 0) {
 831         err = AFPERR_PARAM;
 832         goto afp_read_err;
 833     }
 834
 835     /* zero request count */
 836     err = AFP_OK;
 837     if (!reqcount) {
 838         goto afp_read_err;
 839     }
 840
 841     LOG(log_debug, logtype_afpd, "afp_read(name: \"%s\", offset: %jd, reqcount: %jd)",
 842         of_name(ofork), (intmax_t)offset, (intmax_t)reqcount);
 843
 844    if (obj->options.flags & OPTION_AFP_READ_LOCK) {
 845        if (ad_tmplock(ofork->of_ad, eid, ADLOCK_RD, offset, reqcount, ofork->of_refnum) < 0) {
 846            err = AFPERR_LOCK;
 847            goto afp_read_err;
 848        }
 849    }
 850
 851 #ifdef WITH_SENDFILE
 852     if (!(obj->options.flags & OPTION_NOSENDFILE)) {
 853         int fd = ad_readfile_init(ofork->of_ad, eid, &offset, 0);
 854         if (dsi_stream_read_file(dsi, fd, offset, reqcount, err) < 0) {
 855             LOG(log_error, logtype_afpd, "afp_read(%s): ad_readfile: %s",
 856                 of_name(ofork), strerror(errno));
 857             goto afp_read_exit;
 858         }
 859         dsi_readdone(dsi);
 860         goto afp_read_done;
 861     }
 862 #endif
 863
 864     *rbuflen = MIN(reqcount, *rbuflen);
 865
 866     err = read_file(ofork, eid, offset, rbuf, rbuflen);
 867     if (err < 0)
 868         goto afp_read_done;
 869
 870     LOG(log_debug, logtype_afpd,
 871         "afp_read(name: \"%s\", offset: %jd, reqcount: %jd): got %jd bytes from file",
 872         of_name(ofork), (intmax_t)offset, (intmax_t)reqcount, (intmax_t)*rbuflen);
 873
 874     offset += *rbuflen;
 875
 876     /*
 877      * dsi_readinit() returns size of next read buffer. by this point,
 878      * we know that we're sending some data. if we fail, something
 879      * horrible happened.
 880      */
 881     if ((cc = dsi_readinit(dsi, rbuf, *rbuflen, reqcount, err)) < 0)
 882         goto afp_read_exit;
 883     *rbuflen = cc;
 884
 885     while (*rbuflen > 0) {
 886         cc = read_file(ofork, eid, offset, rbuf, rbuflen);
 887         if (cc < 0)
 888             goto afp_read_exit;
 889
 890         offset += *rbuflen;
 891         /* dsi_read() also returns buffer size of next allocation */
 892         cc = dsi_read(dsi, rbuf, *rbuflen); /* send it off */
 893         if (cc < 0)
 894             goto afp_read_exit;
 895         *rbuflen = cc;
 896     }
 897     dsi_readdone(dsi);
 898     goto afp_read_done;
 899
 900 afp_read_exit:
 901     LOG(log_error, logtype_afpd, "afp_read(%s): %s", of_name(ofork), strerror(errno));
 902     dsi_readdone(dsi);
 903    if (obj->options.flags & OPTION_AFP_READ_LOCK)
 904        ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, savereqcount, ofork->of_refnum);
 905     obj->exit(EXITERR_CLNT);
 906
 907 afp_read_done:
 908     if (obj->options.flags & OPTION_AFP_READ_LOCK)
 909         ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, savereqcount, ofork->of_refnum);
 910     return err;
 911
 912 afp_read_err:
 913     *rbuflen = 0;
 914     return err;
 915 }
 916
 917 /* ---------------------- */
 918 int afp_read(AFPObj *obj, char *ibuf, size_t ibuflen, char *rbuf, size_t *rbuflen)
 919 {
 920     return read_fork(obj, ibuf, ibuflen, rbuf, rbuflen, 0);
 921 }
 922
 923 /* ---------------------- */
 924 int afp_read_ext(AFPObj *obj, char *ibuf, size_t ibuflen, char *rbuf, size_t *rbuflen)
 925 {
 926     return read_fork(obj, ibuf, ibuflen, rbuf, rbuflen, 1);
 927 }
 928
 929 /* ---------------------- */
 930 int afp_flush(AFPObj *obj _U_, char *ibuf, size_t ibuflen _U_, char *rbuf _U_, size_t *rbuflen)
 931 {
 932     struct vol *vol;
 933     uint16_t vid;
 934
 935     *rbuflen = 0;
 936     ibuf += 2;
 937
 938     memcpy(&vid, ibuf, sizeof(vid));
 939     if (NULL == ( vol = getvolbyvid( vid )) ) {
 940         return( AFPERR_PARAM );
 941     }
 942
 943     of_flush(vol);
 944     return( AFP_OK );
 945 }
 946
 947 int afp_flushfork(AFPObj *obj _U_, char *ibuf, size_t ibuflen _U_, char *rbuf _U_, size_t *rbuflen)
 948 {
 949     struct ofork    *ofork;
 950     uint16_t       ofrefnum;
 951
 952     *rbuflen = 0;
 953     ibuf += 2;
 954     memcpy(&ofrefnum, ibuf, sizeof( ofrefnum ));
 955
 956     if (NULL == ( ofork = of_find( ofrefnum )) ) {
 957         LOG(log_error, logtype_afpd, "afp_flushfork: of_find(%d) could not locate fork", ofrefnum );
 958         return( AFPERR_PARAM );
 959     }
 960
 961     LOG(log_debug, logtype_afpd, "afp_flushfork(fork: %s)",
 962         (ofork->of_flags & AFPFORK_DATA) ? "d" : "r");
 963
 964     if ( flushfork( ofork ) < 0 ) {
 965         LOG(log_error, logtype_afpd, "afp_flushfork(%s): %s", of_name(ofork), strerror(errno) );
 966     }
 967
 968     return( AFP_OK );
 969 }
 970
 971 /*
 972   FIXME
 973   There is a lot to tell about fsync, fdatasync, F_FULLFSYNC.
 974   fsync(2) on OSX is implemented differently than on other platforms.
 975   see: http://mirror.linux.org.au/pub/linux.conf.au/2007/video/talks/278.pdf.
 976 */
 977 int afp_syncfork(AFPObj *obj _U_, char *ibuf, size_t ibuflen _U_, char *rbuf _U_, size_t *rbuflen)
 978 {
 979     struct ofork        *ofork;
 980     uint16_t           ofrefnum;
 981
 982     *rbuflen = 0;
 983     ibuf += 2;
 984
 985     memcpy(&ofrefnum, ibuf, sizeof(ofrefnum));
 986     ibuf += sizeof( ofrefnum );
 987
 988     if (NULL == ( ofork = of_find( ofrefnum )) ) {
 989         LOG(log_error, logtype_afpd, "afpd_syncfork: of_find(%d) could not locate fork", ofrefnum );
 990         return( AFPERR_PARAM );
 991     }
 992
 993     LOG(log_debug, logtype_afpd, "afp_syncfork(fork: %s)",
 994         (ofork->of_flags & AFPFORK_DATA) ? "d" : "r");
 995
 996     if ( flushfork( ofork ) < 0 ) {
 997         LOG(log_error, logtype_afpd, "flushfork(%s): %s", of_name(ofork), strerror(errno) );
 998         return AFPERR_MISC;
 999     }
1000
1001     return( AFP_OK );
1002 }
1003
1004 /* this is very similar to closefork */
1005 int flushfork(struct ofork *ofork)
1006 {
1007     struct timeval tv;
1008
1009     int err = 0, doflush = 0;
1010
1011     if ( ad_data_fileno( ofork->of_ad ) != -1 &&
1012          fsync( ad_data_fileno( ofork->of_ad )) < 0 ) {
1013         LOG(log_error, logtype_afpd, "flushfork(%s): dfile(%d) %s",
1014             of_name(ofork), ad_data_fileno(ofork->of_ad), strerror(errno) );
1015         err = -1;
1016     }
1017
1018     if ( ad_reso_fileno( ofork->of_ad ) != -1 &&  /* HF */
1019          (ofork->of_flags & AFPFORK_RSRC)) {
1020
1021         /* read in the rfork length */
1022         ad_refresh(NULL, ofork->of_ad);
1023
1024         /* set the date if we're dirty */
1025         if ((ofork->of_flags & AFPFORK_DIRTY) && !gettimeofday(&tv, NULL)) {
1026             ad_setdate(ofork->of_ad, AD_DATE_MODIFY|AD_DATE_UNIX, tv.tv_sec);
1027             ofork->of_flags &= ~AFPFORK_DIRTY;
1028             doflush++;
1029         }
1030
1031         /* flush the header */
1032         if (doflush && ad_flush(ofork->of_ad) < 0)
1033             err = -1;
1034
1035         if (fsync( ad_reso_fileno( ofork->of_ad )) < 0)
1036             err = -1;
1037
1038         if (err < 0)
1039             LOG(log_error, logtype_afpd, "flushfork(%s): hfile(%d) %s",
1040                 of_name(ofork), ad_reso_fileno(ofork->of_ad), strerror(errno) );
1041     }
1042
1043     return( err );
1044 }
1045
1046 int afp_closefork(AFPObj *obj, char *ibuf, size_t ibuflen _U_, char *rbuf _U_, size_t *rbuflen)
1047 {
1048     struct ofork    *ofork;
1049     uint16_t       ofrefnum;
1050
1051     *rbuflen = 0;
1052     ibuf += 2;
1053     memcpy(&ofrefnum, ibuf, sizeof( ofrefnum ));
1054
1055     if (NULL == ( ofork = of_find( ofrefnum )) ) {
1056         LOG(log_error, logtype_afpd, "afp_closefork: of_find(%d) could not locate fork", ofrefnum );
1057         return( AFPERR_PARAM );
1058     }
1059
1060     LOG(log_debug, logtype_afpd, "afp_closefork(fork: %s)",
1061         (ofork->of_flags & AFPFORK_DATA) ? "d" : "r");
1062
1063     if (of_closefork(obj, ofork) < 0 ) {
1064         LOG(log_error, logtype_afpd, "afp_closefork(%s): of_closefork: %s", of_name(ofork), strerror(errno) );
1065         return( AFPERR_PARAM );
1066     }
1067
1068     return( AFP_OK );
1069 }
1070
1071
1072 static ssize_t write_file(struct ofork *ofork, int eid,
1073                           off_t offset, char *rbuf,
1074                           size_t rbuflen)
1075 {
1076     char *p, *q;
1077     ssize_t cc;
1078
1079     LOG(log_debug, logtype_afpd, "write_file(off: %ju, size: %zu)",
1080         (uintmax_t)offset, rbuflen);
1081
1082     if (( cc = ad_write(ofork->of_ad, eid, offset, 0,
1083                         rbuf, rbuflen)) < 0 ) {
1084         switch ( errno ) {
1085         case EDQUOT :
1086         case EFBIG :
1087         case ENOSPC :
1088             return( AFPERR_DFULL );
1089         case EACCES:
1090             return AFPERR_ACCESS;
1091         default :
1092             LOG(log_error, logtype_afpd, "afp_write(%s): ad_write: %s", of_name(ofork), strerror(errno) );
1093             return( AFPERR_PARAM );
1094         }
1095     }
1096
1097     return cc;
1098 }
1099
1100
1101 /* FPWrite. NOTE: on an error, we always use afp_write_err as
1102  * the client may have sent us a bunch of data that's not reflected
1103  * in reqcount et al. */
1104 static int write_fork(AFPObj *obj, char *ibuf, size_t ibuflen _U_, char *rbuf, size_t *rbuflen, int is64)
1105 {
1106     struct ofork    *ofork;
1107     off_t               offset, saveoff, reqcount, oldsize, newsize;
1108     int             endflag, eid, err = AFP_OK;
1109     uint16_t       ofrefnum;
1110     ssize_t             cc;
1111
1112     /* figure out parameters */
1113     ibuf++;
1114     endflag = ENDBIT(*ibuf);
1115     ibuf++;
1116     memcpy(&ofrefnum, ibuf, sizeof( ofrefnum ));
1117     ibuf += sizeof( ofrefnum );
1118
1119     offset   = get_off_t(&ibuf, is64);
1120     reqcount = get_off_t(&ibuf, is64);
1121
1122     if (NULL == ( ofork = of_find( ofrefnum )) ) {
1123         LOG(log_error, logtype_afpd, "afp_write: of_find(%d) could not locate fork", ofrefnum );
1124         err = AFPERR_PARAM;
1125         goto afp_write_err;
1126     }
1127
1128     LOG(log_debug, logtype_afpd, "afp_write(off: %" PRIu64 ", size: %" PRIu64 ", fork: %s)",
1129         offset, reqcount, (ofork->of_flags & AFPFORK_DATA) ? "d" : "r");
1130
1131     if ((ofork->of_flags & AFPFORK_ACCWR) == 0) {
1132         err = AFPERR_ACCESS;
1133         goto afp_write_err;
1134     }
1135
1136 #ifdef AFS
1137     writtenfork = ofork;
1138 #endif /* AFS */
1139
1140     if ( ofork->of_flags & AFPFORK_DATA) {
1141         eid = ADEID_DFORK;
1142     } else if (ofork->of_flags & AFPFORK_RSRC) {
1143         eid = ADEID_RFORK;
1144     } else {
1145         err = AFPERR_ACCESS; /* should never happen */
1146         goto afp_write_err;
1147     }
1148
1149     oldsize = ad_size(ofork->of_ad, eid);
1150     if (endflag)
1151         offset += oldsize;
1152
1153     /* handle bogus parameters */
1154     if (reqcount < 0 || offset < 0) {
1155         err = AFPERR_PARAM;
1156         goto afp_write_err;
1157     }
1158
1159     newsize = ((offset + reqcount) > oldsize) ? (offset + reqcount) : oldsize;
1160
1161     /* offset can overflow on 64-bit capable filesystems.
1162      * report disk full if that's going to happen. */
1163     if (sum_neg(is64, offset, reqcount)) {
1164         err = AFPERR_DFULL;
1165         goto afp_write_err;
1166     }
1167
1168     if (!reqcount) { /* handle request counts of 0 */
1169         err = AFP_OK;
1170         *rbuflen = set_off_t (offset, rbuf, is64);
1171         goto afp_write_err;
1172     }
1173
1174     saveoff = offset;
1175     if (ad_tmplock(ofork->of_ad, eid, ADLOCK_WR, saveoff,
1176                    reqcount, ofork->of_refnum) < 0) {
1177         err = AFPERR_LOCK;
1178         goto afp_write_err;
1179     }
1180
1181     DSI *dsi = obj->dsi;
1182     /* find out what we have already and write it out. */
1183     cc = dsi_writeinit(dsi, rbuf, *rbuflen);
1184
1185     if (!cc || (cc = write_file(ofork, eid, offset, rbuf, cc)) < 0) {
1186         dsi_writeflush(dsi);
1187         *rbuflen = 0;
1188         ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, reqcount, ofork->of_refnum);
1189         return cc;
1190     }
1191
1192     offset += cc;
1193
1194 #if 0 /*def HAVE_SENDFILE_WRITE*/
1195     if ((cc = ad_writefile(ofork->of_ad, eid, dsi->socket,
1196                            offset, dsi->datasize)) < 0) {
1197         switch (errno) {
1198         case EDQUOT:
1199         case EFBIG:
1200         case ENOSPC:
1201             cc = AFPERR_DFULL;
1202             break;
1203         default:
1204             LOG(log_error, logtype_afpd, "afp_write: ad_writefile: %s", strerror(errno) );
1205             goto afp_write_loop;
1206         }
1207         dsi_writeflush(dsi);
1208         *rbuflen = 0;
1209         ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff,
1210                    reqcount,  ofork->of_refnum);
1211         return cc;
1212     }
1213
1214     offset += cc;
1215     goto afp_write_done;
1216 #endif /* 0, was HAVE_SENDFILE_WRITE */
1217
1218     /* loop until everything gets written. currently
1219      * dsi_write handles the end case by itself. */
1220     while ((cc = dsi_write(dsi, rbuf, *rbuflen))) {
1221         if ((cc = write_file(ofork, eid, offset, rbuf, cc)) < 0) {
1222             dsi_writeflush(dsi);
1223             *rbuflen = 0;
1224             ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff,
1225                        reqcount,  ofork->of_refnum);
1226             return cc;
1227         }
1228         offset += cc;
1229     }
1230
1231     ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, reqcount,  ofork->of_refnum);
1232     if ( ad_meta_fileno( ofork->of_ad ) != -1 ) /* META */
1233         ofork->of_flags |= AFPFORK_DIRTY;
1234
1235     /* we have modified any fork, remember until close_fork */
1236     ofork->of_flags |= AFPFORK_MODIFIED;
1237
1238     /* update write count */
1239     ofork->of_vol->v_appended += (newsize > oldsize) ? (newsize - oldsize) : 0;
1240
1241     *rbuflen = set_off_t (offset, rbuf, is64);
1242     return( AFP_OK );
1243
1244 afp_write_err:
1245     dsi_writeinit(obj->dsi, rbuf, *rbuflen);
1246     dsi_writeflush(obj->dsi);
1247
1248     if (err != AFP_OK) {
1249         *rbuflen = 0;
1250     }
1251     return err;
1252 }
1253
1254 /* ---------------------------- */
1255 int afp_write(AFPObj *obj, char *ibuf, size_t ibuflen, char *rbuf, size_t *rbuflen)
1256 {
1257     return write_fork(obj, ibuf, ibuflen, rbuf, rbuflen, 0);
1258 }
1259
1260 /* ----------------------------
1261  * FIXME need to deal with SIGXFSZ signal
1262  */
1263 int afp_write_ext(AFPObj *obj, char *ibuf, size_t ibuflen, char *rbuf, size_t *rbuflen)
1264 {
1265     return write_fork(obj, ibuf, ibuflen, rbuf, rbuflen, 1);
1266 }
1267
1268 /* ---------------------------- */
1269 int afp_getforkparams(AFPObj *obj, char *ibuf, size_t ibuflen _U_, char *rbuf, size_t *rbuflen)
1270 {
1271     struct ofork    *ofork;
1272     int             ret;
1273     uint16_t       ofrefnum, bitmap;
1274     size_t          buflen;
1275     ibuf += 2;
1276     memcpy(&ofrefnum, ibuf, sizeof( ofrefnum ));
1277     ibuf += sizeof( ofrefnum );
1278     memcpy(&bitmap, ibuf, sizeof( bitmap ));
1279     bitmap = ntohs( bitmap );
1280     ibuf += sizeof( bitmap );
1281
1282     *rbuflen = 0;
1283     if (NULL == ( ofork = of_find( ofrefnum )) ) {
1284         LOG(log_error, logtype_afpd, "afp_getforkparams: of_find(%d) could not locate fork", ofrefnum );
1285         return( AFPERR_PARAM );
1286     }
1287
1288     if (AD_META_OPEN(ofork->of_ad)) {
1289         if ( ad_refresh(NULL, ofork->of_ad ) < 0 ) {
1290             LOG(log_error, logtype_afpd, "getforkparams(%s): ad_refresh: %s", of_name(ofork), strerror(errno) );
1291             return( AFPERR_PARAM );
1292         }
1293     }
1294
1295     if (AFP_OK != (ret = getforkparams(obj, ofork, bitmap, rbuf + sizeof( u_short ), &buflen ))) {
1296         return( ret );
1297     }
1298
1299     *rbuflen = buflen + sizeof( u_short );
1300     bitmap = htons( bitmap );
1301     memcpy(rbuf, &bitmap, sizeof( bitmap ));
1302     return( AFP_OK );
1303 }
1304