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