etc/afpd/fork.c

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