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