etc/afpd/fork.c

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