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