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