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 != AD_SYMLINK && 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     /* zero request count */
 811     err = AFP_OK;
 812     if (!reqcount) {
 813         goto afp_read_err;
 814     }
 815
 816     /* reqcount isn't always truthful. we need to deal with that. */
 817     size = ad_size(ofork->of_ad, eid);
 818
 819     LOG(log_debug, logtype_afpd,
 820         "afp_read(off: %" PRIu64 ", len: %" PRIu64 ", fork: %s, size: %" PRIu64 ")",
 821         offset, reqcount, (ofork->of_flags & AFPFORK_DATA) ? "d" : "r", size);
 822
 823     if (offset > size) {
 824         err = AFPERR_EOF;
 825         goto afp_read_err;
 826     }
 827
 828     /* subtract off the offset */
 829     if (reqcount + offset > size) {
 830         reqcount = size - offset;
 831         err = AFPERR_EOF;
 832     }
 833
 834     savereqcount = reqcount;
 835     saveoff = offset;
 836
 837     LOG(log_debug, logtype_afpd,
 838         "afp_read(off: %" PRIu64 ", len: %" PRIu64 ", fork: %s)",
 839         offset, reqcount, (ofork->of_flags & AFPFORK_DATA) ? "d" : "r");
 840
 841     if (reqcount < 0 || offset < 0) {
 842         err = AFPERR_PARAM;
 843         goto afp_read_err;
 844     }
 845
 846     LOG(log_debug, logtype_afpd, "afp_read(name: \"%s\", offset: %jd, reqcount: %jd)",
 847         of_name(ofork), (intmax_t)offset, (intmax_t)reqcount);
 848
 849     if (obj->options.flags & OPTION_AFP_READ_LOCK) {
 850         if (ad_tmplock(ofork->of_ad, eid, ADLOCK_RD, offset, reqcount, ofork->of_refnum) < 0) {
 851             err = AFPERR_LOCK;
 852             goto afp_read_err;
 853         }
 854     }
 855
 856 #ifdef WITH_SENDFILE
 857     if (!(eid == ADEID_DFORK && ad_data_fileno(ofork->of_ad) == AD_SYMLINK) &&
 858         !(obj->options.flags & OPTION_NOSENDFILE)) {
 859         int fd = ad_readfile_init(ofork->of_ad, eid, &offset, 0);
 860         if (dsi_stream_read_file(dsi, fd, offset, reqcount, err) < 0) {
 861             LOG(log_error, logtype_afpd, "afp_read(%s): ad_readfile: %s",
 862                 of_name(ofork), strerror(errno));
 863             goto afp_read_exit;
 864         }
 865         dsi_readdone(dsi);
 866         goto afp_read_done;
 867     }
 868 #endif
 869
 870     *rbuflen = MIN(reqcount, *rbuflen);
 871
 872     err = read_file(ofork, eid, offset, rbuf, rbuflen);
 873     if (err < 0)
 874         goto afp_read_done;
 875
 876     LOG(log_debug, logtype_afpd,
 877         "afp_read(name: \"%s\", offset: %jd, reqcount: %jd): got %jd bytes from file",
 878         of_name(ofork), (intmax_t)offset, (intmax_t)reqcount, (intmax_t)*rbuflen);
 879
 880     offset += *rbuflen;
 881
 882     /*
 883      * dsi_readinit() returns size of next read buffer. by this point,
 884      * we know that we're sending some data. if we fail, something
 885      * horrible happened.
 886      */
 887     if ((cc = dsi_readinit(dsi, rbuf, *rbuflen, reqcount, err)) < 0)
 888         goto afp_read_exit;
 889     *rbuflen = cc;
 890
 891     while (*rbuflen > 0) {
 892         cc = read_file(ofork, eid, offset, rbuf, rbuflen);
 893         if (cc < 0)
 894             goto afp_read_exit;
 895
 896         offset += *rbuflen;
 897         /* dsi_read() also returns buffer size of next allocation */
 898         cc = dsi_read(dsi, rbuf, *rbuflen); /* send it off */
 899         if (cc < 0)
 900             goto afp_read_exit;
 901         *rbuflen = cc;
 902     }
 903     dsi_readdone(dsi);
 904     goto afp_read_done;
 905
 906 afp_read_exit:
 907     LOG(log_error, logtype_afpd, "afp_read(%s): %s", of_name(ofork), strerror(errno));
 908     dsi_readdone(dsi);
 909    if (obj->options.flags & OPTION_AFP_READ_LOCK)
 910        ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, savereqcount, ofork->of_refnum);
 911     obj->exit(EXITERR_CLNT);
 912
 913 afp_read_done:
 914     if (obj->options.flags & OPTION_AFP_READ_LOCK)
 915         ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, savereqcount, ofork->of_refnum);
 916     return err;
 917
 918 afp_read_err:
 919     *rbuflen = 0;
 920     return err;
 921 }
 922
 923 /* ---------------------- */
 924 int afp_read(AFPObj *obj, char *ibuf, size_t ibuflen, char *rbuf, size_t *rbuflen)
 925 {
 926     return read_fork(obj, ibuf, ibuflen, rbuf, rbuflen, 0);
 927 }
 928
 929 /* ---------------------- */
 930 int afp_read_ext(AFPObj *obj, char *ibuf, size_t ibuflen, char *rbuf, size_t *rbuflen)
 931 {
 932     return read_fork(obj, ibuf, ibuflen, rbuf, rbuflen, 1);
 933 }
 934
 935 /* ---------------------- */
 936 int afp_flush(AFPObj *obj _U_, char *ibuf, size_t ibuflen _U_, char *rbuf _U_, size_t *rbuflen)
 937 {
 938     struct vol *vol;
 939     uint16_t vid;
 940
 941     *rbuflen = 0;
 942     ibuf += 2;
 943
 944     memcpy(&vid, ibuf, sizeof(vid));
 945     if (NULL == ( vol = getvolbyvid( vid )) ) {
 946         return( AFPERR_PARAM );
 947     }
 948
 949     of_flush(vol);
 950     return( AFP_OK );
 951 }
 952
 953 int afp_flushfork(AFPObj *obj _U_, char *ibuf, size_t ibuflen _U_, char *rbuf _U_, size_t *rbuflen)
 954 {
 955     struct ofork    *ofork;
 956     uint16_t       ofrefnum;
 957
 958     *rbuflen = 0;
 959     ibuf += 2;
 960     memcpy(&ofrefnum, ibuf, sizeof( ofrefnum ));
 961
 962     if (NULL == ( ofork = of_find( ofrefnum )) ) {
 963         LOG(log_error, logtype_afpd, "afp_flushfork: of_find(%d) could not locate fork", ofrefnum );
 964         return( AFPERR_PARAM );
 965     }
 966
 967     LOG(log_debug, logtype_afpd, "afp_flushfork(fork: %s)",
 968         (ofork->of_flags & AFPFORK_DATA) ? "d" : "r");
 969
 970     if ( flushfork( ofork ) < 0 ) {
 971         LOG(log_error, logtype_afpd, "afp_flushfork(%s): %s", of_name(ofork), strerror(errno) );
 972     }
 973
 974     return( AFP_OK );
 975 }
 976
 977 /*
 978   FIXME
 979   There is a lot to tell about fsync, fdatasync, F_FULLFSYNC.
 980   fsync(2) on OSX is implemented differently than on other platforms.
 981   see: http://mirror.linux.org.au/pub/linux.conf.au/2007/video/talks/278.pdf.
 982 */
 983 int afp_syncfork(AFPObj *obj _U_, char *ibuf, size_t ibuflen _U_, char *rbuf _U_, size_t *rbuflen)
 984 {
 985     struct ofork        *ofork;
 986     uint16_t           ofrefnum;
 987
 988     *rbuflen = 0;
 989     ibuf += 2;
 990
 991     memcpy(&ofrefnum, ibuf, sizeof(ofrefnum));
 992     ibuf += sizeof( ofrefnum );
 993
 994     if (NULL == ( ofork = of_find( ofrefnum )) ) {
 995         LOG(log_error, logtype_afpd, "afpd_syncfork: of_find(%d) could not locate fork", ofrefnum );
 996         return( AFPERR_PARAM );
 997     }
 998
 999     LOG(log_debug, logtype_afpd, "afp_syncfork(fork: %s)",
1000         (ofork->of_flags & AFPFORK_DATA) ? "d" : "r");
1001
1002     if ( flushfork( ofork ) < 0 ) {
1003         LOG(log_error, logtype_afpd, "flushfork(%s): %s", of_name(ofork), strerror(errno) );
1004         return AFPERR_MISC;
1005     }
1006
1007     return( AFP_OK );
1008 }
1009
1010 /* this is very similar to closefork */
1011 int flushfork(struct ofork *ofork)
1012 {
1013     struct timeval tv;
1014
1015     int err = 0, doflush = 0;
1016
1017     if ( ad_data_fileno( ofork->of_ad ) != -1 &&
1018          fsync( ad_data_fileno( ofork->of_ad )) < 0 ) {
1019         LOG(log_error, logtype_afpd, "flushfork(%s): dfile(%d) %s",
1020             of_name(ofork), ad_data_fileno(ofork->of_ad), strerror(errno) );
1021         err = -1;
1022     }
1023
1024     if ( ad_reso_fileno( ofork->of_ad ) != -1 &&  /* HF */
1025          (ofork->of_flags & AFPFORK_RSRC)) {
1026
1027         /* read in the rfork length */
1028         ad_refresh(NULL, ofork->of_ad);
1029
1030         /* set the date if we're dirty */
1031         if ((ofork->of_flags & AFPFORK_DIRTY) && !gettimeofday(&tv, NULL)) {
1032             ad_setdate(ofork->of_ad, AD_DATE_MODIFY|AD_DATE_UNIX, tv.tv_sec);
1033             ofork->of_flags &= ~AFPFORK_DIRTY;
1034             doflush++;
1035         }
1036
1037         /* flush the header */
1038         if (doflush && ad_flush(ofork->of_ad) < 0)
1039             err = -1;
1040
1041         if (fsync( ad_reso_fileno( ofork->of_ad )) < 0)
1042             err = -1;
1043
1044         if (err < 0)
1045             LOG(log_error, logtype_afpd, "flushfork(%s): hfile(%d) %s",
1046                 of_name(ofork), ad_reso_fileno(ofork->of_ad), strerror(errno) );
1047     }
1048
1049     return( err );
1050 }
1051
1052 int afp_closefork(AFPObj *obj, char *ibuf, size_t ibuflen _U_, char *rbuf _U_, size_t *rbuflen)
1053 {
1054     struct ofork    *ofork;
1055     uint16_t       ofrefnum;
1056
1057     *rbuflen = 0;
1058     ibuf += 2;
1059     memcpy(&ofrefnum, ibuf, sizeof( ofrefnum ));
1060
1061     if (NULL == ( ofork = of_find( ofrefnum )) ) {
1062         LOG(log_error, logtype_afpd, "afp_closefork: of_find(%d) could not locate fork", ofrefnum );
1063         return( AFPERR_PARAM );
1064     }
1065
1066     LOG(log_debug, logtype_afpd, "afp_closefork(fork: %s)",
1067         (ofork->of_flags & AFPFORK_DATA) ? "d" : "r");
1068
1069     if (of_closefork(obj, ofork) < 0 ) {
1070         LOG(log_error, logtype_afpd, "afp_closefork(%s): of_closefork: %s", of_name(ofork), strerror(errno) );
1071         return( AFPERR_PARAM );
1072     }
1073
1074     return( AFP_OK );
1075 }
1076
1077
1078 static ssize_t write_file(struct ofork *ofork, int eid,
1079                           off_t offset, char *rbuf,
1080                           size_t rbuflen)
1081 {
1082     char *p, *q;
1083     ssize_t cc;
1084
1085     LOG(log_debug, logtype_afpd, "write_file(off: %ju, size: %zu)",
1086         (uintmax_t)offset, rbuflen);
1087
1088     if (( cc = ad_write(ofork->of_ad, eid, offset, 0,
1089                         rbuf, rbuflen)) < 0 ) {
1090         switch ( errno ) {
1091         case EDQUOT :
1092         case EFBIG :
1093         case ENOSPC :
1094             return( AFPERR_DFULL );
1095         case EACCES:
1096             return AFPERR_ACCESS;
1097         default :
1098             LOG(log_error, logtype_afpd, "afp_write(%s): ad_write: %s", of_name(ofork), strerror(errno) );
1099             return( AFPERR_PARAM );
1100         }
1101     }
1102
1103     return cc;
1104 }
1105
1106
1107 /*
1108  * FPWrite. NOTE: on an error, we always use afp_write_err as
1109  * the client may have sent us a bunch of data that's not reflected
1110  * in reqcount et al.
1111  */
1112 static int write_fork(AFPObj *obj, char *ibuf, size_t ibuflen _U_, char *rbuf, size_t *rbuflen, int is64)
1113 {
1114     struct ofork    *ofork;
1115     off_t           offset, saveoff, reqcount, oldsize, newsize;
1116     int             endflag, eid, err = AFP_OK;
1117     uint16_t        ofrefnum;
1118     ssize_t         cc;
1119     DSI             *dsi = obj->dsi;
1120     char            *rcvbuf = dsi->buffer;
1121     size_t          rcvbuflen = dsi->dsireadbuf * dsi->server_quantum;
1122
1123     /* figure out parameters */
1124     ibuf++;
1125     endflag = ENDBIT(*ibuf);
1126     ibuf++;
1127     memcpy(&ofrefnum, ibuf, sizeof( ofrefnum ));
1128     ibuf += sizeof( ofrefnum );
1129
1130     offset   = get_off_t(&ibuf, is64);
1131     reqcount = get_off_t(&ibuf, is64);
1132
1133     if (NULL == ( ofork = of_find( ofrefnum )) ) {
1134         LOG(log_error, logtype_afpd, "afp_write: of_find(%d) could not locate fork", ofrefnum );
1135         err = AFPERR_PARAM;
1136         goto afp_write_err;
1137     }
1138
1139     LOG(log_debug, logtype_afpd, "afp_write(off: %" PRIu64 ", size: %" PRIu64 ", fork: %s)",
1140         offset, reqcount, (ofork->of_flags & AFPFORK_DATA) ? "d" : "r");
1141
1142     if ((ofork->of_flags & AFPFORK_ACCWR) == 0) {
1143         err = AFPERR_ACCESS;
1144         goto afp_write_err;
1145     }
1146
1147 #ifdef AFS
1148     writtenfork = ofork;
1149 #endif /* AFS */
1150
1151     if ( ofork->of_flags & AFPFORK_DATA) {
1152         eid = ADEID_DFORK;
1153     } else if (ofork->of_flags & AFPFORK_RSRC) {
1154         eid = ADEID_RFORK;
1155     } else {
1156         err = AFPERR_ACCESS; /* should never happen */
1157         goto afp_write_err;
1158     }
1159
1160     oldsize = ad_size(ofork->of_ad, eid);
1161     if (endflag)
1162         offset += oldsize;
1163
1164     /* handle bogus parameters */
1165     if (reqcount < 0 || offset < 0) {
1166         err = AFPERR_PARAM;
1167         goto afp_write_err;
1168     }
1169
1170     newsize = ((offset + reqcount) > oldsize) ? (offset + reqcount) : oldsize;
1171
1172     /* offset can overflow on 64-bit capable filesystems.
1173      * report disk full if that's going to happen. */
1174     if (sum_neg(is64, offset, reqcount)) {
1175         err = AFPERR_DFULL;
1176         goto afp_write_err;
1177     }
1178
1179     if (!reqcount) { /* handle request counts of 0 */
1180         err = AFP_OK;
1181         *rbuflen = set_off_t (offset, rbuf, is64);
1182         goto afp_write_err;
1183     }
1184
1185     saveoff = offset;
1186     if (obj->options.flags & OPTION_AFP_READ_LOCK) {
1187         if (ad_tmplock(ofork->of_ad, eid, ADLOCK_WR, saveoff, reqcount, ofork->of_refnum) < 0) {
1188             err = AFPERR_LOCK;
1189             goto afp_write_err;
1190         }
1191     }
1192
1193     /* find out what we have already */
1194     cc = dsi_writeinit(dsi, rcvbuf, rcvbuflen);
1195
1196     if (!cc || (cc = write_file(ofork, eid, offset, rcvbuf, cc)) < 0) {
1197         dsi_writeflush(dsi);
1198         *rbuflen = 0;
1199         if (obj->options.flags & OPTION_AFP_READ_LOCK)
1200             ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, reqcount, ofork->of_refnum);
1201         return cc;
1202     }
1203
1204     offset += cc;
1205
1206 #if 0 /*def HAVE_SENDFILE_WRITE*/
1207     if ((cc = ad_writefile(ofork->of_ad, eid, dsi->socket, offset, dsi->datasize)) < 0) {
1208         switch (errno) {
1209         case EDQUOT:
1210         case EFBIG:
1211         case ENOSPC:
1212             cc = AFPERR_DFULL;
1213             break;
1214         default:
1215             LOG(log_error, logtype_afpd, "afp_write: ad_writefile: %s", strerror(errno) );
1216             goto afp_write_loop;
1217         }
1218         dsi_writeflush(dsi);
1219         *rbuflen = 0;
1220         if (obj->options.flags & OPTION_AFP_READ_LOCK)
1221             ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, reqcount,  ofork->of_refnum);
1222         return cc;
1223     }
1224
1225     offset += cc;
1226     goto afp_write_done;
1227 #endif /* 0, was HAVE_SENDFILE_WRITE */
1228
1229     /* loop until everything gets written. currently
1230      * dsi_write handles the end case by itself. */
1231     while ((cc = dsi_write(dsi, rcvbuf, rcvbuflen))) {
1232
1233         if ((cc = write_file(ofork, eid, offset, rcvbuf, cc)) < 0) {
1234             dsi_writeflush(dsi);
1235             *rbuflen = 0;
1236             if (obj->options.flags & OPTION_AFP_READ_LOCK)
1237                 ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, reqcount,  ofork->of_refnum);
1238             return cc;
1239         }
1240
1241         LOG(log_debug, logtype_afpd, "afp_write: wrote: %jd, offset: %jd",
1242             (intmax_t)cc, (intmax_t)offset);
1243
1244         offset += cc;
1245     }
1246
1247     if (obj->options.flags & OPTION_AFP_READ_LOCK)
1248         ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, reqcount,  ofork->of_refnum);
1249     if ( ad_meta_fileno( ofork->of_ad ) != -1 ) /* META */
1250         ofork->of_flags |= AFPFORK_DIRTY;
1251
1252     /* we have modified any fork, remember until close_fork */
1253     ofork->of_flags |= AFPFORK_MODIFIED;
1254
1255     /* update write count */
1256     ofork->of_vol->v_appended += (newsize > oldsize) ? (newsize - oldsize) : 0;
1257
1258     *rbuflen = set_off_t (offset, rbuf, is64);
1259     return( AFP_OK );
1260
1261 afp_write_err:
1262     dsi_writeinit(obj->dsi, rbuf, *rbuflen);
1263     dsi_writeflush(obj->dsi);
1264
1265     if (err != AFP_OK) {
1266         *rbuflen = 0;
1267     }
1268     return err;
1269 }
1270
1271 /* ---------------------------- */
1272 int afp_write(AFPObj *obj, char *ibuf, size_t ibuflen, char *rbuf, size_t *rbuflen)
1273 {
1274     return write_fork(obj, ibuf, ibuflen, rbuf, rbuflen, 0);
1275 }
1276
1277 /* ----------------------------
1278  * FIXME need to deal with SIGXFSZ signal
1279  */
1280 int afp_write_ext(AFPObj *obj, char *ibuf, size_t ibuflen, char *rbuf, size_t *rbuflen)
1281 {
1282     return write_fork(obj, ibuf, ibuflen, rbuf, rbuflen, 1);
1283 }
1284
1285 /* ---------------------------- */
1286 int afp_getforkparams(AFPObj *obj, char *ibuf, size_t ibuflen _U_, char *rbuf, size_t *rbuflen)
1287 {
1288     struct ofork    *ofork;
1289     int             ret;
1290     uint16_t       ofrefnum, bitmap;
1291     size_t          buflen;
1292     ibuf += 2;
1293     memcpy(&ofrefnum, ibuf, sizeof( ofrefnum ));
1294     ibuf += sizeof( ofrefnum );
1295     memcpy(&bitmap, ibuf, sizeof( bitmap ));
1296     bitmap = ntohs( bitmap );
1297     ibuf += sizeof( bitmap );
1298
1299     *rbuflen = 0;
1300     if (NULL == ( ofork = of_find( ofrefnum )) ) {
1301         LOG(log_error, logtype_afpd, "afp_getforkparams: of_find(%d) could not locate fork", ofrefnum );
1302         return( AFPERR_PARAM );
1303     }
1304
1305     if (AD_META_OPEN(ofork->of_ad)) {
1306         if ( ad_refresh(NULL, ofork->of_ad ) < 0 ) {
1307             LOG(log_error, logtype_afpd, "getforkparams(%s): ad_refresh: %s", of_name(ofork), strerror(errno) );
1308             return( AFPERR_PARAM );
1309         }
1310     }
1311
1312     if (AFP_OK != (ret = getforkparams(obj, ofork, bitmap, rbuf + sizeof( u_short ), &buflen ))) {
1313         return( ret );
1314     }
1315
1316     *rbuflen = buflen + sizeof( u_short );
1317     bitmap = htons( bitmap );
1318     memcpy(rbuf, &bitmap, sizeof( bitmap ));
1319     return( AFP_OK );
1320 }
1321