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             LOG(log_error, logtype_afpd, "afp_setforkparams: DISK FULL");
 634             return AFPERR_DFULL;
 635         default:
 636             return AFPERR_PARAM;
 637         }
 638     }
 639 }
 640
 641 /* for this to work correctly, we need to check for locks before each
 642  * read and write. that's most easily handled by always doing an
 643  * appropriate check before each ad_read/ad_write. other things
 644  * that can change files like truncate are handled internally to those
 645  * functions.
 646  */
 647 #define ENDBIT(a)  ((a) & 0x80)
 648 #define UNLOCKBIT(a) ((a) & 0x01)
 649
 650
 651 /* ---------------------- */
 652 static int byte_lock(AFPObj *obj _U_, char *ibuf, size_t ibuflen _U_, char *rbuf, size_t *rbuflen, int is64)
 653 {
 654     struct ofork    *ofork;
 655     off_t               offset, length;
 656     int                 eid;
 657     uint16_t       ofrefnum;
 658     uint8_t            flags;
 659     int                 lockop;
 660
 661     *rbuflen = 0;
 662
 663     /* figure out parameters */
 664     ibuf++;
 665     flags = *ibuf; /* first bit = endflag, lastbit = lockflag */
 666     ibuf++;
 667     memcpy(&ofrefnum, ibuf, sizeof(ofrefnum));
 668     ibuf += sizeof(ofrefnum);
 669
 670     if (NULL == ( ofork = of_find( ofrefnum )) ) {
 671         LOG(log_error, logtype_afpd, "byte_lock: of_find(%d) could not locate fork", ofrefnum );
 672         return( AFPERR_PARAM );
 673     }
 674
 675     if ( ofork->of_flags & AFPFORK_DATA) {
 676         eid = ADEID_DFORK;
 677     } else if (ofork->of_flags & AFPFORK_RSRC) {
 678         eid = ADEID_RFORK;
 679     } else
 680         return AFPERR_PARAM;
 681
 682     offset = get_off_t(&ibuf, is64);
 683     length = get_off_t(&ibuf, is64);
 684
 685     if (length == -1)
 686         length = BYTELOCK_MAX;
 687     else if (!length || is_neg(is64, length)) {
 688         return AFPERR_PARAM;
 689     } else if ((length >= AD_FILELOCK_BASE) && -1 == (ad_reso_fileno(ofork->of_ad))) { /* HF ?*/
 690         return AFPERR_LOCK;
 691     }
 692
 693     if (ENDBIT(flags)) {
 694         offset += ad_size(ofork->of_ad, eid);
 695         /* FIXME what do we do if file size > 2 GB and
 696            it's not byte_lock_ext?
 697         */
 698     }
 699     if (offset < 0)    /* error if we have a negative offset */
 700         return AFPERR_PARAM;
 701
 702     /* if the file is a read-only file, we use read locks instead of
 703      * write locks. that way, we can prevent anyone from initiating
 704      * a write lock. */
 705     lockop = UNLOCKBIT(flags) ? ADLOCK_CLR : ADLOCK_WR;
 706     if (ad_lock(ofork->of_ad, eid, lockop, offset, length,
 707                 ofork->of_refnum) < 0) {
 708         switch (errno) {
 709         case EACCES:
 710         case EAGAIN:
 711             return UNLOCKBIT(flags) ? AFPERR_NORANGE : AFPERR_LOCK;
 712             break;
 713         case ENOLCK:
 714             return AFPERR_NLOCK;
 715             break;
 716         case EINVAL:
 717             return UNLOCKBIT(flags) ? AFPERR_NORANGE : AFPERR_RANGEOVR;
 718             break;
 719         case EBADF:
 720         default:
 721             return AFPERR_PARAM;
 722             break;
 723         }
 724     }
 725     *rbuflen = set_off_t (offset, rbuf, is64);
 726     return( AFP_OK );
 727 }
 728
 729 /* --------------------------- */
 730 int afp_bytelock(AFPObj *obj, char *ibuf, size_t ibuflen, char *rbuf, size_t *rbuflen)
 731 {
 732     return byte_lock ( obj, ibuf, ibuflen, rbuf, rbuflen , 0);
 733 }
 734
 735 /* --------------------------- */
 736 int afp_bytelock_ext(AFPObj *obj, char *ibuf, size_t ibuflen, char *rbuf, size_t *rbuflen)
 737 {
 738     return byte_lock ( obj, ibuf, ibuflen, rbuf, rbuflen , 1);
 739 }
 740
 741 #undef UNLOCKBIT
 742
 743 /*!
 744  * Read *rbuflen bytes from fork at offset
 745  *
 746  * @param ofork    (r)  fork handle
 747  * @param eid      (r)  data fork or ressource fork entry id
 748  * @param offset   (r)  offset
 749  * @param rbuf     (r)  data buffer
 750  * @param rbuflen  (rw) in: number of bytes to read, out: bytes read
 751  *
 752  * @return         AFP status code
 753  */
 754 static int read_file(const struct ofork *ofork, int eid, off_t offset, char *rbuf, size_t *rbuflen)
 755 {
 756     ssize_t cc;
 757     int eof = 0;
 758     char *p, *q;
 759
 760     cc = ad_read(ofork->of_ad, eid, offset, rbuf, *rbuflen);
 761     if ( cc < 0 ) {
 762         LOG(log_error, logtype_afpd, "afp_read(%s): ad_read: %s", of_name(ofork), strerror(errno) );
 763         *rbuflen = 0;
 764         return( AFPERR_PARAM );
 765     }
 766     *rbuflen = cc;
 767
 768     if ((size_t)cc < *rbuflen)
 769         return AFPERR_EOF;
 770     return AFP_OK;
 771 }
 772
 773 static int read_fork(AFPObj *obj, char *ibuf, size_t ibuflen _U_, char *rbuf, size_t *rbuflen, int is64)
 774 {
 775     DSI          *dsi = obj->dsi;
 776     struct ofork *ofork;
 777     off_t        offset, saveoff, reqcount, savereqcount, size;
 778     ssize_t      cc, err;
 779     int          eid;
 780     uint16_t     ofrefnum;
 781
 782     /* we break the AFP spec here by not supporting nlmask and nlchar anymore */
 783
 784     ibuf += 2;
 785     memcpy(&ofrefnum, ibuf, sizeof( ofrefnum ));
 786     ibuf += sizeof( u_short );
 787
 788     if (NULL == ( ofork = of_find( ofrefnum )) ) {
 789         LOG(log_error, logtype_afpd, "afp_read: of_find(%d) could not locate fork", ofrefnum );
 790         err = AFPERR_PARAM;
 791         goto afp_read_err;
 792     }
 793
 794     if ((ofork->of_flags & AFPFORK_ACCRD) == 0) {
 795         err = AFPERR_ACCESS;
 796         goto afp_read_err;
 797     }
 798
 799     if ( ofork->of_flags & AFPFORK_DATA) {
 800         eid = ADEID_DFORK;
 801     } else if (ofork->of_flags & AFPFORK_RSRC) {
 802         eid = ADEID_RFORK;
 803     } else { /* fork wasn't opened. this should never really happen. */
 804         err = AFPERR_ACCESS;
 805         goto afp_read_err;
 806     }
 807
 808     offset   = get_off_t(&ibuf, is64);
 809     reqcount = get_off_t(&ibuf, is64);
 810
 811     /* zero request count */
 812     err = AFP_OK;
 813     if (!reqcount) {
 814         goto afp_read_err;
 815     }
 816
 817     /* reqcount isn't always truthful. we need to deal with that. */
 818     size = ad_size(ofork->of_ad, eid);
 819
 820     LOG(log_debug, logtype_afpd,
 821         "afp_read(off: %" PRIu64 ", len: %" PRIu64 ", fork: %s, size: %" PRIu64 ")",
 822         offset, reqcount, (ofork->of_flags & AFPFORK_DATA) ? "d" : "r", size);
 823
 824     if (offset > size) {
 825         err = AFPERR_EOF;
 826         goto afp_read_err;
 827     }
 828
 829     /* subtract off the offset */
 830     if (reqcount + offset > size) {
 831         reqcount = size - offset;
 832         err = AFPERR_EOF;
 833     }
 834
 835     savereqcount = reqcount;
 836     saveoff = offset;
 837
 838     LOG(log_debug, logtype_afpd,
 839         "afp_read(off: %" PRIu64 ", len: %" PRIu64 ", fork: %s)",
 840         offset, reqcount, (ofork->of_flags & AFPFORK_DATA) ? "d" : "r");
 841
 842     if (reqcount < 0 || offset < 0) {
 843         err = AFPERR_PARAM;
 844         goto afp_read_err;
 845     }
 846
 847     LOG(log_debug, logtype_afpd, "afp_read(name: \"%s\", offset: %jd, reqcount: %jd)",
 848         of_name(ofork), (intmax_t)offset, (intmax_t)reqcount);
 849
 850     if (obj->options.flags & OPTION_AFP_READ_LOCK) {
 851         if (ad_tmplock(ofork->of_ad, eid, ADLOCK_RD, offset, reqcount, ofork->of_refnum) < 0) {
 852             err = AFPERR_LOCK;
 853             goto afp_read_err;
 854         }
 855     }
 856
 857 #ifdef WITH_SENDFILE
 858     if (!(eid == ADEID_DFORK && ad_data_fileno(ofork->of_ad) == AD_SYMLINK) &&
 859         !(obj->options.flags & OPTION_NOSENDFILE)) {
 860         int fd = ad_readfile_init(ofork->of_ad, eid, &offset, 0);
 861         if (dsi_stream_read_file(dsi, fd, offset, reqcount, err) < 0) {
 862             LOG(log_error, logtype_afpd, "afp_read(%s): ad_readfile: %s",
 863                 of_name(ofork), strerror(errno));
 864             goto afp_read_exit;
 865         }
 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             LOG(log_error, logtype_afpd, "write_file: DISK FULL");
1095             return( AFPERR_DFULL );
1096         case EACCES:
1097             return AFPERR_ACCESS;
1098         default :
1099             LOG(log_error, logtype_afpd, "afp_write(%s): ad_write: %s", of_name(ofork), strerror(errno) );
1100             return( AFPERR_PARAM );
1101         }
1102     }
1103
1104     return cc;
1105 }
1106
1107
1108 /*
1109  * FPWrite. NOTE: on an error, we always use afp_write_err as
1110  * the client may have sent us a bunch of data that's not reflected
1111  * in reqcount et al.
1112  */
1113 static int write_fork(AFPObj *obj, char *ibuf, size_t ibuflen _U_, char *rbuf, size_t *rbuflen, int is64)
1114 {
1115     struct ofork    *ofork;
1116     off_t           offset, saveoff, reqcount, oldsize, newsize;
1117     int             endflag, eid, err = AFP_OK;
1118     uint16_t        ofrefnum;
1119     ssize_t         cc;
1120     DSI             *dsi = obj->dsi;
1121     char            *rcvbuf = dsi->buffer;
1122     size_t          rcvbuflen = dsi->dsireadbuf * dsi->server_quantum;
1123
1124     /* figure out parameters */
1125     ibuf++;
1126     endflag = ENDBIT(*ibuf);
1127     ibuf++;
1128     memcpy(&ofrefnum, ibuf, sizeof( ofrefnum ));
1129     ibuf += sizeof( ofrefnum );
1130
1131     offset   = get_off_t(&ibuf, is64);
1132     reqcount = get_off_t(&ibuf, is64);
1133
1134     if (NULL == ( ofork = of_find( ofrefnum )) ) {
1135         LOG(log_error, logtype_afpd, "afp_write: of_find(%d) could not locate fork", ofrefnum );
1136         err = AFPERR_PARAM;
1137         goto afp_write_err;
1138     }
1139
1140     LOG(log_debug, logtype_afpd, "afp_write(off: %" PRIu64 ", size: %" PRIu64 ", fork: %s)",
1141         offset, reqcount, (ofork->of_flags & AFPFORK_DATA) ? "d" : "r");
1142
1143     if ((ofork->of_flags & AFPFORK_ACCWR) == 0) {
1144         err = AFPERR_ACCESS;
1145         goto afp_write_err;
1146     }
1147
1148 #ifdef AFS
1149     writtenfork = ofork;
1150 #endif /* AFS */
1151
1152     if ( ofork->of_flags & AFPFORK_DATA) {
1153         eid = ADEID_DFORK;
1154     } else if (ofork->of_flags & AFPFORK_RSRC) {
1155         eid = ADEID_RFORK;
1156     } else {
1157         err = AFPERR_ACCESS; /* should never happen */
1158         goto afp_write_err;
1159     }
1160
1161     oldsize = ad_size(ofork->of_ad, eid);
1162     if (endflag)
1163         offset += oldsize;
1164
1165     /* handle bogus parameters */
1166     if (reqcount < 0 || offset < 0) {
1167         err = AFPERR_PARAM;
1168         goto afp_write_err;
1169     }
1170
1171     newsize = ((offset + reqcount) > oldsize) ? (offset + reqcount) : oldsize;
1172
1173     /* offset can overflow on 64-bit capable filesystems.
1174      * report disk full if that's going to happen. */
1175     if (sum_neg(is64, offset, reqcount)) {
1176         LOG(log_error, logtype_afpd, "write_fork: DISK FULL");
1177         err = AFPERR_DFULL;
1178         goto afp_write_err;
1179     }
1180
1181     if (!reqcount) { /* handle request counts of 0 */
1182         err = AFP_OK;
1183         *rbuflen = set_off_t (offset, rbuf, is64);
1184         goto afp_write_err;
1185     }
1186
1187     saveoff = offset;
1188     if (obj->options.flags & OPTION_AFP_READ_LOCK) {
1189         if (ad_tmplock(ofork->of_ad, eid, ADLOCK_WR, saveoff, reqcount, ofork->of_refnum) < 0) {
1190             err = AFPERR_LOCK;
1191             goto afp_write_err;
1192         }
1193     }
1194
1195     /* find out what we have already */
1196     cc = dsi_writeinit(dsi, rcvbuf, rcvbuflen);
1197
1198     if (!cc || (cc = write_file(ofork, eid, offset, rcvbuf, cc)) < 0) {
1199         dsi_writeflush(dsi);
1200         *rbuflen = 0;
1201         if (obj->options.flags & OPTION_AFP_READ_LOCK)
1202             ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, reqcount, ofork->of_refnum);
1203         return cc;
1204     }
1205
1206     offset += cc;
1207
1208 #if 0 /*def HAVE_SENDFILE_WRITE*/
1209     if ((cc = ad_writefile(ofork->of_ad, eid, dsi->socket, offset, dsi->datasize)) < 0) {
1210         switch (errno) {
1211         case EDQUOT:
1212         case EFBIG:
1213         case ENOSPC:
1214             cc = AFPERR_DFULL;
1215             break;
1216         default:
1217             LOG(log_error, logtype_afpd, "afp_write: ad_writefile: %s", strerror(errno) );
1218             goto afp_write_loop;
1219         }
1220         dsi_writeflush(dsi);
1221         *rbuflen = 0;
1222         if (obj->options.flags & OPTION_AFP_READ_LOCK)
1223             ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, reqcount,  ofork->of_refnum);
1224         return cc;
1225     }
1226
1227     offset += cc;
1228     goto afp_write_done;
1229 #endif /* 0, was HAVE_SENDFILE_WRITE */
1230
1231     /* loop until everything gets written. currently
1232      * dsi_write handles the end case by itself. */
1233     while ((cc = dsi_write(dsi, rcvbuf, rcvbuflen))) {
1234
1235         if ((cc = write_file(ofork, eid, offset, rcvbuf, cc)) < 0) {
1236             dsi_writeflush(dsi);
1237             *rbuflen = 0;
1238             if (obj->options.flags & OPTION_AFP_READ_LOCK)
1239                 ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, reqcount,  ofork->of_refnum);
1240             return cc;
1241         }
1242
1243         LOG(log_debug, logtype_afpd, "afp_write: wrote: %jd, offset: %jd",
1244             (intmax_t)cc, (intmax_t)offset);
1245
1246         offset += cc;
1247     }
1248
1249     if (obj->options.flags & OPTION_AFP_READ_LOCK)
1250         ad_tmplock(ofork->of_ad, eid, ADLOCK_CLR, saveoff, reqcount,  ofork->of_refnum);
1251     if ( ad_meta_fileno( ofork->of_ad ) != -1 ) /* META */
1252         ofork->of_flags |= AFPFORK_DIRTY;
1253
1254     /* we have modified any fork, remember until close_fork */
1255     ofork->of_flags |= AFPFORK_MODIFIED;
1256
1257     /* update write count */
1258     ofork->of_vol->v_appended += (newsize > oldsize) ? (newsize - oldsize) : 0;
1259
1260     *rbuflen = set_off_t (offset, rbuf, is64);
1261     return( AFP_OK );
1262
1263 afp_write_err:
1264     dsi_writeinit(obj->dsi, rbuf, *rbuflen);
1265     dsi_writeflush(obj->dsi);
1266
1267     if (err != AFP_OK) {
1268         *rbuflen = 0;
1269     }
1270     return err;
1271 }
1272
1273 /* ---------------------------- */
1274 int afp_write(AFPObj *obj, char *ibuf, size_t ibuflen, char *rbuf, size_t *rbuflen)
1275 {
1276     return write_fork(obj, ibuf, ibuflen, rbuf, rbuflen, 0);
1277 }
1278
1279 /* ----------------------------
1280  * FIXME need to deal with SIGXFSZ signal
1281  */
1282 int afp_write_ext(AFPObj *obj, char *ibuf, size_t ibuflen, char *rbuf, size_t *rbuflen)
1283 {
1284     return write_fork(obj, ibuf, ibuflen, rbuf, rbuflen, 1);
1285 }
1286
1287 /* ---------------------------- */
1288 int afp_getforkparams(AFPObj *obj, char *ibuf, size_t ibuflen _U_, char *rbuf, size_t *rbuflen)
1289 {
1290     struct ofork    *ofork;
1291     int             ret;
1292     uint16_t       ofrefnum, bitmap;
1293     size_t          buflen;
1294     ibuf += 2;
1295     memcpy(&ofrefnum, ibuf, sizeof( ofrefnum ));
1296     ibuf += sizeof( ofrefnum );
1297     memcpy(&bitmap, ibuf, sizeof( bitmap ));
1298     bitmap = ntohs( bitmap );
1299     ibuf += sizeof( bitmap );
1300
1301     *rbuflen = 0;
1302     if (NULL == ( ofork = of_find( ofrefnum )) ) {
1303         LOG(log_error, logtype_afpd, "afp_getforkparams: of_find(%d) could not locate fork", ofrefnum );
1304         return( AFPERR_PARAM );
1305     }
1306
1307     if (AD_META_OPEN(ofork->of_ad)) {
1308         if ( ad_refresh(NULL, ofork->of_ad ) < 0 ) {
1309             LOG(log_error, logtype_afpd, "getforkparams(%s): ad_refresh: %s", of_name(ofork), strerror(errno) );
1310             return( AFPERR_PARAM );
1311         }
1312     }
1313
1314     if (AFP_OK != (ret = getforkparams(obj, ofork, bitmap, rbuf + sizeof( u_short ), &buflen ))) {
1315         return( ret );
1316     }
1317
1318     *rbuflen = buflen + sizeof( u_short );
1319     bitmap = htons( bitmap );
1320     memcpy(rbuf, &bitmap, sizeof( bitmap ));
1321     return( AFP_OK );
1322 }
1323