viced: Improve CallPreamble error messages
[openafs.git] / src / viced / afsfileprocs.c
1 /*
2  * Copyright 2000, International Business Machines Corporation and others.
3  * All Rights Reserved.
4  *
5  * This software has been released under the terms of the IBM Public
6  * License.  For details, see the LICENSE file in the top-level source
7  * directory or online at http://www.openafs.org/dl/license10.html
8  */
9
10 /*  afs_fileprocs.c - Complete File Server request routines              */
11 /*                                                                       */
12 /*  Information Technology Center                                        */
13 /*  Carnegie Mellon University                                           */
14 /*                                                                       */
15 /*  Date: 8/10/88                                                        */
16 /*                                                                       */
17 /*  Function    - A set of routines to handle the various file Server    */
18 /*                  requests; these routines are invoked by rxgen.       */
19 /*                                                                       */
20 /* ********************************************************************** */
21
22 /*
23  * GetVolumePackage disables Rx keepalives; PutVolumePackage re-enables.
24  * If callbacks are to be broken, keepalives should be enabled in the
25  * stub while that occurs; disabled while disk I/O is in process.
26  */
27
28 /*
29  * in Check_PermissionRights, certain privileges are afforded to the owner
30  * of the volume, or the owner of a file.  Are these considered "use of
31  * privilege"?
32  */
33
34 #include <afsconfig.h>
35 #include <afs/param.h>
36 #include <afs/stds.h>
37
38 #include <roken.h>
39
40 #ifdef  AFS_SGI_ENV
41 #undef SHARED                   /* XXX */
42 #endif
43
44 #ifdef HAVE_NET_IF_H
45 #include <net/if.h>
46 #endif
47
48 #ifdef HAVE_NETINET_IF_ETHER_H
49 #include <netinet/if_ether.h>
50 #endif
51
52 #if !defined(AFS_SGI_ENV) && defined(HAVE_SYS_MAP_H)
53 #include <sys/map.h>
54 #endif
55
56 #ifdef HAVE_SYS_STATFS_H
57 #include <sys/statfs.h>
58 #endif
59
60 #ifdef HAVE_SYS_LOCKF_H
61 #include <sys/lockf.h>
62 #endif
63
64 #ifdef HAVE_SYS_DK_H
65 #include <sys/dk.h>
66 #endif
67
68 #ifdef AFS_HPUX_ENV
69 /* included early because of name conflict on IOPEN */
70 #include <sys/inode.h>
71 #ifdef IOPEN
72 #undef IOPEN
73 #endif
74 #endif /* AFS_HPUX_ENV */
75
76 #include <afs/opr.h>
77 #include <rx/rx_queue.h>
78 #include <opr/lock.h>
79 #include <afs/nfs.h>
80 #include <afs/afsint.h>
81 #include <afs/vldbint.h>
82 #include <afs/errors.h>
83 #include <afs/ihandle.h>
84 #include <afs/vnode.h>
85 #include <afs/volume.h>
86 #include <afs/ptclient.h>
87 #include <afs/ptuser.h>
88 #include <afs/prs_fs.h>
89 #include <afs/acl.h>
90 #include <rx/rx.h>
91 #include <rx/rx_globals.h>
92
93 #include <afs/cellconfig.h>
94 #include <afs/keys.h>
95
96 #include <afs/partition.h>
97 #include "viced_prototypes.h"
98 #include "viced.h"
99 #include "host.h"
100 #include "callback.h"
101 #include <afs/unified_afs.h>
102 #include <afs/audit.h>
103 #include <afs/afsutil.h>
104 #include <afs/dir.h>
105
106 extern void SetDirHandle(DirHandle * dir, Vnode * vnode);
107 extern void FidZap(DirHandle * file);
108 extern void FidZero(DirHandle * file);
109
110 pthread_mutex_t fileproc_glock_mutex;
111
112 /* Useful local defines used by this module */
113
114 #define DONTCHECK       0
115 #define MustNOTBeDIR    1
116 #define MustBeDIR       2
117
118 #define TVS_SDATA       1
119 #define TVS_SSTATUS     2
120 #define TVS_CFILE       4
121 #define TVS_SLINK       8
122 #define TVS_MKDIR       0x10
123
124 #define CHK_FETCH       0x10
125 #define CHK_FETCHDATA   0x10
126 #define CHK_FETCHACL    0x11
127 #define CHK_FETCHSTATUS 0x12
128 #define CHK_STOREDATA   0x00
129 #define CHK_STOREACL    0x01
130 #define CHK_STORESTATUS 0x02
131
132 #define OWNERREAD       0400
133 #define OWNERWRITE      0200
134 #define OWNEREXEC       0100
135 #ifdef USE_GROUP_PERMS
136 #define GROUPREAD       0040
137 #define GROUPWRITE      0020
138 #define GROUPREXEC      0010
139 #endif
140
141 /* The following errors were not defined in NT. They are given unique
142  * names here to avoid any potential collision.
143  */
144 #define FSERR_ELOOP              90
145 #define FSERR_EOPNOTSUPP        122
146 #define FSERR_ECONNREFUSED      130
147
148 #define NOTACTIVECALL   0
149 #define ACTIVECALL      1
150
151 #define CREATE_SGUID_ADMIN_ONLY 1
152
153 extern struct afsconf_dir *confDir;
154 extern afs_int32 dataVersionHigh;
155
156 extern int SystemId;
157 static struct AFSCallStatistics AFSCallStats;
158 struct fs_stats_FullPerfStats afs_FullPerfStats;
159 extern int AnonymousID;
160 static const char nullString[] = "";
161
162 struct afs_FSStats {
163     afs_int32 NothingYet;
164 };
165
166 struct afs_FSStats afs_fsstats;
167
168 int LogLevel = 0;
169 int supported = 1;
170 int Console = 0;
171 afs_int32 BlocksSpare = 1024;   /* allow 1 MB overruns */
172 afs_int32 PctSpare;
173 extern afs_int32 implicitAdminRights;
174 extern afs_int32 readonlyServer;
175 extern int CopyOnWrite_calls, CopyOnWrite_off0, CopyOnWrite_size0;
176 extern afs_fsize_t CopyOnWrite_maxsize;
177
178 /*
179  * Externals used by the xstat code.
180  */
181 extern VolPkgStats VStats;
182 extern int CEs, CEBlocks;
183
184 extern int HTs, HTBlocks;
185
186 static afs_int32 FetchData_RXStyle(Volume * volptr, Vnode * targetptr,
187                                    struct rx_call *Call, afs_sfsize_t Pos,
188                                    afs_sfsize_t Len, afs_int32 Int64Mode,
189                                    afs_sfsize_t * a_bytesToFetchP,
190                                    afs_sfsize_t * a_bytesFetchedP);
191
192 static afs_int32 StoreData_RXStyle(Volume * volptr, Vnode * targetptr,
193                                    struct AFSFid *Fid, struct client *client,
194                                    struct rx_call *Call, afs_fsize_t Pos,
195                                    afs_fsize_t Length, afs_fsize_t FileLength,
196                                    int sync,
197                                    afs_sfsize_t * a_bytesToStoreP,
198                                    afs_sfsize_t * a_bytesStoredP);
199
200 #ifdef AFS_SGI_XFS_IOPS_ENV
201 #include <afs/xfsattrs.h>
202 static int
203 GetLinkCount(Volume * avp, struct stat *astat)
204 {
205     if (!strcmp("xfs", astat->st_fstype)) {
206         return (astat->st_mode & AFS_XFS_MODE_LINK_MASK);
207     } else
208         return astat->st_nlink;
209 }
210 #else
211 #define GetLinkCount(V, S) (S)->st_nlink
212 #endif
213
214 afs_int32
215 SpareComp(Volume * avolp)
216 {
217     afs_int32 temp;
218
219     FS_LOCK;
220     if (PctSpare) {
221         temp = V_maxquota(avolp);
222         if (temp == 0) {
223             /* no matter; doesn't check in this case */
224             FS_UNLOCK;
225             return 0;
226         }
227         temp = (temp * PctSpare) / 100;
228         FS_UNLOCK;
229         return temp;
230     } else {
231         FS_UNLOCK;
232         return BlocksSpare;
233     }
234
235 }                               /*SpareComp */
236
237 /*
238  * Set the volume synchronization parameter for this volume.  If it changes,
239  * the Cache Manager knows that the volume must be purged from the stat cache.
240  */
241 static void
242 SetVolumeSync(struct AFSVolSync *async, Volume * avol)
243 {
244     FS_LOCK;
245     /* date volume instance was created */
246     if (async) {
247         if (avol)
248             async->spare1 = V_creationDate(avol);
249         else
250             async->spare1 = 0;
251         async->spare2 = 0;
252         async->spare3 = 0;
253         async->spare4 = 0;
254         async->spare5 = 0;
255         async->spare6 = 0;
256     }
257     FS_UNLOCK;
258 }                               /*SetVolumeSync */
259
260 /**
261  * Verify that the on-disk size for a vnode matches the length in the vnode
262  * index.
263  *
264  * @param[in] vp   Volume pointer
265  * @param[in] vnp  Vnode pointer
266  * @param[in] alen Size of the vnode on disk, if known. If unknown, give -1,
267  *                 and CheckLength itself will determine the on-disk size.
268  *
269  * @return operation status
270  *  @retval 0 lengths match
271  *  @retval nonzero Error; either the lengths do not match or there was an
272  *                  error determining the on-disk size. The volume should be
273  *                  taken offline and salvaged.
274  */
275 static int
276 CheckLength(struct Volume *vp, struct Vnode *vnp, afs_sfsize_t alen)
277 {
278     afs_sfsize_t vlen;
279     VN_GET_LEN(vlen, vnp);
280
281     if (alen < 0) {
282         FdHandle_t *fdP;
283
284         fdP = IH_OPEN(vnp->handle);
285         if (fdP == NULL) {
286             ViceLog(0, ("CheckLength: cannot open inode for fid %" AFS_VOLID_FMT ".%lu.%lu\n",
287                         afs_printable_VolumeId_lu(vp->hashid),
288                         afs_printable_uint32_lu(Vn_id(vnp)),
289                         afs_printable_uint32_lu(vnp->disk.uniquifier)));
290             return -1;
291         }
292         alen = FDH_SIZE(fdP);
293         FDH_CLOSE(fdP);
294         if (alen < 0) {
295             afs_int64 alen64 = alen;
296             ViceLog(0, ("CheckLength: cannot get size for inode for fid %"
297                         AFS_VOLID_FMT ".%lu.%lu; FDH_SIZE returned %" AFS_INT64_FMT "\n",
298                         afs_printable_VolumeId_lu(vp->hashid),
299                         afs_printable_uint32_lu(Vn_id(vnp)),
300                         afs_printable_uint32_lu(vnp->disk.uniquifier),
301                         alen64));
302             return -1;
303         }
304     }
305
306     if (alen != vlen) {
307         afs_int64 alen64 = alen, vlen64 = vlen;
308         ViceLog(0, ("Fid %" AFS_VOLID_FMT ".%lu.%lu has inconsistent length (index "
309                     "%lld inode %lld ); volume must be salvaged\n",
310                     afs_printable_VolumeId_lu(vp->hashid),
311                     afs_printable_uint32_lu(Vn_id(vnp)),
312                     afs_printable_uint32_lu(vnp->disk.uniquifier),
313                     vlen64, alen64));
314         return -1;
315     }
316     return 0;
317 }
318
319 /*
320  * Note that this function always returns a held host, so
321  * that CallPostamble can block without the host's disappearing.
322  * Call returns rx connection in passed in *tconn
323  */
324 static int
325 CallPreamble(struct rx_call *acall, int activecall,
326              struct rx_connection **tconn, struct host **ahostp)
327 {
328     struct host *thost;
329     struct client *tclient;
330     int retry_flag = 1;
331     int code = 0;
332     char hoststr[16], hoststr2[16];
333     struct ubik_client *uclient;
334     *ahostp = NULL;
335
336     if (!tconn) {
337         ViceLog(0, ("CallPreamble: unexpected null tconn!\n"));
338         return -1;
339     }
340     *tconn = rx_ConnectionOf(acall);
341
342     H_LOCK;
343   retry:
344     tclient = h_FindClient_r(*tconn);
345     if (!tclient) {
346         ViceLog(0, ("CallPreamble: Couldn't get client struct for host "
347                     "%s:%d, sending busy signal\n",
348                     afs_inet_ntoa_r(rx_HostOf(rx_PeerOf(*tconn)), hoststr),
349                     (int)ntohs(rx_PortOf(rx_PeerOf(*tconn)))));
350         H_UNLOCK;
351         return VBUSY;
352     }
353     thost = tclient->host;
354     if (tclient->prfail == 1) { /* couldn't get the CPS */
355         if (!retry_flag) {
356             h_ReleaseClient_r(tclient);
357             h_Release_r(thost);
358             ViceLog(0, ("CallPreamble: Couldn't get CPS for client from host "
359                         "%s:%d, failing request\n",
360                         afs_inet_ntoa_r(thost->host, hoststr),
361                         (int)ntohs(thost->port)));
362             H_UNLOCK;
363             return -1001;
364         }
365         retry_flag = 0;         /* Retry once */
366
367         /* Take down the old connection and re-read the key file */
368         ViceLog(0,
369                 ("CallPreamble: Couldn't get CPS. Reconnect to ptserver\n"));
370         uclient = (struct ubik_client *)pthread_getspecific(viced_uclient_key);
371
372         /* Is it still necessary to drop this? We hit the net, we should... */
373         H_UNLOCK;
374         if (uclient) {
375             hpr_End(uclient);
376             uclient = NULL;
377         }
378         code = hpr_Initialize(&uclient);
379
380         if (!code)
381             opr_Verify(pthread_setspecific(viced_uclient_key,
382                                            (void *)uclient) == 0);
383         H_LOCK;
384
385         if (code) {
386             h_ReleaseClient_r(tclient);
387             h_Release_r(thost);
388             H_UNLOCK;
389             ViceLog(0, ("CallPreamble: couldn't reconnect to ptserver while "
390                         "handling request for %s:%d\n",
391                         afs_inet_ntoa_r(thost->host, hoststr),
392                         (int)ntohs(thost->port)));
393             return -1001;
394         }
395
396         tclient->prfail = 2;    /* Means re-eval client's cps */
397         h_ReleaseClient_r(tclient);
398         h_Release_r(thost);
399         goto retry;
400     }
401
402     tclient->LastCall = thost->LastCall = time(NULL);
403     if (activecall)             /* For all but "GetTime", "GetStats", and "GetCaps" calls */
404         thost->ActiveCall = thost->LastCall;
405
406     h_Lock_r(thost);
407     if (thost->hostFlags & HOSTDELETED) {
408         ViceLog(3,
409                 ("Discarded a packet for deleted host %s:%d\n",
410                  afs_inet_ntoa_r(thost->host, hoststr), ntohs(thost->port)));
411         code = VBUSY;           /* raced, so retry */
412     } else if ((thost->hostFlags & VENUSDOWN)
413                || (thost->hostFlags & HFE_LATER)) {
414         if (BreakDelayedCallBacks_r(thost)) {
415             ViceLog(0,
416                     ("BreakDelayedCallbacks FAILED for host %s:%d which IS UP.  Connection from %s:%d.  Possible network or routing failure.\n",
417                      afs_inet_ntoa_r(thost->host, hoststr), ntohs(thost->port), afs_inet_ntoa_r(rxr_HostOf(*tconn), hoststr2),
418                      ntohs(rxr_PortOf(*tconn))));
419             if (MultiProbeAlternateAddress_r(thost)) {
420                 ViceLog(0,
421                         ("MultiProbe failed to find new address for host %s:%d\n",
422                          afs_inet_ntoa_r(thost->host, hoststr),
423                          ntohs(thost->port)));
424                 code = -1;
425             } else {
426                 ViceLog(0,
427                         ("MultiProbe found new address for host %s:%d\n",
428                          afs_inet_ntoa_r(thost->host, hoststr),
429                          ntohs(thost->port)));
430                 if (BreakDelayedCallBacks_r(thost)) {
431                     ViceLog(0,
432                             ("BreakDelayedCallbacks FAILED AGAIN for host %s:%d which IS UP.  Connection from %s:%d.  Possible network or routing failure.\n",
433                               afs_inet_ntoa_r(thost->host, hoststr), ntohs(thost->port), afs_inet_ntoa_r(rxr_HostOf(*tconn), hoststr2),
434                               ntohs(rxr_PortOf(*tconn))));
435                     code = -1;
436                 }
437             }
438         }
439     } else {
440         code = 0;
441     }
442
443     h_ReleaseClient_r(tclient);
444     h_Unlock_r(thost);
445     H_UNLOCK;
446     *ahostp = thost;
447     return code;
448
449 }                               /*CallPreamble */
450
451
452 static afs_int32
453 CallPostamble(struct rx_connection *aconn, afs_int32 ret,
454               struct host *ahost)
455 {
456     struct host *thost;
457     struct client *tclient;
458     int translate = 0;
459
460     H_LOCK;
461     tclient = h_FindClient_r(aconn);
462     if (!tclient)
463         goto busyout;
464     thost = tclient->host;
465     if (thost->hostFlags & HERRORTRANS)
466         translate = 1;
467     h_ReleaseClient_r(tclient);
468
469     if (ahost) {
470             if (ahost != thost) {
471                     /* host/client recycle */
472                     char hoststr[16], hoststr2[16];
473                     ViceLog(0, ("CallPostamble: ahost %s:%d (%p) != thost "
474                                 "%s:%d (%p)\n",
475                                 afs_inet_ntoa_r(ahost->host, hoststr),
476                                 ntohs(ahost->port),
477                                 ahost,
478                                 afs_inet_ntoa_r(thost->host, hoststr2),
479                                 ntohs(thost->port),
480                                 thost));
481             }
482             /* return the reference taken in CallPreamble */
483             h_Release_r(ahost);
484     } else {
485             char hoststr[16];
486             ViceLog(0, ("CallPostamble: null ahost for thost %s:%d (%p)\n",
487                         afs_inet_ntoa_r(thost->host, hoststr),
488                         ntohs(thost->port),
489                         thost));
490     }
491
492     /* return the reference taken in local h_FindClient_r--h_ReleaseClient_r
493      * does not decrement refcount on client->host */
494     h_Release_r(thost);
495
496  busyout:
497     H_UNLOCK;
498     return (translate ? sys_error_to_et(ret) : ret);
499 }                               /*CallPostamble */
500
501 /*
502  * Returns the volume and vnode pointers associated with file Fid; the lock
503  * type on the vnode is set to lock. Note that both volume/vnode's ref counts
504  * are incremented and they must be eventualy released.
505  */
506 static afs_int32
507 CheckVnodeWithCall(AFSFid * fid, Volume ** volptr, struct VCallByVol *cbv,
508                    Vnode ** vptr, int lock)
509 {
510     Error fileCode = 0;
511     Error local_errorCode, errorCode = -1;
512     static struct timeval restartedat = { 0, 0 };
513
514     if (fid->Volume == 0 || fid->Vnode == 0)    /* not: || fid->Unique == 0) */
515         return (EINVAL);
516     if ((*volptr) == 0) {
517         extern int VInit;
518
519         while (1) {
520             int restarting =
521 #ifdef AFS_DEMAND_ATTACH_FS
522                 VSALVAGE
523 #else
524                 VRESTARTING
525 #endif
526                 ;
527             static const struct timespec timeout_ts = { 0, 0 };
528             static const struct timespec * const ts = &timeout_ts;
529
530             errorCode = 0;
531             *volptr = VGetVolumeWithCall(&local_errorCode, &errorCode,
532                                                fid->Volume, ts, cbv);
533             if (!errorCode) {
534                 opr_Assert(*volptr);
535                 break;
536             }
537             if ((errorCode == VOFFLINE) && (VInit < 2)) {
538                 /* The volume we want may not be attached yet because
539                  * the volume initialization is not yet complete.
540                  * We can do several things:
541                  *     1.  return -1, which will cause users to see
542                  *         "connection timed out".  This is more or
543                  *         less the same as always, except that the servers
544                  *         may appear to bounce up and down while they
545                  *         are actually restarting.
546                  *     2.  return VBUSY which will cause clients to
547                  *         sleep and retry for 6.5 - 15 minutes, depending
548                  *         on what version of the CM they are running.  If
549                  *         the file server takes longer than that interval
550                  *         to attach the desired volume, then the application
551                  *         will see an ENODEV or EIO.  This approach has
552                  *         the advantage that volumes which have been attached
553                  *         are immediately available, it keeps the server's
554                  *         immediate backlog low, and the call is interruptible
555                  *         by the user.  Users see "waiting for busy volume."
556                  *     3.  sleep here and retry.  Some people like this approach
557                  *         because there is no danger of seeing errors.  However,
558                  *         this approach only works with a bounded number of
559                  *         clients, since the pending queues will grow without
560                  *         stopping.  It might be better to find a way to take
561                  *         this call and stick it back on a queue in order to
562                  *         recycle this thread for a different request.
563                  *     4.  Return a new error code, which new cache managers will
564                  *         know enough to interpret as "sleep and retry", without
565                  *         the upper bound of 6-15 minutes that is imposed by the
566                  *         VBUSY handling.  Users will see "waiting for
567                  *         busy volume," so they know that something is
568                  *         happening.  Old cache managers must be able to do
569                  *         something reasonable with this, for instance, mark the
570                  *         server down.  Fortunately, any error code < 0
571                  *         will elicit that behavior. See #1.
572                  *     5.  Some combination of the above.  I like doing #2 for 10
573                  *         minutes, followed by #4.  3.1b and 3.2 cache managers
574                  *         will be fine as long as the restart period is
575                  *         not longer than 6.5 minutes, otherwise they may
576                  *         return ENODEV to users.  3.3 cache managers will be
577                  *         fine for 10 minutes, then will return
578                  *         ETIMEDOUT.  3.4 cache managers will just wait
579                  *         until the call works or fails definitively.
580                  *  NB. The problem with 2,3,4,5 is that old clients won't
581                  *  fail over to an alternate read-only replica while this
582                  *  server is restarting.  3.4 clients will fail over right away.
583                  */
584                 if (restartedat.tv_sec == 0) {
585                     /* I'm not really worried about when we restarted, I'm   */
586                     /* just worried about when the first VBUSY was returned. */
587                     gettimeofday(&restartedat, 0);
588                     if (busyonrst) {
589                         FS_LOCK;
590                         afs_perfstats.fs_nBusies++;
591                         FS_UNLOCK;
592                     }
593                     return (busyonrst ? VBUSY : restarting);
594                 } else {
595                     struct timeval now;
596                     gettimeofday(&now, 0);
597                     if ((now.tv_sec - restartedat.tv_sec) < (11 * 60)) {
598                         if (busyonrst) {
599                             FS_LOCK;
600                             afs_perfstats.fs_nBusies++;
601                             FS_UNLOCK;
602                         }
603                         return (busyonrst ? VBUSY : restarting);
604                     } else {
605                         return (restarting);
606                     }
607                 }
608             }
609             /* allow read operations on busy volume.
610              * must check local_errorCode because demand attach fs
611              * can have local_errorCode == VSALVAGING, errorCode == VBUSY */
612             else if (local_errorCode == VBUSY && lock == READ_LOCK) {
613 #ifdef AFS_DEMAND_ATTACH_FS
614                 /* DAFS case is complicated by the fact that local_errorCode can
615                  * be VBUSY in cases where the volume is truly offline */
616                 if (!*volptr) {
617                     /* volume is in VOL_STATE_UNATTACHED */
618                     return (errorCode);
619                 }
620 #endif /* AFS_DEMAND_ATTACH_FS */
621                 errorCode = 0;
622                 break;
623             } else if (errorCode)
624                 return (errorCode);
625         }
626     }
627     opr_Assert(*volptr);
628
629     /* get the vnode  */
630     *vptr = VGetVnode(&errorCode, *volptr, fid->Vnode, lock);
631     if (errorCode)
632         return (errorCode);
633     if ((*vptr)->disk.uniquifier != fid->Unique) {
634         VPutVnode(&fileCode, *vptr);
635         opr_Assert(fileCode == 0);
636         *vptr = 0;
637         return (VNOVNODE);      /* return the right error code, at least */
638     }
639     return (0);
640 }                               /*CheckVnode */
641
642 static_inline afs_int32
643 CheckVnode(AFSFid * fid, Volume ** volptr, Vnode ** vptr, int lock)
644 {
645     return CheckVnodeWithCall(fid, volptr, NULL, vptr, lock);
646 }
647
648 /*
649  * This routine returns the ACL associated with the targetptr. If the
650  * targetptr isn't a directory, we access its parent dir and get the ACL
651  * thru the parent; in such case the parent's vnode is returned in
652  * READ_LOCK mode.
653  */
654 static afs_int32
655 SetAccessList(Vnode ** targetptr, Volume ** volume,
656               struct acl_accessList **ACL, int *ACLSize, Vnode ** parent,
657               AFSFid * Fid, int Lock)
658 {
659     if ((*targetptr)->disk.type == vDirectory) {
660         *parent = 0;
661         *ACL = VVnodeACL(*targetptr);
662         *ACLSize = VAclSize(*targetptr);
663         return (0);
664     } else {
665         opr_Assert(Fid != 0);
666         while (1) {
667             VnodeId parentvnode;
668             Error errorCode = 0;
669
670             parentvnode = (*targetptr)->disk.parent;
671             VPutVnode(&errorCode, *targetptr);
672             *targetptr = 0;
673             if (errorCode)
674                 return (errorCode);
675             *parent = VGetVnode(&errorCode, *volume, parentvnode, READ_LOCK);
676             if (errorCode)
677                 return (errorCode);
678             *ACL = VVnodeACL(*parent);
679             *ACLSize = VAclSize(*parent);
680             if ((errorCode = CheckVnode(Fid, volume, targetptr, Lock)) != 0)
681                 return (errorCode);
682             if ((*targetptr)->disk.parent != parentvnode) {
683                 VPutVnode(&errorCode, *parent);
684                 *parent = 0;
685                 if (errorCode)
686                     return (errorCode);
687             } else
688                 return (0);
689         }
690     }
691
692 }                               /*SetAccessList */
693
694 /* Must not be called with H_LOCK held */
695 static void
696 client_CheckRights(struct client *client, struct acl_accessList *ACL,
697                    afs_int32 *rights)
698 {
699     *rights = 0;
700     ObtainReadLock(&client->lock);
701     if (client->CPS.prlist_len > 0 && !client->deleted &&
702         client->host && !(client->host->hostFlags & HOSTDELETED))
703         acl_CheckRights(ACL, &client->CPS, rights);
704     ReleaseReadLock(&client->lock);
705 }
706
707 /* Must not be called with H_LOCK held */
708 static afs_int32
709 client_HasAsMember(struct client *client, afs_int32 id)
710 {
711     afs_int32 code = 0;
712
713     ObtainReadLock(&client->lock);
714     if (client->CPS.prlist_len > 0 && !client->deleted &&
715         client->host && !(client->host->hostFlags & HOSTDELETED))
716         code = acl_IsAMember(id, &client->CPS);
717     ReleaseReadLock(&client->lock);
718     return code;
719 }
720
721 /*
722  * Compare the directory's ACL with the user's access rights in the client
723  * connection and return the user's and everybody else's access permissions
724  * in rights and anyrights, respectively
725  */
726 static afs_int32
727 GetRights(struct client *client, struct acl_accessList *ACL,
728           afs_int32 * rights, afs_int32 * anyrights)
729 {
730     extern prlist SystemAnyUserCPS;
731     afs_int32 hrights = 0;
732
733     if (acl_CheckRights(ACL, &SystemAnyUserCPS, anyrights) != 0) {
734         ViceLog(0, ("CheckRights failed\n"));
735         *anyrights = 0;
736     }
737     *rights = 0;
738
739     client_CheckRights(client, ACL, rights);
740
741     /* wait if somebody else is already doing the getCPS call */
742     H_LOCK;
743     while (client->host->hostFlags & HCPS_INPROGRESS) {
744         client->host->hostFlags |= HCPS_WAITING;        /* I am waiting */
745         opr_cv_wait(&client->host->cond, &host_glock_mutex);
746     }
747
748     if (!client->host->hcps.prlist_len || !client->host->hcps.prlist_val) {
749         char hoststr[16];
750         ViceLog(5,
751                 ("CheckRights: len=%u, for host=%s:%d\n",
752                  client->host->hcps.prlist_len,
753                  afs_inet_ntoa_r(client->host->host, hoststr),
754                  ntohs(client->host->port)));
755     } else
756         acl_CheckRights(ACL, &client->host->hcps, &hrights);
757     H_UNLOCK;
758     /* Allow system:admin the rights given with the -implicit option */
759     if (client_HasAsMember(client, SystemId))
760         *rights |= implicitAdminRights;
761
762     *rights |= hrights;
763     *anyrights |= hrights;
764
765     return (0);
766
767 }                               /*GetRights */
768
769 /*
770  * VanillaUser returns 1 (true) if the user is a vanilla user (i.e., not
771  * a System:Administrator)
772  */
773 static afs_int32
774 VanillaUser(struct client *client)
775 {
776     if (client_HasAsMember(client, SystemId))
777         return (0);             /* not a system administrator, then you're "vanilla" */
778     return (1);
779
780 }                               /*VanillaUser */
781
782
783 /*------------------------------------------------------------------------
784  * GetVolumePackageWithCall
785  *
786  * Description:
787  *      This unusual afs_int32-parameter routine encapsulates all volume
788  *      package related operations together in a single function; it's
789  *      called by almost all AFS interface calls.
790  *
791  * Arguments:
792  *      acall               : Ptr to Rx call on which this request came in.
793  *      cbv                 : struct containing the RX call for offline cancels
794  *      Fid                 : the AFS fid the caller is acting on
795  *      volptr              : returns a pointer to the volume struct
796  *      targetptr           : returns a pointer to the vnode struct
797  *      chkforDir           : whether to check for if vnode is a dir
798  *      parent              : returns a pointer to the parent of this vnode
799  *      client              : returns a pointer to the calling client
800  *      locktype            : indicates what kind of lock to take on vnodes
801  *      rights              : returns a pointer to caller's rights
802  *      anyrights           : returns a pointer to anonymous' rights
803  *      remote              : indicates that the volume is a remote RW replica
804  *
805  * Returns:
806  *      0 on success
807  *      appropriate error based on permission or invalid operation.
808  *
809  * Environment:
810  *      Nothing interesting.
811  *
812  * Side Effects:
813  *      On success, disables keepalives on the call. Caller should re-enable
814  *      after completing disk I/O.
815  *------------------------------------------------------------------------*/
816 static afs_int32
817 GetVolumePackageWithCall(struct rx_call *acall, struct VCallByVol *cbv,
818                          AFSFid * Fid, Volume ** volptr, Vnode ** targetptr,
819                          int chkforDir, Vnode ** parent,
820                          struct client **client, int locktype,
821                          afs_int32 * rights, afs_int32 * anyrights, int remote)
822 {
823     struct acl_accessList *aCL = NULL;  /* Internal access List */
824     int aCLSize;                /* size of the access list */
825     Error errorCode = 0;                /* return code to caller */
826     struct rx_connection *tcon = rx_ConnectionOf(acall);
827
828     rx_KeepAliveOff(acall);
829
830     if ((errorCode = CheckVnodeWithCall(Fid, volptr, cbv, targetptr, locktype)))
831         goto gvpdone;
832
833     if (chkforDir) {
834         if (chkforDir == MustNOTBeDIR
835             && ((*targetptr)->disk.type == vDirectory)) {
836             errorCode = EISDIR;
837             goto gvpdone;
838         }
839         else if (chkforDir == MustBeDIR
840                  && ((*targetptr)->disk.type != vDirectory)) {
841             errorCode = ENOTDIR;
842             goto gvpdone;
843         }
844     }
845     /*
846      * If the remote flag is set, the current call is dealing with a remote RW
847      * replica, and it can be assumed that the appropriate access checks were
848      * done by the calling server hosting the master volume.
849      */
850     if (!remote) {
851         if ((errorCode = SetAccessList(targetptr, volptr, &aCL, &aCLSize, parent,
852                 (chkforDir == MustBeDIR ? (AFSFid *) 0 : Fid),
853                 (chkforDir == MustBeDIR ? 0 : locktype))) != 0)
854             goto gvpdone;
855         if (chkforDir == MustBeDIR)
856             opr_Assert((*parent) == 0);
857         if (!(*client)) {
858             if ((errorCode = GetClient(tcon, client)) != 0)
859                 goto gvpdone;
860             if (!(*client)) {
861                 errorCode = EINVAL;
862                 goto gvpdone;
863             }
864         }
865         GetRights(*client, aCL, rights, anyrights);
866         /* ok, if this is not a dir, set the PRSFS_ADMINISTER bit iff we're the owner */
867         if ((*targetptr)->disk.type != vDirectory) {
868             /* anyuser can't be owner, so only have to worry about rights, not anyrights */
869             if ((*targetptr)->disk.owner == (*client)->ViceId)
870                 (*rights) |= PRSFS_ADMINISTER;
871             else
872                 (*rights) &= ~PRSFS_ADMINISTER;
873         }
874 #ifdef ADMIN_IMPLICIT_LOOKUP
875         /* admins get automatic lookup on everything */
876         if (!VanillaUser(*client))
877             (*rights) |= PRSFS_LOOKUP;
878 #endif /* ADMIN_IMPLICIT_LOOKUP */
879     }
880 gvpdone:
881     if (errorCode)
882         rx_KeepAliveOn(acall);
883     return errorCode;
884
885 }                               /*GetVolumePackage */
886
887 static_inline afs_int32
888 GetVolumePackage(struct rx_call *acall, AFSFid * Fid, Volume ** volptr,
889                  Vnode ** targetptr, int chkforDir, Vnode ** parent,
890                  struct client **client, int locktype, afs_int32 * rights,
891                  afs_int32 * anyrights)
892 {
893     return GetVolumePackageWithCall(acall, NULL, Fid, volptr, targetptr,
894                                     chkforDir, parent, client, locktype,
895                                     rights, anyrights, 0);
896 }
897
898
899 /*------------------------------------------------------------------------
900  * PutVolumePackageWithCall
901  *
902  * Description:
903  *      This is the opposite of GetVolumePackage(), and is always used at
904  *      the end of AFS calls to put back all used vnodes and the volume
905  *      in the proper order!
906  *
907  * Arguments:
908  *      acall               : Ptr to Rx call on which this request came in.
909  *      parentwhentargetnotdir : a pointer to the parent when the target isn't
910  *                            a directory vnode
911  *      targetptr           : a pointer to the vnode struct
912  *      parentptr           : a pointer to the parent of this vnode
913  *      volptr              : a pointer to the volume structure
914  *      client              : a pointer to the calling client
915  *      cbv                 : struct containing the RX call for offline cancels
916  *
917  * Returns:
918  *      Nothing
919  *
920  * Environment:
921  *      Nothing interesting.
922  *
923  * Side Effects:
924  *      Enables keepalives on the call.
925  *------------------------------------------------------------------------*/
926 static void
927 PutVolumePackageWithCall(struct rx_call *acall, Vnode *
928                          parentwhentargetnotdir, Vnode * targetptr,
929                          Vnode * parentptr, Volume * volptr,
930                          struct client **client, struct VCallByVol *cbv)
931 {
932     Error fileCode = 0;         /* Error code returned by the volume package */
933
934     rx_KeepAliveOff(acall);
935     if (parentwhentargetnotdir) {
936         VPutVnode(&fileCode, parentwhentargetnotdir);
937         opr_Assert(!fileCode || (fileCode == VSALVAGE));
938     }
939     if (targetptr) {
940         VPutVnode(&fileCode, targetptr);
941         opr_Assert(!fileCode || (fileCode == VSALVAGE));
942     }
943     if (parentptr) {
944         VPutVnode(&fileCode, parentptr);
945         opr_Assert(!fileCode || (fileCode == VSALVAGE));
946     }
947     if (volptr) {
948         VPutVolumeWithCall(volptr, cbv);
949     }
950     rx_KeepAliveOn(acall);
951
952     if (*client) {
953         PutClient(client);
954     }
955 }                               /*PutVolumePackage */
956
957 static_inline void
958 PutVolumePackage(struct rx_call *acall, Vnode * parentwhentargetnotdir,
959                  Vnode * targetptr, Vnode * parentptr, Volume * volptr,
960                  struct client **client)
961 {
962     PutVolumePackageWithCall(acall, parentwhentargetnotdir, targetptr,
963                              parentptr, volptr, client, NULL);
964 }
965
966 static int
967 VolumeOwner(struct client *client, Vnode * targetptr)
968 {
969     afs_int32 owner = V_owner(targetptr->volumePtr);    /* get volume owner */
970
971     if (owner >= 0)
972         return (client->ViceId == owner);
973     else {
974         /*
975          * We don't have to check for host's cps since only regular
976          * viceid are volume owners.
977          */
978         return (client_HasAsMember(client, owner));
979     }
980
981 }                               /*VolumeOwner */
982
983 static int
984 VolumeRootVnode(Vnode * targetptr)
985 {
986     return ((targetptr->vnodeNumber == ROOTVNODE)
987             && (targetptr->disk.uniquifier == 1));
988
989 }                               /*VolumeRootVnode */
990
991 /*
992  * Check if target file has the proper access permissions for the Fetch
993  * (FetchData, FetchACL, FetchStatus) and Store (StoreData, StoreACL,
994  * StoreStatus) related calls
995  */
996 /* this code should probably just set a "priv" flag where all the audit events
997  * are now, and only generate the audit event once at the end of the routine,
998  * thus only generating the event if all the checks succeed, but only because
999  * of the privilege       XXX
1000  */
1001 static afs_int32
1002 Check_PermissionRights(Vnode * targetptr, struct client *client,
1003                        afs_int32 rights, int CallingRoutine,
1004                        AFSStoreStatus * InStatus)
1005 {
1006     Error errorCode = 0;
1007 #define OWNSp(client, target) ((client)->ViceId == (target)->disk.owner)
1008 #define CHOWN(i,t) (((i)->Mask & AFS_SETOWNER) &&((i)->Owner != (t)->disk.owner))
1009 #define CHGRP(i,t) (((i)->Mask & AFS_SETGROUP) &&((i)->Group != (t)->disk.group))
1010
1011     if (CallingRoutine & CHK_FETCH) {
1012         if (CallingRoutine == CHK_FETCHDATA || VanillaUser(client)) {
1013             if (targetptr->disk.type == vDirectory
1014                 || targetptr->disk.type == vSymlink) {
1015                 if (!(rights & PRSFS_LOOKUP)
1016 #ifdef ADMIN_IMPLICIT_LOOKUP
1017                     /* grant admins fetch on all directories */
1018                     && VanillaUser(client)
1019 #endif /* ADMIN_IMPLICIT_LOOKUP */
1020                     && !VolumeOwner(client, targetptr))
1021                     return (EACCES);
1022             } else {            /* file */
1023                 /* must have read access, or be owner and have insert access */
1024                 if (!(rights & PRSFS_READ)
1025                     && !((OWNSp(client, targetptr) && (rights & PRSFS_INSERT)
1026                           && (client->ViceId != AnonymousID))))
1027                     return (EACCES);
1028             }
1029             if (CallingRoutine == CHK_FETCHDATA
1030                 && targetptr->disk.type == vFile)
1031 #ifdef USE_GROUP_PERMS
1032                 if (!OWNSp(client, targetptr)
1033                     && !client_HasAsMember(client, targetptr->disk.owner)) {
1034                     errorCode =
1035                         (((GROUPREAD | GROUPEXEC) & targetptr->disk.modeBits)
1036                          ? 0 : EACCES);
1037                 } else {
1038                     errorCode =
1039                         (((OWNERREAD | OWNEREXEC) & targetptr->disk.modeBits)
1040                          ? 0 : EACCES);
1041                 }
1042 #else
1043                 /*
1044                  * The check with the ownership below is a kludge to allow
1045                  * reading of files created with no read permission. The owner
1046                  * of the file is always allowed to read it.
1047                  */
1048                 if ((client->ViceId != targetptr->disk.owner)
1049                     && VanillaUser(client))
1050                     errorCode =
1051                         (((OWNERREAD | OWNEREXEC) & targetptr->disk.
1052                           modeBits) ? 0 : EACCES);
1053 #endif
1054         } else {                /*  !VanillaUser(client) && !FetchData */
1055
1056             osi_audit(PrivilegeEvent, 0, AUD_ID,
1057                       (client ? client->ViceId : 0), AUD_INT, CallingRoutine,
1058                       AUD_END);
1059         }
1060     } else {                    /* a store operation */
1061         if ((rights & PRSFS_INSERT) && OWNSp(client, targetptr)
1062             && (CallingRoutine != CHK_STOREACL)
1063             && (targetptr->disk.type == vFile)) {
1064             /* bypass protection checks on first store after a create
1065              * for the creator; also prevent chowns during this time
1066              * unless you are a system administrator */
1067           /******  InStatus->Owner && UnixModeBits better be SET!! */
1068             if (CHOWN(InStatus, targetptr) || CHGRP(InStatus, targetptr)) {
1069                 if (readonlyServer)
1070                     return (VREADONLY);
1071                 else if (VanillaUser(client))
1072                     return (EPERM);     /* Was EACCES */
1073                 else
1074                     osi_audit(PrivilegeEvent, 0, AUD_ID,
1075                               (client ? client->ViceId : 0), AUD_INT,
1076                               CallingRoutine, AUD_END);
1077             }
1078         } else {
1079             if (CallingRoutine != CHK_STOREDATA && !VanillaUser(client)) {
1080                 osi_audit(PrivilegeEvent, 0, AUD_ID,
1081                           (client ? client->ViceId : 0), AUD_INT,
1082                           CallingRoutine, AUD_END);
1083             } else {
1084                 if (readonlyServer) {
1085                     return (VREADONLY);
1086                 }
1087                 if (CallingRoutine == CHK_STOREACL) {
1088                     if (!(rights & PRSFS_ADMINISTER)
1089                         && !VolumeOwner(client, targetptr))
1090                         return (EACCES);
1091                 } else {        /* store data or status */
1092                     /* watch for chowns and chgrps */
1093                     if (CHOWN(InStatus, targetptr)
1094                         || CHGRP(InStatus, targetptr)) {
1095                         if (readonlyServer)
1096                             return (VREADONLY);
1097                         else if (VanillaUser(client))
1098                             return (EPERM);     /* Was EACCES */
1099                         else
1100                             osi_audit(PrivilegeEvent, 0, AUD_ID,
1101                                       (client ? client->ViceId : 0), AUD_INT,
1102                                       CallingRoutine, AUD_END);
1103                     }
1104                     /* must be sysadmin to set suid/sgid bits */
1105                     if ((InStatus->Mask & AFS_SETMODE) &&
1106 #ifdef AFS_NT40_ENV
1107                         (InStatus->UnixModeBits & 0xc00) != 0) {
1108 #else
1109                         (InStatus->UnixModeBits & (S_ISUID | S_ISGID)) != 0) {
1110 #endif
1111                         if (readonlyServer)
1112                             return (VREADONLY);
1113                         if (VanillaUser(client))
1114                             return (EACCES);
1115                         else
1116                             osi_audit(PrivSetID, 0, AUD_ID,
1117                                       (client ? client->ViceId : 0), AUD_INT,
1118                                       CallingRoutine, AUD_END);
1119                     }
1120                     if (CallingRoutine == CHK_STOREDATA) {
1121                         if (readonlyServer)
1122                             return (VREADONLY);
1123                         if (!(rights & PRSFS_WRITE))
1124                             return (EACCES);
1125                         /* Next thing is tricky.  We want to prevent people
1126                          * from writing files sans 0200 bit, but we want
1127                          * creating new files with 0444 mode to work.  We
1128                          * don't check the 0200 bit in the "you are the owner"
1129                          * path above, but here we check the bit.  However, if
1130                          * you're a system administrator, we ignore the 0200
1131                          * bit anyway, since you may have fchowned the file,
1132                          * too */
1133 #ifdef USE_GROUP_PERMS
1134                         if ((targetptr->disk.type == vFile)
1135                             && VanillaUser(client)) {
1136                             if (!OWNSp(client, targetptr)
1137                                 && !client_HasAsMember(client, targetptr->disk.owner)) {
1138                                 errorCode =
1139                                     ((GROUPWRITE & targetptr->disk.modeBits)
1140                                      ? 0 : EACCES);
1141                             } else {
1142                                 errorCode =
1143                                     ((OWNERWRITE & targetptr->disk.modeBits)
1144                                      ? 0 : EACCES);
1145                             }
1146                         } else
1147 #endif
1148                             if ((targetptr->disk.type != vDirectory)
1149                                 && (!(targetptr->disk.modeBits & OWNERWRITE))) {
1150                             if (readonlyServer)
1151                                 return (VREADONLY);
1152                             if (VanillaUser(client))
1153                                 return (EACCES);
1154                             else
1155                                 osi_audit(PrivilegeEvent, 0, AUD_ID,
1156                                           (client ? client->ViceId : 0),
1157                                           AUD_INT, CallingRoutine, AUD_END);
1158                         }
1159                     } else {    /* a status store */
1160                         if (readonlyServer)
1161                             return (VREADONLY);
1162                         if (targetptr->disk.type == vDirectory) {
1163                             if (!(rights & PRSFS_DELETE)
1164                                 && !(rights & PRSFS_INSERT))
1165                                 return (EACCES);
1166                         } else {        /* a file  or symlink */
1167                             if (!(rights & PRSFS_WRITE))
1168                                 return (EACCES);
1169                         }
1170                     }
1171                 }
1172             }
1173         }
1174     }
1175     return (errorCode);
1176
1177 }                               /*Check_PermissionRights */
1178
1179
1180 /*
1181  * The Access List information is converted from its internal form in the
1182  * target's vnode buffer (or its parent vnode buffer if not a dir), to an
1183  * external form and returned back to the caller, via the AccessList
1184  * structure
1185  */
1186 static afs_int32
1187 RXFetch_AccessList(Vnode * targetptr, Vnode * parentwhentargetnotdir,
1188                    struct AFSOpaque *AccessList)
1189 {
1190     char *eACL;                 /* External access list placeholder */
1191
1192     if (acl_Externalize_pr
1193         (hpr_IdToName, (targetptr->disk.type ==
1194           vDirectory ? VVnodeACL(targetptr) :
1195           VVnodeACL(parentwhentargetnotdir)), &eACL) != 0) {
1196         return EIO;
1197     }
1198     if ((strlen(eACL) + 1) > AFSOPAQUEMAX) {
1199         acl_FreeExternalACL(&eACL);
1200         return (E2BIG);
1201     } else {
1202         strcpy((char *)(AccessList->AFSOpaque_val), (char *)eACL);
1203         AccessList->AFSOpaque_len = strlen(eACL) + 1;
1204     }
1205     acl_FreeExternalACL(&eACL);
1206     return (0);
1207
1208 }                               /*RXFetch_AccessList */
1209
1210
1211 /*
1212  * The Access List information is converted from its external form in the
1213  * input AccessList structure to the internal representation and copied into
1214  * the target dir's vnode storage.
1215  */
1216 static afs_int32
1217 RXStore_AccessList(Vnode * targetptr, struct AFSOpaque *AccessList)
1218 {
1219     struct acl_accessList *newACL;      /* PlaceHolder for new access list */
1220
1221     if (acl_Internalize_pr(hpr_NameToId, AccessList->AFSOpaque_val, &newACL)
1222         != 0)
1223         return (EINVAL);
1224     if ((newACL->size + 4) > VAclSize(targetptr))
1225         return (E2BIG);
1226     memcpy((char *)VVnodeACL(targetptr), (char *)newACL, (int)(newACL->size));
1227     acl_FreeACL(&newACL);
1228     return (0);
1229
1230 }                               /*RXStore_AccessList */
1231
1232 static int
1233 CheckLink(Volume *volptr, FdHandle_t *fdP, const char *descr)
1234 {
1235     int code;
1236     afs_ino_str_t ino;
1237
1238     code = FDH_ISUNLINKED(fdP);
1239     if (code < 0) {
1240         ViceLog(0, ("CopyOnWrite: error fstating volume %u inode %s (%s), errno %d\n",
1241                     V_id(volptr), PrintInode(ino, fdP->fd_ih->ih_ino), descr, errno));
1242         return -1;
1243     }
1244     if (code) {
1245         ViceLog(0, ("CopyOnWrite corruption prevention: detected zero nlink for "
1246                     "volume %u inode %s (%s), forcing volume offline\n",
1247                     V_id(volptr), PrintInode(ino, fdP->fd_ih->ih_ino), descr));
1248         return -1;
1249     }
1250     return 0;
1251 }
1252
1253 /* In our current implementation, each successive data store (new file
1254  * data version) creates a new inode. This function creates the new
1255  * inode, copies the old inode's contents to the new one, remove the old
1256  * inode (i.e. decrement inode count -- if it's currently used the delete
1257  * will be delayed), and modify some fields (i.e. vnode's
1258  * disk.inodeNumber and cloned)
1259  */
1260 #define COPYBUFFSIZE    8192
1261 #define MAXFSIZE (~(afs_fsize_t) 0)
1262 static int
1263 CopyOnWrite(Vnode * targetptr, Volume * volptr, afs_foff_t off, afs_fsize_t len)
1264 {
1265     Inode ino;
1266     Inode nearInode AFS_UNUSED;
1267     ssize_t rdlen;
1268     ssize_t wrlen;
1269     afs_fsize_t size;
1270     afs_foff_t done;
1271     size_t length;
1272     char *buff;
1273     int rc;                     /* return code */
1274     IHandle_t *newH;            /* Use until finished copying, then cp to vnode. */
1275     FdHandle_t *targFdP;        /* Source Inode file handle */
1276     FdHandle_t *newFdP;         /* Dest Inode file handle */
1277
1278     if (targetptr->disk.type == vDirectory)
1279         DFlush();               /* just in case? */
1280
1281     VN_GET_LEN(size, targetptr);
1282     if (size > off)
1283         size -= off;
1284     else
1285         size = 0;
1286     if (size > len)
1287         size = len;
1288
1289     buff = malloc(COPYBUFFSIZE);
1290     if (buff == NULL) {
1291         return EIO;
1292     }
1293
1294     ino = VN_GET_INO(targetptr);
1295     if (!VALID_INO(ino)) {
1296         free(buff);
1297         VTakeOffline(volptr);
1298         ViceLog(0, ("Volume %" AFS_VOLID_FMT " now offline, must be salvaged.\n",
1299                     afs_printable_VolumeId_lu(volptr->hashid)));
1300         return EIO;
1301     }
1302     targFdP = IH_OPEN(targetptr->handle);
1303     if (targFdP == NULL) {
1304         rc = errno;
1305         ViceLog(0,
1306                 ("CopyOnWrite failed: Failed to open target vnode %u in volume %" AFS_VOLID_FMT " (errno = %d)\n",
1307                  targetptr->vnodeNumber, afs_printable_VolumeId_lu(V_id(volptr)), rc));
1308         free(buff);
1309         VTakeOffline(volptr);
1310         return rc;
1311     }
1312
1313     nearInode = VN_GET_INO(targetptr);
1314     ino =
1315         IH_CREATE(V_linkHandle(volptr), V_device(volptr),
1316                   VPartitionPath(V_partition(volptr)), nearInode,
1317                   V_id(volptr), targetptr->vnodeNumber,
1318                   targetptr->disk.uniquifier,
1319                   (int)targetptr->disk.dataVersion);
1320     if (!VALID_INO(ino)) {
1321         ViceLog(0,
1322                 ("CopyOnWrite failed: Partition %s that contains volume %" AFS_VOLID_FMT " may be out of free inodes(errno = %d)\n",
1323                  volptr->partition->name, afs_printable_VolumeId_lu(V_id(volptr)), errno));
1324         FDH_CLOSE(targFdP);
1325         free(buff);
1326         return ENOSPC;
1327     }
1328     IH_INIT(newH, V_device(volptr), V_id(volptr), ino);
1329     newFdP = IH_OPEN(newH);
1330     opr_Assert(newFdP != NULL);
1331
1332     rc = CheckLink(volptr, targFdP, "source");
1333     if (!rc) {
1334         rc = CheckLink(volptr, newFdP, "dest");
1335     }
1336     if (rc) {
1337         FDH_REALLYCLOSE(newFdP);
1338         IH_RELEASE(newH);
1339         FDH_REALLYCLOSE(targFdP);
1340         IH_DEC(V_linkHandle(volptr), ino, V_parentId(volptr));
1341         free(buff);
1342         VTakeOffline(volptr);
1343         return VSALVAGE;
1344     }
1345
1346     done = off;
1347     while (size > 0) {
1348         if (size > COPYBUFFSIZE) {      /* more than a buffer */
1349             length = COPYBUFFSIZE;
1350             size -= COPYBUFFSIZE;
1351         } else {
1352             length = size;
1353             size = 0;
1354         }
1355         rdlen = FDH_PREAD(targFdP, buff, length, done);
1356         if (rdlen == length) {
1357             wrlen = FDH_PWRITE(newFdP, buff, length, done);
1358             done += rdlen;
1359         } else
1360             wrlen = 0;
1361         /*  Callers of this function are not prepared to recover
1362          *  from error that put the filesystem in an inconsistent
1363          *  state. Make sure that we force the volume off-line if
1364          *  we some error other than ENOSPC - 4.29.99)
1365          *
1366          *  In case we are unable to write the required bytes, and the
1367          *  error code indicates that the disk is full, we roll-back to
1368          *  the initial state.
1369          */
1370         if ((rdlen != length) || (wrlen != length)) {
1371             if ((wrlen < 0) && (errno == ENOSPC)) {     /* disk full */
1372                 ViceLog(0,
1373                         ("CopyOnWrite failed: Partition %s containing volume %" AFS_VOLID_FMT " is full\n",
1374                          volptr->partition->name, afs_printable_VolumeId_lu(V_id(volptr))));
1375                 /* remove destination inode which was partially copied till now */
1376                 FDH_REALLYCLOSE(newFdP);
1377                 IH_RELEASE(newH);
1378                 FDH_REALLYCLOSE(targFdP);
1379                 rc = IH_DEC(V_linkHandle(volptr), ino, V_parentId(volptr));
1380                 if (rc) {
1381                     ViceLog(0,
1382                             ("CopyOnWrite failed: error %u after i_dec on disk full, volume %" AFS_VOLID_FMT " in partition %s needs salvage\n",
1383                              rc, afs_printable_VolumeId_lu(V_id(volptr)), volptr->partition->name));
1384                     VTakeOffline(volptr);
1385                 }
1386                 free(buff);
1387                 return ENOSPC;
1388             } else {
1389                 /* length, rdlen, and wrlen may or may not be 64-bits wide;
1390                  * since we never do any I/O anywhere near 2^32 bytes at a
1391                  * time, just case to an unsigned int for printing */
1392
1393                 ViceLog(0,
1394                         ("CopyOnWrite failed: volume %" AFS_VOLID_FMT " in partition %s  (tried reading %u, read %u, wrote %u, errno %u) volume needs salvage\n",
1395                          afs_printable_VolumeId_lu(V_id(volptr)), volptr->partition->name, (unsigned)length, (unsigned)rdlen,
1396                          (unsigned)wrlen, errno));
1397 #if defined(AFS_DEMAND_ATTACH_FS)
1398                 ViceLog(0, ("CopyOnWrite failed: requesting salvage\n"));
1399 #else
1400                 ViceLog(0, ("CopyOnWrite failed: taking volume offline\n"));
1401 #endif
1402                 /* Decrement this inode so salvager doesn't find it. */
1403                 FDH_REALLYCLOSE(newFdP);
1404                 IH_RELEASE(newH);
1405                 FDH_REALLYCLOSE(targFdP);
1406                 IH_DEC(V_linkHandle(volptr), ino, V_parentId(volptr));
1407                 free(buff);
1408                 VTakeOffline(volptr);
1409                 return EIO;
1410             }
1411         }
1412     }
1413     FDH_REALLYCLOSE(targFdP);
1414     rc = IH_DEC(V_linkHandle(volptr), VN_GET_INO(targetptr),
1415                 V_parentId(volptr));
1416     opr_Assert(!rc);
1417     IH_RELEASE(targetptr->handle);
1418
1419     rc = FDH_SYNC(newFdP);
1420     opr_Assert(rc == 0);
1421     FDH_CLOSE(newFdP);
1422     targetptr->handle = newH;
1423     VN_SET_INO(targetptr, ino);
1424     targetptr->disk.cloned = 0;
1425     /* Internal change to vnode, no user level change to volume - def 5445 */
1426     targetptr->changed_oldTime = 1;
1427     free(buff);
1428     return 0;                   /* success */
1429 }                               /*CopyOnWrite */
1430
1431 /*
1432  * Common code to handle with removing the Name (file when it's called from
1433  * SAFS_RemoveFile() or an empty dir when called from SAFS_rmdir()) from a
1434  * given directory, parentptr.
1435  */
1436 int DT1 = 0, DT0 = 0;
1437 static afs_int32
1438 DeleteTarget(Vnode * parentptr, Volume * volptr, Vnode ** targetptr,
1439              DirHandle * dir, AFSFid * fileFid, char *Name, int ChkForDir)
1440 {
1441     DirHandle childdir;         /* Handle for dir package I/O */
1442     Error errorCode = 0;
1443     int code;
1444     afs_ino_str_t stmp;
1445
1446     /* watch for invalid names */
1447     if (!strcmp(Name, ".") || !strcmp(Name, ".."))
1448         return (EINVAL);
1449
1450     if (CheckLength(volptr, parentptr, -1)) {
1451         VTakeOffline(volptr);
1452         return VSALVAGE;
1453     }
1454
1455     if (parentptr->disk.cloned) {
1456         ViceLog(25, ("DeleteTarget : CopyOnWrite called\n"));
1457         if ((errorCode = CopyOnWrite(parentptr, volptr, 0, MAXFSIZE))) {
1458             ViceLog(20,
1459                     ("DeleteTarget %s: CopyOnWrite failed %d\n", Name,
1460                      errorCode));
1461             return errorCode;
1462         }
1463     }
1464
1465     /* check that the file is in the directory */
1466     SetDirHandle(dir, parentptr);
1467     if (afs_dir_Lookup(dir, Name, fileFid))
1468         return (ENOENT);
1469     fileFid->Volume = V_id(volptr);
1470
1471     /* just-in-case check for something causing deadlock */
1472     if (fileFid->Vnode == parentptr->vnodeNumber)
1473         return (EINVAL);
1474
1475     *targetptr = VGetVnode(&errorCode, volptr, fileFid->Vnode, WRITE_LOCK);
1476     if (errorCode) {
1477         return (errorCode);
1478     }
1479     if (ChkForDir == MustBeDIR) {
1480         if ((*targetptr)->disk.type != vDirectory)
1481             return (ENOTDIR);
1482     } else if ((*targetptr)->disk.type == vDirectory)
1483         return (EISDIR);
1484
1485     /*osi_Assert((*targetptr)->disk.uniquifier == fileFid->Unique); */
1486     /**
1487       * If the uniquifiers dont match then instead of asserting
1488       * take the volume offline and return VSALVAGE
1489       */
1490     if ((*targetptr)->disk.uniquifier != fileFid->Unique) {
1491         VTakeOffline(volptr);
1492         ViceLog(0,
1493                 ("Volume %" AFS_VOLID_FMT " now offline, must be salvaged.\n",
1494                  afs_printable_VolumeId_lu(volptr->hashid)));
1495         errorCode = VSALVAGE;
1496         return errorCode;
1497     }
1498
1499     if (ChkForDir == MustBeDIR) {
1500         SetDirHandle(&childdir, *targetptr);
1501         if (afs_dir_IsEmpty(&childdir) != 0)
1502             return (EEXIST);
1503         DZap(&childdir);
1504         FidZap(&childdir);
1505         (*targetptr)->delete = 1;
1506     } else if ((--(*targetptr)->disk.linkCount) == 0)
1507         (*targetptr)->delete = 1;
1508     if ((*targetptr)->delete) {
1509         if (VN_GET_INO(*targetptr)) {
1510             DT0++;
1511             IH_REALLYCLOSE((*targetptr)->handle);
1512             errorCode =
1513                 IH_DEC(V_linkHandle(volptr), VN_GET_INO(*targetptr),
1514                        V_parentId(volptr));
1515             IH_RELEASE((*targetptr)->handle);
1516             if (errorCode == -1) {
1517                 ViceLog(0,
1518                         ("DT: inode=%s, name=%s, errno=%d\n",
1519                          PrintInode(stmp, VN_GET_INO(*targetptr)), Name,
1520                          errno));
1521                 if (errno != ENOENT)
1522                 {
1523                     VTakeOffline(volptr);
1524                     ViceLog(0,
1525                             ("Volume %" AFS_VOLID_FMT " now offline, must be salvaged.\n",
1526                              afs_printable_VolumeId_lu(volptr->hashid)));
1527                     return (EIO);
1528                 }
1529                 DT1++;
1530                 errorCode = 0;
1531             }
1532         }
1533         VN_SET_INO(*targetptr, (Inode) 0);
1534         {
1535             afs_fsize_t adjLength;
1536             VN_GET_LEN(adjLength, *targetptr);
1537             VAdjustDiskUsage(&errorCode, volptr, -(int)nBlocks(adjLength), 0);
1538         }
1539     }
1540
1541     (*targetptr)->changed_newTime = 1;  /* Status change of deleted file/dir */
1542
1543     code = afs_dir_Delete(dir, Name);
1544     if (code) {
1545         ViceLog(0,
1546                 ("Error %d deleting %s\n", code,
1547                  (((*targetptr)->disk.type ==
1548                    Directory) ? "directory" : "file")));
1549         VTakeOffline(volptr);
1550         ViceLog(0,
1551                 ("Volume %" AFS_VOLID_FMT " now offline, must be salvaged.\n",
1552                  afs_printable_VolumeId_lu(volptr->hashid)));
1553         if (!errorCode)
1554             errorCode = code;
1555     }
1556
1557     DFlush();
1558     return (errorCode);
1559
1560 }                               /*DeleteTarget */
1561
1562
1563 /*
1564  * This routine updates the parent directory's status block after the
1565  * specified operation (i.e. RemoveFile(), CreateFile(), Rename(),
1566  * SymLink(), Link(), MakeDir(), RemoveDir()) on one of its children has
1567  * been performed.
1568  */
1569 static void
1570 Update_ParentVnodeStatus(Vnode * parentptr, Volume * volptr, DirHandle * dir,
1571                          int author, int linkcount, char a_inSameNetwork)
1572 {
1573     afs_fsize_t newlength;      /* Holds new directory length */
1574     afs_fsize_t parentLength;
1575     Error errorCode;
1576     Date currDate;              /*Current date */
1577     int writeIdx;               /*Write index to bump */
1578     int timeIdx;                /*Authorship time index to bump */
1579     time_t now;
1580
1581     parentptr->disk.dataVersion++;
1582     newlength = (afs_fsize_t) afs_dir_Length(dir);
1583     /*
1584      * This is a called on both dir removals (i.e. remove, removedir, rename) but also in dir additions
1585      * (create, symlink, link, makedir) so we need to check if we have enough space
1586      * XXX But we still don't check the error since we're dealing with dirs here and really the increase
1587      * of a new entry would be too tiny to worry about failures (since we have all the existing cushion)
1588      */
1589     VN_GET_LEN(parentLength, parentptr);
1590     if (nBlocks(newlength) != nBlocks(parentLength)) {
1591         VAdjustDiskUsage(&errorCode, volptr,
1592                          (nBlocks(newlength) - nBlocks(parentLength)),
1593                          (nBlocks(newlength) - nBlocks(parentLength)));
1594     }
1595     VN_SET_LEN(parentptr, newlength);
1596
1597     /*
1598      * Update directory write stats for this volume.  Note that the auth
1599      * counter is located immediately after its associated ``distance''
1600      * counter.
1601      */
1602     if (a_inSameNetwork)
1603         writeIdx = VOL_STATS_SAME_NET;
1604     else
1605         writeIdx = VOL_STATS_DIFF_NET;
1606     V_stat_writes(volptr, writeIdx)++;
1607     if (author != AnonymousID) {
1608         V_stat_writes(volptr, writeIdx + 1)++;
1609     }
1610
1611     /*
1612      * Update the volume's authorship information in response to this
1613      * directory operation.  Get the current time, decide to which time
1614      * slot this operation belongs, and bump the appropriate slot.
1615      */
1616     now = time(NULL);
1617     currDate = (now - parentptr->disk.unixModifyTime);
1618     timeIdx =
1619         (currDate < VOL_STATS_TIME_CAP_0 ? VOL_STATS_TIME_IDX_0 : currDate <
1620          VOL_STATS_TIME_CAP_1 ? VOL_STATS_TIME_IDX_1 : currDate <
1621          VOL_STATS_TIME_CAP_2 ? VOL_STATS_TIME_IDX_2 : currDate <
1622          VOL_STATS_TIME_CAP_3 ? VOL_STATS_TIME_IDX_3 : currDate <
1623          VOL_STATS_TIME_CAP_4 ? VOL_STATS_TIME_IDX_4 : VOL_STATS_TIME_IDX_5);
1624     if (parentptr->disk.author == author) {
1625         V_stat_dirSameAuthor(volptr, timeIdx)++;
1626     } else {
1627         V_stat_dirDiffAuthor(volptr, timeIdx)++;
1628     }
1629
1630     parentptr->disk.author = author;
1631     parentptr->disk.linkCount = linkcount;
1632     parentptr->disk.unixModifyTime = now;       /* This should be set from CLIENT!! */
1633     parentptr->disk.serverModifyTime = now;
1634     parentptr->changed_newTime = 1;     /* vnode changed, write it back. */
1635 }
1636
1637
1638 /*
1639  * Update the target file's (or dir's) status block after the specified
1640  * operation is complete. Note that some other fields maybe updated by
1641  * the individual module.
1642  * If remote is set, the volume is a RW replica and access checks can
1643  * be skipped.
1644  */
1645
1646 /* XXX INCOMPLETE - More attention is needed here! */
1647 static void
1648 Update_TargetVnodeStatus(Vnode * targetptr, afs_uint32 Caller,
1649                          struct client *client, AFSStoreStatus * InStatus,
1650                          Vnode * parentptr, Volume * volptr,
1651                          afs_fsize_t length, int remote)
1652 {
1653     Date currDate;              /*Current date */
1654     int writeIdx;               /*Write index to bump */
1655     int timeIdx;                /*Authorship time index to bump */
1656
1657     if (Caller & (TVS_CFILE | TVS_SLINK | TVS_MKDIR)) { /* initialize new file */
1658         targetptr->disk.parent = parentptr->vnodeNumber;
1659         VN_SET_LEN(targetptr, length);
1660         /* targetptr->disk.group =      0;  save some cycles */
1661         targetptr->disk.modeBits = 0777;
1662         targetptr->disk.owner = client->ViceId;
1663         targetptr->disk.dataVersion = 0;        /* consistent with the client */
1664         targetptr->disk.linkCount = (Caller & TVS_MKDIR ? 2 : 1);
1665         /* the inode was created in Alloc_NewVnode() */
1666     }
1667     /*
1668      * Update file write stats for this volume.  Note that the auth
1669      * counter is located immediately after its associated ``distance''
1670      * counter.
1671      */
1672     if (client->InSameNetwork)
1673         writeIdx = VOL_STATS_SAME_NET;
1674     else
1675         writeIdx = VOL_STATS_DIFF_NET;
1676     V_stat_writes(volptr, writeIdx)++;
1677     if (client->ViceId != AnonymousID) {
1678         V_stat_writes(volptr, writeIdx + 1)++;
1679     }
1680
1681     /*
1682      * We only count operations that DON'T involve creating new objects
1683      * (files, symlinks, directories) or simply setting status as
1684      * authorship-change operations.
1685      */
1686     if (!(Caller & (TVS_CFILE | TVS_SLINK | TVS_MKDIR | TVS_SSTATUS))) {
1687         /*
1688          * Update the volume's authorship information in response to this
1689          * file operation.  Get the current time, decide to which time
1690          * slot this operation belongs, and bump the appropriate slot.
1691          */
1692         currDate = (time(NULL) - targetptr->disk.unixModifyTime);
1693         timeIdx =
1694             (currDate <
1695              VOL_STATS_TIME_CAP_0 ? VOL_STATS_TIME_IDX_0 : currDate <
1696              VOL_STATS_TIME_CAP_1 ? VOL_STATS_TIME_IDX_1 : currDate <
1697              VOL_STATS_TIME_CAP_2 ? VOL_STATS_TIME_IDX_2 : currDate <
1698              VOL_STATS_TIME_CAP_3 ? VOL_STATS_TIME_IDX_3 : currDate <
1699              VOL_STATS_TIME_CAP_4 ? VOL_STATS_TIME_IDX_4 :
1700              VOL_STATS_TIME_IDX_5);
1701         if (targetptr->disk.author == client->ViceId) {
1702             V_stat_fileSameAuthor(volptr, timeIdx)++;
1703         } else {
1704             V_stat_fileDiffAuthor(volptr, timeIdx)++;
1705         }
1706     }
1707
1708     if (!(Caller & TVS_SSTATUS))
1709         targetptr->disk.author = client->ViceId;
1710     if (Caller & TVS_SDATA) {
1711         targetptr->disk.dataVersion++;
1712         if (!remote && VanillaUser(client)) {
1713             /* turn off suid */
1714             targetptr->disk.modeBits = targetptr->disk.modeBits & ~04000;
1715 #ifdef CREATE_SGUID_ADMIN_ONLY
1716             /* turn off sgid */
1717             targetptr->disk.modeBits = targetptr->disk.modeBits & ~02000;
1718 #endif
1719         }
1720     }
1721     if (Caller & TVS_SSTATUS) { /* update time on non-status change */
1722         /* store status, must explicitly request to change the date */
1723         if (InStatus->Mask & AFS_SETMODTIME)
1724             targetptr->disk.unixModifyTime = InStatus->ClientModTime;
1725     } else {                    /* other: date always changes, but perhaps to what is specified by caller */
1726         targetptr->disk.unixModifyTime =
1727             (InStatus->Mask & AFS_SETMODTIME ? InStatus->
1728              ClientModTime : time(NULL));
1729     }
1730     if (InStatus->Mask & AFS_SETOWNER) {
1731         /* admin is allowed to do chmod, chown as well as chown, chmod. */
1732         if (!remote && VanillaUser(client)) {
1733             /* turn off suid */
1734             targetptr->disk.modeBits = targetptr->disk.modeBits & ~04000;
1735 #ifdef CREATE_SGUID_ADMIN_ONLY
1736             /* turn off sgid */
1737             targetptr->disk.modeBits = targetptr->disk.modeBits & ~02000;
1738 #endif
1739         }
1740         targetptr->disk.owner = InStatus->Owner;
1741         if (VolumeRootVnode(targetptr)) {
1742             Error errorCode = 0;        /* what should be done with this? */
1743
1744             V_owner(targetptr->volumePtr) = InStatus->Owner;
1745             VUpdateVolume(&errorCode, targetptr->volumePtr);
1746         }
1747     }
1748     if (InStatus->Mask & AFS_SETMODE) {
1749         int modebits = InStatus->UnixModeBits;
1750 #define CREATE_SGUID_ADMIN_ONLY 1
1751 #ifdef CREATE_SGUID_ADMIN_ONLY
1752         if (!remote && VanillaUser(client))
1753             modebits = modebits & 0777;
1754 #endif
1755         if (!remote && VanillaUser(client)) {
1756             targetptr->disk.modeBits = modebits;
1757         } else {
1758             targetptr->disk.modeBits = modebits;
1759             switch (Caller) {
1760             case TVS_SDATA:
1761                 osi_audit(PrivSetID, 0, AUD_ID, client->ViceId, AUD_INT,
1762                           CHK_STOREDATA, AUD_END);
1763                 break;
1764             case TVS_CFILE:
1765             case TVS_SSTATUS:
1766                 osi_audit(PrivSetID, 0, AUD_ID, client->ViceId, AUD_INT,
1767                           CHK_STORESTATUS, AUD_END);
1768                 break;
1769             default:
1770                 break;
1771             }
1772         }
1773     }
1774     targetptr->disk.serverModifyTime = time(NULL);
1775     if (InStatus->Mask & AFS_SETGROUP)
1776         targetptr->disk.group = InStatus->Group;
1777     /* vnode changed : to be written back by VPutVnode */
1778     targetptr->changed_newTime = 1;
1779
1780 }                               /*Update_TargetVnodeStatus */
1781
1782
1783 /*
1784  * Fills the CallBack structure with the expiration time and type of callback
1785  * structure. Warning: this function is currently incomplete.
1786  */
1787 static void
1788 SetCallBackStruct(afs_uint32 CallBackTime, struct AFSCallBack *CallBack)
1789 {
1790     /* CallBackTime could not be 0 */
1791     if (CallBackTime == 0) {
1792         ViceLog(0, ("WARNING: CallBackTime == 0!\n"));
1793         CallBack->ExpirationTime = 0;
1794     } else
1795         CallBack->ExpirationTime = CallBackTime - time(NULL);
1796     CallBack->CallBackVersion = CALLBACK_VERSION;
1797     CallBack->CallBackType = CB_SHARED; /* The default for now */
1798
1799 }                               /*SetCallBackStruct */
1800
1801
1802 /*
1803  * Adjusts (Subtract) "length" number of blocks from the volume's disk
1804  * allocation; if some error occured (exceeded volume quota or partition
1805  * was full, or whatever), it frees the space back and returns the code.
1806  * We usually pre-adjust the volume space to make sure that there's
1807  * enough space before consuming some.
1808  */
1809 static afs_int32
1810 AdjustDiskUsage(Volume * volptr, afs_sfsize_t length,
1811                 afs_sfsize_t checkLength)
1812 {
1813     Error rc;
1814     Error nc;
1815
1816     VAdjustDiskUsage(&rc, volptr, length, checkLength);
1817     if (rc) {
1818         VAdjustDiskUsage(&nc, volptr, -length, 0);
1819         if (rc == VOVERQUOTA) {
1820             ViceLog(2,
1821                     ("Volume %" AFS_VOLID_FMT " (%s) is full\n",
1822                      afs_printable_VolumeId_lu(V_id(volptr)),
1823                      V_name(volptr)));
1824             return (rc);
1825         }
1826         if (rc == VDISKFULL) {
1827             ViceLog(0,
1828                     ("Partition %s that contains volume %" AFS_VOLID_FMT " is full\n",
1829                      volptr->partition->name,
1830                      afs_printable_VolumeId_lu(V_id(volptr))));
1831             return (rc);
1832         }
1833         ViceLog(0, ("Got error return %d from VAdjustDiskUsage\n", rc));
1834         return (rc);
1835     }
1836     return (0);
1837
1838 }                               /*AdjustDiskUsage */
1839
1840 /*
1841  * Common code that handles the creation of a new file (SAFS_CreateFile and
1842  * SAFS_Symlink) or a new dir (SAFS_MakeDir)
1843  */
1844 static afs_int32
1845 Alloc_NewVnode(Vnode * parentptr, DirHandle * dir, Volume * volptr,
1846                Vnode ** targetptr, char *Name, struct AFSFid *OutFid,
1847                int FileType, afs_sfsize_t BlocksPreallocatedForVnode)
1848 {
1849     Error errorCode = 0;                /* Error code returned back */
1850     Error temp;
1851     Inode inode = 0;
1852     Inode nearInode AFS_UNUSED;  /* hint for inode allocation in solaris */
1853     afs_ino_str_t stmp;
1854
1855     if ((errorCode =
1856          AdjustDiskUsage(volptr, BlocksPreallocatedForVnode,
1857                          BlocksPreallocatedForVnode))) {
1858         ViceLog(25,
1859                 ("Insufficient space to allocate %lld blocks\n",
1860                  (afs_intmax_t) BlocksPreallocatedForVnode));
1861         return (errorCode);
1862     }
1863
1864     if (CheckLength(volptr, parentptr, -1)) {
1865         VAdjustDiskUsage(&temp, volptr, -BlocksPreallocatedForVnode, 0);
1866         VTakeOffline(volptr);
1867         return VSALVAGE;
1868     }
1869
1870     *targetptr = VAllocVnode(&errorCode, volptr, FileType, 0, 0);
1871     if (errorCode != 0) {
1872         VAdjustDiskUsage(&temp, volptr, -BlocksPreallocatedForVnode, 0);
1873         return (errorCode);
1874     }
1875     OutFid->Volume = V_id(volptr);
1876     OutFid->Vnode = (*targetptr)->vnodeNumber;
1877     OutFid->Unique = (*targetptr)->disk.uniquifier;
1878
1879     nearInode = VN_GET_INO(parentptr);  /* parent is also in same vol */
1880
1881     /* create the inode now itself */
1882     inode =
1883         IH_CREATE(V_linkHandle(volptr), V_device(volptr),
1884                   VPartitionPath(V_partition(volptr)), nearInode,
1885                   V_id(volptr), (*targetptr)->vnodeNumber,
1886                   (*targetptr)->disk.uniquifier, 1);
1887
1888     /* error in creating inode */
1889     if (!VALID_INO(inode)) {
1890         ViceLog(0,
1891                 ("Volume : %" AFS_VOLID_FMT " vnode = %u Failed to create inode: errno = %d\n",
1892                  afs_printable_VolumeId_lu(V_id((*targetptr)->volumePtr)),
1893                  (*targetptr)->vnodeNumber, errno));
1894         VAdjustDiskUsage(&temp, volptr, -BlocksPreallocatedForVnode, 0);
1895         (*targetptr)->delete = 1;       /* delete vnode */
1896         return ENOSPC;
1897     }
1898     VN_SET_INO(*targetptr, inode);
1899     IH_INIT(((*targetptr)->handle), V_device(volptr), V_id(volptr), inode);
1900
1901     /* copy group from parent dir */
1902     (*targetptr)->disk.group = parentptr->disk.group;
1903
1904     if (parentptr->disk.cloned) {
1905         ViceLog(25, ("Alloc_NewVnode : CopyOnWrite called\n"));
1906         if ((errorCode = CopyOnWrite(parentptr, volptr, 0, MAXFSIZE))) {        /* disk full */
1907             ViceLog(25, ("Alloc_NewVnode : CopyOnWrite failed\n"));
1908             /* delete the vnode previously allocated */
1909             (*targetptr)->delete = 1;
1910             VAdjustDiskUsage(&temp, volptr, -BlocksPreallocatedForVnode, 0);
1911             IH_REALLYCLOSE((*targetptr)->handle);
1912             if (IH_DEC(V_linkHandle(volptr), inode, V_parentId(volptr)))
1913                 ViceLog(0,
1914                         ("Alloc_NewVnode: partition %s idec %s failed\n",
1915                          volptr->partition->name, PrintInode(stmp, inode)));
1916             IH_RELEASE((*targetptr)->handle);
1917
1918             return errorCode;
1919         }
1920     }
1921
1922     /* add the name to the directory */
1923     SetDirHandle(dir, parentptr);
1924     if ((errorCode = afs_dir_Create(dir, Name, OutFid))) {
1925         (*targetptr)->delete = 1;
1926         VAdjustDiskUsage(&temp, volptr, -BlocksPreallocatedForVnode, 0);
1927         IH_REALLYCLOSE((*targetptr)->handle);
1928         if (IH_DEC(V_linkHandle(volptr), inode, V_parentId(volptr)))
1929             ViceLog(0,
1930                     ("Alloc_NewVnode: partition %s idec %s failed\n",
1931                      volptr->partition->name, PrintInode(stmp, inode)));
1932         IH_RELEASE((*targetptr)->handle);
1933         return (errorCode);
1934     }
1935     DFlush();
1936     return (0);
1937
1938 }                               /*Alloc_NewVnode */
1939
1940
1941 /*
1942  * Handle all the lock-related code (SAFS_SetLock, SAFS_ExtendLock and
1943  * SAFS_ReleaseLock)
1944  */
1945 static afs_int32
1946 HandleLocking(Vnode * targetptr, struct client *client, afs_int32 rights, ViceLockType LockingType)
1947 {
1948     int Time;                   /* Used for time */
1949     int writeVnode = targetptr->changed_oldTime;        /* save original status */
1950
1951     targetptr->changed_oldTime = 1;     /* locking doesn't affect any time stamp */
1952     Time = time(NULL);
1953     switch (LockingType) {
1954     case LockRead:
1955     case LockWrite:
1956         if (Time > targetptr->disk.lock.lockTime)
1957             targetptr->disk.lock.lockTime = targetptr->disk.lock.lockCount =
1958                 0;
1959         Time += AFS_LOCKWAIT;
1960         if (LockingType == LockRead) {
1961             if ( !(rights & PRSFS_LOCK) &&
1962                  !(rights & PRSFS_WRITE) &&
1963                  !(OWNSp(client, targetptr) && (rights & PRSFS_INSERT)) )
1964                     return(EACCES);
1965
1966             if (targetptr->disk.lock.lockCount >= 0) {
1967                 ++(targetptr->disk.lock.lockCount);
1968                 targetptr->disk.lock.lockTime = Time;
1969             } else
1970                 return (EAGAIN);
1971         } else if (LockingType == LockWrite) {
1972             if ( !(rights & PRSFS_WRITE) &&
1973                  !(OWNSp(client, targetptr) && (rights & PRSFS_INSERT)) )
1974                 return(EACCES);
1975
1976             if (targetptr->disk.lock.lockCount == 0) {
1977                 targetptr->disk.lock.lockCount = -1;
1978                 targetptr->disk.lock.lockTime = Time;
1979             } else
1980                 return (EAGAIN);
1981         }
1982         break;
1983     case LockExtend:
1984         Time += AFS_LOCKWAIT;
1985         if (targetptr->disk.lock.lockCount != 0)
1986             targetptr->disk.lock.lockTime = Time;
1987         else
1988             return (EINVAL);
1989         break;
1990     case LockRelease:
1991         if ((--targetptr->disk.lock.lockCount) <= 0)
1992             targetptr->disk.lock.lockCount = targetptr->disk.lock.lockTime =
1993                 0;
1994         break;
1995     default:
1996         targetptr->changed_oldTime = writeVnode;        /* restore old status */
1997         ViceLog(0, ("Illegal Locking type %d\n", LockingType));
1998     }
1999     return (0);
2000 }                               /*HandleLocking */
2001
2002 /* Checks if caller has the proper AFS and Unix (WRITE) access permission to the target directory; Prfs_Mode refers to the AFS Mode operation while rights contains the caller's access permissions to the directory. */
2003
2004 static afs_int32
2005 CheckWriteMode(Vnode * targetptr, afs_int32 rights, int Prfs_Mode)
2006 {
2007     if (readonlyServer)
2008         return (VREADONLY);
2009     if (!(rights & Prfs_Mode))
2010         return (EACCES);
2011     if ((targetptr->disk.type != vDirectory)
2012         && (!(targetptr->disk.modeBits & OWNERWRITE)))
2013         return (EACCES);
2014     return (0);
2015 }
2016
2017 /*
2018  * If some flags (i.e. min or max quota) are set, the volume's in disk
2019  * label is updated; Name, OfflineMsg, and Motd are also reflected in the
2020  * update, if applicable.
2021  */
2022 static afs_int32
2023 RXUpdate_VolumeStatus(Volume * volptr, AFSStoreVolumeStatus * StoreVolStatus,
2024                       char *Name, char *OfflineMsg, char *Motd)
2025 {
2026     Error errorCode = 0;
2027
2028     if (StoreVolStatus->Mask & AFS_SETMINQUOTA)
2029         V_minquota(volptr) = StoreVolStatus->MinQuota;
2030     if (StoreVolStatus->Mask & AFS_SETMAXQUOTA)
2031         V_maxquota(volptr) = StoreVolStatus->MaxQuota;
2032     if (strlen(OfflineMsg) > 0) {
2033         strcpy(V_offlineMessage(volptr), OfflineMsg);
2034     }
2035     if (strlen(Name) > 0) {
2036         strcpy(V_name(volptr), Name);
2037     }
2038     /*
2039      * We don't overwrite the motd field, since it's now being used
2040      * for stats
2041      */
2042     VUpdateVolume(&errorCode, volptr);
2043     return (errorCode);
2044
2045 }                               /*RXUpdate_VolumeStatus */
2046
2047
2048 static afs_int32
2049 RXGetVolumeStatus(AFSFetchVolumeStatus * status, char **name, char **offMsg,
2050                   char **motd, Volume * volptr)
2051 {
2052
2053     status->Vid = V_id(volptr);
2054     status->ParentId = V_parentId(volptr);
2055     status->Online = V_inUse(volptr);
2056     status->InService = V_inService(volptr);
2057     status->Blessed = V_blessed(volptr);
2058     status->NeedsSalvage = V_needsSalvaged(volptr);
2059     if (VolumeWriteable(volptr))
2060         status->Type = ReadWrite;
2061     else
2062         status->Type = ReadOnly;
2063     status->MinQuota = V_minquota(volptr);
2064     status->MaxQuota = V_maxquota(volptr);
2065     status->BlocksInUse = V_diskused(volptr);
2066     status->PartBlocksAvail = RoundInt64ToInt31(volptr->partition->free);
2067     status->PartMaxBlocks = RoundInt64ToInt31(volptr->partition->totalUsable);
2068
2069     /* now allocate and copy these things; they're freed by the RXGEN stub */
2070     *name = strdup(V_name(volptr));
2071     if (!*name) {
2072         ViceLogThenPanic(0, ("Failed malloc in RXGetVolumeStatus\n"));
2073     }
2074     *offMsg = strdup(V_offlineMessage(volptr));
2075     if (!*offMsg) {
2076         ViceLogThenPanic(0, ("Failed malloc in RXGetVolumeStatus\n"));
2077     }
2078     *motd = malloc(1);
2079     if (!*motd) {
2080         ViceLogThenPanic(0, ("Failed malloc in RXGetVolumeStatus\n"));
2081     }
2082     strcpy(*motd, nullString);
2083     return 0;
2084 }                               /*RXGetVolumeStatus */
2085
2086
2087 static afs_int32
2088 FileNameOK(char *aname)
2089 {
2090     afs_int32 i, tc;
2091     i = strlen(aname);
2092     if (i >= 4) {
2093         /* watch for @sys on the right */
2094         if (strcmp(aname + i - 4, "@sys") == 0)
2095             return 0;
2096     }
2097     while ((tc = *aname++)) {
2098         if (tc == '/')
2099             return 0;           /* very bad character to encounter */
2100     }
2101     return 1;                   /* file name is ok */
2102
2103 }                               /*FileNameOK */
2104
2105
2106 /*
2107  * This variant of symlink is expressly to support the AFS/DFS translator
2108  * and is not supported by the AFS fileserver. We just return EINVAL.
2109  * The cache manager should not generate this call to an AFS cache manager.
2110  */
2111 afs_int32
2112 SRXAFS_DFSSymlink(struct rx_call *acall, struct AFSFid *DirFid, char *Name,
2113                   char *LinkContents, struct AFSStoreStatus *InStatus,
2114                   struct AFSFid *OutFid, struct AFSFetchStatus *OutFidStatus,
2115                   struct AFSFetchStatus *OutDirStatus,
2116                   struct AFSCallBack *CallBack, struct AFSVolSync *Sync)
2117 {
2118     return EINVAL;
2119 }
2120
2121 afs_int32
2122 SRXAFS_FsCmd(struct rx_call * acall, struct AFSFid * Fid,
2123                     struct FsCmdInputs * Inputs,
2124                     struct FsCmdOutputs * Outputs)
2125 {
2126     afs_int32 code = 0;
2127
2128     switch (Inputs->command) {
2129     default:
2130         code = EINVAL;
2131     }
2132     ViceLog(1,("FsCmd: cmd = %d, code=%d\n",
2133                         Inputs->command, Outputs->code));
2134     return code;
2135 }
2136
2137 #ifndef HAVE_PIOV
2138 static struct afs_buffer {
2139     struct afs_buffer *next;
2140 } *freeBufferList = 0;
2141 static int afs_buffersAlloced = 0;
2142
2143 static int
2144 FreeSendBuffer(struct afs_buffer *adata)
2145 {
2146     FS_LOCK;
2147     afs_buffersAlloced--;
2148     adata->next = freeBufferList;
2149     freeBufferList = adata;
2150     FS_UNLOCK;
2151     return 0;
2152
2153 }                               /*FreeSendBuffer */
2154
2155 /* allocate space for sender */
2156 static char *
2157 AllocSendBuffer(void)
2158 {
2159     struct afs_buffer *tp;
2160
2161     FS_LOCK;
2162     afs_buffersAlloced++;
2163     if (!freeBufferList) {
2164         char *tmp;
2165         FS_UNLOCK;
2166         tmp = malloc(sendBufSize);
2167         if (!tmp) {
2168             ViceLogThenPanic(0, ("Failed malloc in AllocSendBuffer\n"));
2169         }
2170         return tmp;
2171     }
2172     tp = freeBufferList;
2173     freeBufferList = tp->next;
2174     FS_UNLOCK;
2175     return (char *)tp;
2176
2177 }                               /*AllocSendBuffer */
2178 #endif /* HAVE_PIOV */
2179
2180 /*
2181  * This routine returns the status info associated with the targetptr vnode
2182  * in the AFSFetchStatus structure.  Some of the newer fields, such as
2183  * SegSize and Group are not yet implemented
2184  */
2185 static
2186     void
2187 GetStatus(Vnode * targetptr, AFSFetchStatus * status, afs_int32 rights,
2188           afs_int32 anyrights, Vnode * parentptr)
2189 {
2190     int Time = time(NULL);
2191
2192     /* initialize return status from a vnode  */
2193     status->InterfaceVersion = 1;
2194     status->SyncCounter = status->dataVersionHigh = status->lockCount =
2195         status->errorCode = 0;
2196     status->ResidencyMask = 1;  /* means for MR-AFS: file in /vicepr-partition */
2197     if (targetptr->disk.type == vFile)
2198         status->FileType = File;
2199     else if (targetptr->disk.type == vDirectory)
2200         status->FileType = Directory;
2201     else if (targetptr->disk.type == vSymlink)
2202         status->FileType = SymbolicLink;
2203     else
2204         status->FileType = Invalid;     /*invalid type field */
2205     status->LinkCount = targetptr->disk.linkCount;
2206     {
2207         afs_fsize_t targetLen;
2208         VN_GET_LEN(targetLen, targetptr);
2209         SplitOffsetOrSize(targetLen, status->Length_hi, status->Length);
2210     }
2211     status->DataVersion = targetptr->disk.dataVersion;
2212     status->Author = targetptr->disk.author;
2213     status->Owner = targetptr->disk.owner;
2214     status->CallerAccess = rights;
2215     status->AnonymousAccess = anyrights;
2216     status->UnixModeBits = targetptr->disk.modeBits;
2217     status->ClientModTime = targetptr->disk.unixModifyTime;     /* This might need rework */
2218     status->ParentVnode =
2219         (status->FileType ==
2220          Directory ? targetptr->vnodeNumber : parentptr->vnodeNumber);
2221     status->ParentUnique =
2222         (status->FileType ==
2223          Directory ? targetptr->disk.uniquifier : parentptr->disk.uniquifier);
2224     status->ServerModTime = targetptr->disk.serverModifyTime;
2225     status->Group = targetptr->disk.group;
2226     status->lockCount = Time > targetptr->disk.lock.lockTime ? 0 : targetptr->disk.lock.lockCount;
2227     status->errorCode = 0;
2228
2229 }                               /*GetStatus */
2230
2231 static afs_int32
2232 common_FetchData64(struct rx_call *acall, struct AFSFid *Fid,
2233                    afs_sfsize_t Pos, afs_sfsize_t Len,
2234                    struct AFSFetchStatus *OutStatus,
2235                    struct AFSCallBack *CallBack, struct AFSVolSync *Sync,
2236                    int type)
2237 {
2238     Vnode *targetptr = 0;       /* pointer to vnode to fetch */
2239     Vnode *parentwhentargetnotdir = 0;  /* parent vnode if vptr is a file */
2240     Vnode tparentwhentargetnotdir;      /* parent vnode for GetStatus */
2241     Error errorCode = 0;                /* return code to caller */
2242     Error fileCode = 0;         /* return code from vol package */
2243     Volume *volptr = 0;         /* pointer to the volume */
2244     struct client *client = 0;  /* pointer to the client data */
2245     struct rx_connection *tcon; /* the connection we're part of */
2246     struct host *thost;
2247     afs_int32 rights, anyrights;        /* rights for this and any user */
2248     struct client *t_client = NULL;     /* tmp ptr to client data */
2249     struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
2250     struct VCallByVol tcbv, *cbv = NULL;
2251     static int remainder = 0;   /* shared access protected by FS_LOCK */
2252     struct fsstats fsstats;
2253     afs_sfsize_t bytesToXfer;  /* # bytes to xfer */
2254     afs_sfsize_t bytesXferred; /* # bytes actually xferred */
2255     int readIdx;                /* Index of read stats array to bump */
2256
2257     fsstats_StartOp(&fsstats, FS_STATS_RPCIDX_FETCHDATA);
2258
2259     ViceLog(1,
2260             ("SRXAFS_FetchData, Fid = %u.%u.%u\n", Fid->Volume, Fid->Vnode,
2261              Fid->Unique));
2262     FS_LOCK;
2263     AFSCallStats.FetchData++, AFSCallStats.TotalCalls++;
2264     FS_UNLOCK;
2265     if ((errorCode = CallPreamble(acall, ACTIVECALL, &tcon, &thost)))
2266         goto Bad_FetchData;
2267
2268     /* Get ptr to client data for user Id for logging */
2269     t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
2270     logHostAddr.s_addr = rxr_HostOf(tcon);
2271     ViceLog(5,
2272             ("SRXAFS_FetchData, Fid = %u.%u.%u, Host %s:%d, Id %d\n",
2273              Fid->Volume, Fid->Vnode, Fid->Unique, inet_ntoa(logHostAddr),
2274              ntohs(rxr_PortOf(tcon)), t_client->ViceId));
2275
2276     queue_NodeInit(&tcbv);
2277     tcbv.call = acall;
2278     cbv = &tcbv;
2279
2280     /*
2281      * Get volume/vnode for the fetched file; caller's access rights to
2282      * it are also returned
2283      */
2284     if ((errorCode =
2285          GetVolumePackageWithCall(acall, cbv, Fid, &volptr, &targetptr, DONTCHECK,
2286                           &parentwhentargetnotdir, &client, READ_LOCK,
2287                           &rights, &anyrights, 0)))
2288         goto Bad_FetchData;
2289
2290     SetVolumeSync(Sync, volptr);
2291
2292     /*
2293      * Remember that another read operation was performed.
2294      */
2295     FS_LOCK;
2296     if (client->InSameNetwork)
2297         readIdx = VOL_STATS_SAME_NET;
2298     else
2299         readIdx = VOL_STATS_DIFF_NET;
2300     V_stat_reads(volptr, readIdx)++;
2301     if (client->ViceId != AnonymousID) {
2302         V_stat_reads(volptr, readIdx + 1)++;
2303     }
2304     FS_UNLOCK;
2305     /* Check whether the caller has permission access to fetch the data */
2306     if ((errorCode =
2307          Check_PermissionRights(targetptr, client, rights, CHK_FETCHDATA, 0)))
2308         goto Bad_FetchData;
2309
2310     /*
2311      * Drop the read lock on the parent directory after saving the parent
2312      * vnode information we need to pass to GetStatus
2313      */
2314     if (parentwhentargetnotdir != NULL) {
2315         tparentwhentargetnotdir = *parentwhentargetnotdir;
2316         VPutVnode(&fileCode, parentwhentargetnotdir);
2317         opr_Assert(!fileCode || (fileCode == VSALVAGE));
2318         parentwhentargetnotdir = NULL;
2319     }
2320
2321     fsstats_StartXfer(&fsstats, FS_STATS_XFERIDX_FETCHDATA);
2322
2323     /* actually do the data transfer */
2324     errorCode =
2325         FetchData_RXStyle(volptr, targetptr, acall, Pos, Len, type,
2326                           &bytesToXfer, &bytesXferred);
2327
2328     fsstats_FinishXfer(&fsstats, errorCode, bytesToXfer, bytesXferred,
2329                        &remainder);
2330
2331     if (errorCode)
2332         goto Bad_FetchData;
2333
2334     /* write back  the OutStatus from the target vnode  */
2335     GetStatus(targetptr, OutStatus, rights, anyrights,
2336               &tparentwhentargetnotdir);
2337
2338     rx_KeepAliveOn(acall); /* I/O done */
2339
2340     /* if a r/w volume, promise a callback to the caller */
2341     if (VolumeWriteable(volptr))
2342         SetCallBackStruct(AddCallBack(client->host, Fid), CallBack);
2343     else {
2344         struct AFSFid myFid;
2345         memset(&myFid, 0, sizeof(struct AFSFid));
2346         myFid.Volume = Fid->Volume;
2347         SetCallBackStruct(AddVolCallBack(client->host, &myFid), CallBack);
2348     }
2349
2350   Bad_FetchData:
2351     /* Update and store volume/vnode and parent vnodes back */
2352     (void)PutVolumePackageWithCall(acall, parentwhentargetnotdir, targetptr,
2353                                    (Vnode *) 0, volptr, &client, cbv);
2354     ViceLog(2, ("SRXAFS_FetchData returns %d\n", errorCode));
2355     errorCode = CallPostamble(tcon, errorCode, thost);
2356
2357     fsstats_FinishOp(&fsstats, errorCode);
2358
2359     osi_auditU(acall, FetchDataEvent, errorCode,
2360                AUD_ID, t_client ? t_client->ViceId : 0,
2361                AUD_FID, Fid, AUD_END);
2362     return (errorCode);
2363
2364 }                               /*SRXAFS_FetchData */
2365
2366 afs_int32
2367 SRXAFS_FetchData(struct rx_call * acall, struct AFSFid * Fid, afs_int32 Pos,
2368                  afs_int32 Len, struct AFSFetchStatus * OutStatus,
2369                  struct AFSCallBack * CallBack, struct AFSVolSync * Sync)
2370 {
2371     return common_FetchData64(acall, Fid, Pos, Len, OutStatus, CallBack,
2372                               Sync, 0);
2373 }
2374
2375 afs_int32
2376 SRXAFS_FetchData64(struct rx_call * acall, struct AFSFid * Fid, afs_int64 Pos,
2377                    afs_int64 Len, struct AFSFetchStatus * OutStatus,
2378                    struct AFSCallBack * CallBack, struct AFSVolSync * Sync)
2379 {
2380     int code;
2381     afs_sfsize_t tPos, tLen;
2382
2383     tPos = (afs_sfsize_t) Pos;
2384     tLen = (afs_sfsize_t) Len;
2385
2386     code =
2387         common_FetchData64(acall, Fid, tPos, tLen, OutStatus, CallBack, Sync,
2388                            1);
2389     return code;
2390 }
2391
2392 afs_int32
2393 SRXAFS_FetchACL(struct rx_call * acall, struct AFSFid * Fid,
2394                 struct AFSOpaque * AccessList,
2395                 struct AFSFetchStatus * OutStatus, struct AFSVolSync * Sync)
2396 {
2397     Vnode *targetptr = 0;       /* pointer to vnode to fetch */
2398     Vnode *parentwhentargetnotdir = 0;  /* parent vnode if targetptr is a file */
2399     Error errorCode = 0;                /* return error code to caller */
2400     Volume *volptr = 0;         /* pointer to the volume */
2401     struct client *client = 0;  /* pointer to the client data */
2402     afs_int32 rights, anyrights;        /* rights for this and any user */
2403     struct rx_connection *tcon = rx_ConnectionOf(acall);
2404     struct host *thost;
2405     struct client *t_client = NULL;     /* tmp ptr to client data */
2406     struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
2407     struct fsstats fsstats;
2408
2409     fsstats_StartOp(&fsstats, FS_STATS_RPCIDX_FETCHACL);
2410
2411     ViceLog(1,
2412             ("SAFS_FetchACL, Fid = %u.%u.%u\n", Fid->Volume, Fid->Vnode,
2413              Fid->Unique));
2414     FS_LOCK;
2415     AFSCallStats.FetchACL++, AFSCallStats.TotalCalls++;
2416     FS_UNLOCK;
2417     if ((errorCode = CallPreamble(acall, ACTIVECALL, &tcon, &thost)))
2418         goto Bad_FetchACL;
2419
2420     /* Get ptr to client data for user Id for logging */
2421     t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
2422     logHostAddr.s_addr = rxr_HostOf(tcon);
2423     ViceLog(5,
2424             ("SAFS_FetchACL, Fid = %u.%u.%u, Host %s:%d, Id %d\n", Fid->Volume,
2425              Fid->Vnode, Fid->Unique, inet_ntoa(logHostAddr),
2426              ntohs(rxr_PortOf(tcon)), t_client->ViceId));
2427
2428     AccessList->AFSOpaque_len = 0;
2429     AccessList->AFSOpaque_val = malloc(AFSOPAQUEMAX);
2430     if (!AccessList->AFSOpaque_val) {
2431         ViceLogThenPanic(0, ("Failed malloc in SRXAFS_FetchACL\n"));
2432     }
2433
2434     /*
2435      * Get volume/vnode for the fetched file; caller's access rights to it
2436      * are also returned
2437      */
2438     if ((errorCode =
2439          GetVolumePackage(acall, Fid, &volptr, &targetptr, DONTCHECK,
2440                           &parentwhentargetnotdir, &client, READ_LOCK,
2441                           &rights, &anyrights)))
2442         goto Bad_FetchACL;
2443
2444     SetVolumeSync(Sync, volptr);
2445
2446     /* Check whether we have permission to fetch the ACL */
2447     if ((errorCode =
2448          Check_PermissionRights(targetptr, client, rights, CHK_FETCHACL, 0)))
2449         goto Bad_FetchACL;
2450
2451     /* Get the Access List from the dir's vnode */
2452     if ((errorCode =
2453          RXFetch_AccessList(targetptr, parentwhentargetnotdir, AccessList)))
2454         goto Bad_FetchACL;
2455
2456     /* Get OutStatus back From the target Vnode  */
2457     GetStatus(targetptr, OutStatus, rights, anyrights,
2458               parentwhentargetnotdir);
2459
2460   Bad_FetchACL:
2461     /* Update and store volume/vnode and parent vnodes back */
2462     (void)PutVolumePackage(acall, parentwhentargetnotdir, targetptr,
2463                            (Vnode *) 0, volptr, &client);
2464     ViceLog(2,
2465             ("SAFS_FetchACL returns %d (ACL=%s)\n", errorCode,
2466              AccessList->AFSOpaque_val));
2467     errorCode = CallPostamble(tcon, errorCode, thost);
2468
2469     fsstats_FinishOp(&fsstats, errorCode);
2470
2471     osi_auditU(acall, FetchACLEvent, errorCode,
2472                AUD_ID, t_client ? t_client->ViceId : 0,
2473                AUD_FID, Fid,
2474                AUD_ACL, AccessList->AFSOpaque_val, AUD_END);
2475     return errorCode;
2476 }                               /*SRXAFS_FetchACL */
2477
2478
2479 /*
2480  * This routine is called exclusively by SRXAFS_FetchStatus(), and should be
2481  * merged into it when possible.
2482  */
2483 static afs_int32
2484 SAFSS_FetchStatus(struct rx_call *acall, struct AFSFid *Fid,
2485                   struct AFSFetchStatus *OutStatus,
2486                   struct AFSCallBack *CallBack, struct AFSVolSync *Sync)
2487 {
2488     Vnode *targetptr = 0;       /* pointer to vnode to fetch */
2489     Vnode *parentwhentargetnotdir = 0;  /* parent vnode if targetptr is a file */
2490     Error errorCode = 0;                /* return code to caller */
2491     Volume *volptr = 0;         /* pointer to the volume */
2492     struct client *client = 0;  /* pointer to the client data */
2493     afs_int32 rights, anyrights;        /* rights for this and any user */
2494     struct client *t_client = NULL;     /* tmp ptr to client data */
2495     struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
2496     struct rx_connection *tcon = rx_ConnectionOf(acall);
2497
2498     /* Get ptr to client data for user Id for logging */
2499     t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
2500     logHostAddr.s_addr = rxr_HostOf(tcon);
2501     ViceLog(1,
2502             ("SAFS_FetchStatus,  Fid = %u.%u.%u, Host %s:%d, Id %d\n",
2503              Fid->Volume, Fid->Vnode, Fid->Unique, inet_ntoa(logHostAddr),
2504              ntohs(rxr_PortOf(tcon)), t_client->ViceId));
2505     FS_LOCK;
2506     AFSCallStats.FetchStatus++, AFSCallStats.TotalCalls++;
2507     FS_UNLOCK;
2508     /*
2509      * Get volume/vnode for the fetched file; caller's rights to it are
2510      * also returned
2511      */
2512     if ((errorCode =
2513          GetVolumePackage(acall, Fid, &volptr, &targetptr, DONTCHECK,
2514                           &parentwhentargetnotdir, &client, READ_LOCK,
2515                           &rights, &anyrights)))
2516         goto Bad_FetchStatus;
2517
2518     rx_KeepAliveOn(acall);
2519
2520     /* set volume synchronization information */
2521     SetVolumeSync(Sync, volptr);
2522
2523     /* Are we allowed to fetch Fid's status? */
2524     if (targetptr->disk.type != vDirectory) {
2525         if ((errorCode =
2526              Check_PermissionRights(targetptr, client, rights,
2527                                     CHK_FETCHSTATUS, 0))) {
2528             if (rx_GetCallAbortCode(acall) == errorCode)
2529                 rx_SetCallAbortCode(acall, 0);
2530             goto Bad_FetchStatus;
2531         }
2532     }
2533
2534     /* set OutStatus From the Fid  */
2535     GetStatus(targetptr, OutStatus, rights, anyrights,
2536               parentwhentargetnotdir);
2537
2538     /* If a r/w volume, also set the CallBack state */
2539     if (VolumeWriteable(volptr))
2540         SetCallBackStruct(AddCallBack(client->host, Fid), CallBack);
2541     else {
2542         struct AFSFid myFid;
2543         memset(&myFid, 0, sizeof(struct AFSFid));
2544         myFid.Volume = Fid->Volume;
2545         SetCallBackStruct(AddVolCallBack(client->host, &myFid), CallBack);
2546     }
2547
2548   Bad_FetchStatus:
2549     /* Update and store volume/vnode and parent vnodes back */
2550     (void)PutVolumePackage(acall, parentwhentargetnotdir, targetptr,
2551                            (Vnode *) 0, volptr, &client);
2552     ViceLog(2, ("SAFS_FetchStatus returns %d\n", errorCode));
2553     return errorCode;
2554
2555 }                               /*SAFSS_FetchStatus */
2556
2557
2558 afs_int32
2559 SRXAFS_BulkStatus(struct rx_call * acall, struct AFSCBFids * Fids,
2560                   struct AFSBulkStats * OutStats, struct AFSCBs * CallBacks,
2561                   struct AFSVolSync * Sync)
2562 {
2563     int i;
2564     afs_int32 nfiles;
2565     Vnode *targetptr = 0;       /* pointer to vnode to fetch */
2566     Vnode *parentwhentargetnotdir = 0;  /* parent vnode if targetptr is a file */
2567     Error errorCode = 0;                /* return code to caller */
2568     Volume *volptr = 0;         /* pointer to the volume */
2569     struct client *client = 0;  /* pointer to the client data */
2570     afs_int32 rights, anyrights;        /* rights for this and any user */
2571     struct AFSFid *tfid;        /* file id we're dealing with now */
2572     struct rx_connection *tcon = rx_ConnectionOf(acall);
2573     struct host *thost;
2574     struct client *t_client = NULL;     /* tmp pointer to the client data */
2575     struct fsstats fsstats;
2576
2577     fsstats_StartOp(&fsstats, FS_STATS_RPCIDX_BULKSTATUS);
2578
2579     ViceLog(1, ("SAFS_BulkStatus\n"));
2580     FS_LOCK;
2581     AFSCallStats.TotalCalls++;
2582     FS_UNLOCK;
2583     nfiles = Fids->AFSCBFids_len;       /* # of files in here */
2584     if (nfiles <= 0) {          /* Sanity check */
2585         errorCode = EINVAL;
2586         goto Audit_and_Return;
2587     }
2588
2589     /* allocate space for return output parameters */
2590     OutStats->AFSBulkStats_val = malloc(nfiles * sizeof(struct AFSFetchStatus));
2591     if (!OutStats->AFSBulkStats_val) {
2592         ViceLogThenPanic(0, ("Failed malloc in SRXAFS_BulkStatus\n"));
2593     }
2594     OutStats->AFSBulkStats_len = nfiles;
2595     CallBacks->AFSCBs_val = malloc(nfiles * sizeof(struct AFSCallBack));
2596     if (!CallBacks->AFSCBs_val) {
2597         ViceLogThenPanic(0, ("Failed malloc in SRXAFS_BulkStatus\n"));
2598     }
2599     CallBacks->AFSCBs_len = nfiles;
2600
2601     if ((errorCode = CallPreamble(acall, ACTIVECALL, &tcon, &thost)))
2602         goto Bad_BulkStatus;
2603
2604     tfid = Fids->AFSCBFids_val;
2605     for (i = 0; i < nfiles; i++, tfid++) {
2606         /*
2607          * Get volume/vnode for the fetched file; caller's rights to it
2608          * are also returned
2609          */
2610         if ((errorCode =
2611              GetVolumePackage(acall, tfid, &volptr, &targetptr, DONTCHECK,
2612                               &parentwhentargetnotdir, &client, READ_LOCK,
2613                               &rights, &anyrights)))
2614             goto Bad_BulkStatus;
2615
2616         rx_KeepAliveOn(acall);
2617
2618         /* set volume synchronization information, but only once per call */
2619         if (i == 0)
2620             SetVolumeSync(Sync, volptr);
2621
2622         /* Are we allowed to fetch Fid's status? */
2623         if (targetptr->disk.type != vDirectory) {
2624             if ((errorCode =
2625                  Check_PermissionRights(targetptr, client, rights,
2626                                         CHK_FETCHSTATUS, 0))) {
2627                 if (rx_GetCallAbortCode(acall) == errorCode)
2628                     rx_SetCallAbortCode(acall, 0);
2629                 goto Bad_BulkStatus;
2630             }
2631         }
2632
2633         /* set OutStatus From the Fid  */
2634         GetStatus(targetptr, &OutStats->AFSBulkStats_val[i], rights,
2635                   anyrights, parentwhentargetnotdir);
2636
2637         /* If a r/w volume, also set the CallBack state */
2638         if (VolumeWriteable(volptr))
2639             SetCallBackStruct(AddBulkCallBack(client->host, tfid),
2640                               &CallBacks->AFSCBs_val[i]);
2641         else {
2642             struct AFSFid myFid;
2643             memset(&myFid, 0, sizeof(struct AFSFid));
2644             myFid.Volume = tfid->Volume;
2645             SetCallBackStruct(AddVolCallBack(client->host, &myFid),
2646                               &CallBacks->AFSCBs_val[i]);
2647         }
2648
2649         /* put back the file ID and volume */
2650         (void)PutVolumePackage(acall, parentwhentargetnotdir, targetptr,
2651                                (Vnode *) 0, volptr, &client);
2652         parentwhentargetnotdir = (Vnode *) 0;
2653         targetptr = (Vnode *) 0;
2654         volptr = (Volume *) 0;
2655         client = (struct client *)0;
2656     }
2657
2658   Bad_BulkStatus:
2659     /* Update and store volume/vnode and parent vnodes back */
2660     (void)PutVolumePackage(acall, parentwhentargetnotdir, targetptr,
2661                            (Vnode *) 0, volptr, &client);
2662     errorCode = CallPostamble(tcon, errorCode, thost);
2663
2664     t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
2665
2666     fsstats_FinishOp(&fsstats, errorCode);
2667
2668   Audit_and_Return:
2669     ViceLog(2, ("SAFS_BulkStatus        returns %d\n", errorCode));
2670     osi_auditU(acall, BulkFetchStatusEvent, errorCode,
2671                AUD_ID, t_client ? t_client->ViceId : 0,
2672                AUD_FIDS, Fids, AUD_END);
2673     return errorCode;
2674
2675 }                               /*SRXAFS_BulkStatus */
2676
2677
2678 afs_int32
2679 SRXAFS_InlineBulkStatus(struct rx_call * acall, struct AFSCBFids * Fids,
2680                         struct AFSBulkStats * OutStats,
2681                         struct AFSCBs * CallBacks, struct AFSVolSync * Sync)
2682 {
2683     int i;
2684     afs_int32 nfiles;
2685     Vnode *targetptr = 0;       /* pointer to vnode to fetch */
2686     Vnode *parentwhentargetnotdir = 0;  /* parent vnode if targetptr is a file */
2687     Error errorCode = 0;                /* return code to caller */
2688     Volume *volptr = 0;         /* pointer to the volume */
2689     struct client *client = 0;  /* pointer to the client data */
2690     afs_int32 rights, anyrights;        /* rights for this and any user */
2691     struct AFSFid *tfid;        /* file id we're dealing with now */
2692     struct rx_connection *tcon;
2693     struct host *thost;
2694     struct client *t_client = NULL;     /* tmp ptr to client data */
2695     AFSFetchStatus *tstatus;
2696     int VolSync_set = 0;
2697     struct fsstats fsstats;
2698
2699     fsstats_StartOp(&fsstats, FS_STATS_RPCIDX_BULKSTATUS);
2700
2701     ViceLog(1, ("SAFS_InlineBulkStatus\n"));
2702     FS_LOCK;
2703     AFSCallStats.TotalCalls++;
2704     FS_UNLOCK;
2705     nfiles = Fids->AFSCBFids_len;       /* # of files in here */
2706     if (nfiles <= 0) {          /* Sanity check */
2707         errorCode = EINVAL;
2708         goto Audit_and_Return;
2709     }
2710
2711     /* allocate space for return output parameters */
2712     OutStats->AFSBulkStats_val = calloc(nfiles, sizeof(struct AFSFetchStatus));
2713     if (!OutStats->AFSBulkStats_val) {
2714         ViceLogThenPanic(0, ("Failed malloc in SRXAFS_FetchStatus\n"));
2715     }
2716     OutStats->AFSBulkStats_len = nfiles;
2717     CallBacks->AFSCBs_val = calloc(nfiles, sizeof(struct AFSCallBack));
2718     if (!CallBacks->AFSCBs_val) {
2719         ViceLogThenPanic(0, ("Failed malloc in SRXAFS_FetchStatus\n"));
2720     }
2721     CallBacks->AFSCBs_len = nfiles;
2722
2723     /* Zero out return values to avoid leaking information on partial succes */
2724     memset(Sync, 0, sizeof(*Sync));
2725
2726     if ((errorCode = CallPreamble(acall, ACTIVECALL, &tcon, &thost))) {
2727         goto Bad_InlineBulkStatus;
2728     }
2729
2730     tfid = Fids->AFSCBFids_val;
2731     for (i = 0; i < nfiles; i++, tfid++) {
2732         /*
2733          * Get volume/vnode for the fetched file; caller's rights to it
2734          * are also returned
2735          */
2736         if ((errorCode =
2737              GetVolumePackage(acall, tfid, &volptr, &targetptr, DONTCHECK,
2738                               &parentwhentargetnotdir, &client, READ_LOCK,
2739                               &rights, &anyrights))) {
2740             tstatus = &OutStats->AFSBulkStats_val[i];
2741
2742             if (thost->hostFlags & HERRORTRANS) {
2743                 tstatus->errorCode = sys_error_to_et(errorCode);
2744             } else {
2745                 tstatus->errorCode = errorCode;
2746             }
2747
2748             PutVolumePackage(acall, parentwhentargetnotdir, targetptr,
2749                              (Vnode *) 0, volptr, &client);
2750             parentwhentargetnotdir = (Vnode *) 0;
2751             targetptr = (Vnode *) 0;
2752             volptr = (Volume *) 0;
2753             client = (struct client *)0;
2754             continue;
2755         }
2756
2757         rx_KeepAliveOn(acall);
2758
2759         /* set volume synchronization information, but only once per call */
2760         if (!VolSync_set) {
2761             SetVolumeSync(Sync, volptr);
2762             VolSync_set = 1;
2763         }
2764
2765         /* Are we allowed to fetch Fid's status? */
2766         if (targetptr->disk.type != vDirectory) {
2767             if ((errorCode =
2768                  Check_PermissionRights(targetptr, client, rights,
2769                                         CHK_FETCHSTATUS, 0))) {
2770                 tstatus = &OutStats->AFSBulkStats_val[i];
2771
2772                 if (thost->hostFlags & HERRORTRANS) {
2773                     tstatus->errorCode = sys_error_to_et(errorCode);
2774                 } else {
2775                     tstatus->errorCode = errorCode;
2776                 }
2777
2778                 (void)PutVolumePackage(acall, parentwhentargetnotdir,
2779                                        targetptr, (Vnode *) 0, volptr,
2780                                        &client);
2781                 parentwhentargetnotdir = (Vnode *) 0;
2782                 targetptr = (Vnode *) 0;
2783                 volptr = (Volume *) 0;
2784                 client = (struct client *)0;
2785                 continue;
2786             }
2787         }
2788
2789         /* set OutStatus From the Fid  */
2790         GetStatus(targetptr,
2791                   (struct AFSFetchStatus *)&OutStats->AFSBulkStats_val[i],
2792                   rights, anyrights, parentwhentargetnotdir);
2793
2794         /* If a r/w volume, also set the CallBack state */
2795         if (VolumeWriteable(volptr))
2796             SetCallBackStruct(AddBulkCallBack(client->host, tfid),
2797                               &CallBacks->AFSCBs_val[i]);
2798         else {
2799             struct AFSFid myFid;
2800             memset(&myFid, 0, sizeof(struct AFSFid));
2801             myFid.Volume = tfid->Volume;
2802             SetCallBackStruct(AddVolCallBack(client->host, &myFid),
2803                               &CallBacks->AFSCBs_val[i]);
2804         }
2805
2806         /* put back the file ID and volume */
2807         (void)PutVolumePackage(acall, parentwhentargetnotdir, targetptr,
2808                                (Vnode *) 0, volptr, &client);
2809         parentwhentargetnotdir = (Vnode *) 0;
2810         targetptr = (Vnode *) 0;
2811         volptr = (Volume *) 0;
2812         client = (struct client *)0;
2813     }
2814     errorCode = 0;
2815
2816   Bad_InlineBulkStatus:
2817     /* Update and store volume/vnode and parent vnodes back */
2818     (void)PutVolumePackage(acall, parentwhentargetnotdir, targetptr,
2819                            (Vnode *) 0, volptr, &client);
2820     errorCode = CallPostamble(tcon, errorCode, thost);
2821
2822     t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
2823
2824     fsstats_FinishOp(&fsstats, errorCode);
2825
2826   Audit_and_Return:
2827     ViceLog(2, ("SAFS_InlineBulkStatus  returns %d\n", errorCode));
2828     osi_auditU(acall, InlineBulkFetchStatusEvent, errorCode,
2829                AUD_ID, t_client ? t_client->ViceId : 0,
2830                AUD_FIDS, Fids, AUD_END);
2831     return errorCode;
2832
2833 }                               /*SRXAFS_InlineBulkStatus */
2834
2835
2836 afs_int32
2837 SRXAFS_FetchStatus(struct rx_call * acall, struct AFSFid * Fid,
2838                    struct AFSFetchStatus * OutStatus,
2839                    struct AFSCallBack * CallBack, struct AFSVolSync * Sync)
2840 {
2841     afs_int32 code;
2842     struct rx_connection *tcon;
2843     struct host *thost;
2844     struct client *t_client = NULL;     /* tmp ptr to client data */
2845     struct fsstats fsstats;
2846
2847     fsstats_StartOp(&fsstats, FS_STATS_RPCIDX_FETCHSTATUS);
2848
2849     if ((code = CallPreamble(acall, ACTIVECALL, &tcon, &thost)))
2850         goto Bad_FetchStatus;
2851
2852     code = SAFSS_FetchStatus(acall, Fid, OutStatus, CallBack, Sync);
2853
2854   Bad_FetchStatus:
2855     code = CallPostamble(tcon, code, thost);
2856
2857     t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
2858
2859     fsstats_FinishOp(&fsstats, code);
2860
2861     osi_auditU(acall, FetchStatusEvent, code,
2862                AUD_ID, t_client ? t_client->ViceId : 0,
2863                AUD_FID, Fid, AUD_END);
2864     return code;
2865
2866 }                               /*SRXAFS_FetchStatus */
2867
2868 static
2869   afs_int32
2870 common_StoreData64(struct rx_call *acall, struct AFSFid *Fid,
2871                    struct AFSStoreStatus *InStatus, afs_fsize_t Pos,
2872                    afs_fsize_t Length, afs_fsize_t FileLength,
2873                    struct AFSFetchStatus *OutStatus, struct AFSVolSync *Sync)
2874 {
2875     Vnode *targetptr = 0;       /* pointer to input fid */
2876     Vnode *parentwhentargetnotdir = 0;  /* parent of Fid to get ACL */
2877     Vnode tparentwhentargetnotdir;      /* parent vnode for GetStatus */
2878     Error errorCode = 0;                /* return code for caller */
2879     Error fileCode = 0;         /* return code from vol package */
2880     Volume *volptr = 0;         /* pointer to the volume header */
2881     struct client *client = 0;  /* pointer to client structure */
2882     afs_int32 rights, anyrights;        /* rights for this and any user */
2883     struct client *t_client = NULL;     /* tmp ptr to client data */
2884     struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
2885     struct rx_connection *tcon;
2886     struct host *thost;
2887     struct fsstats fsstats;
2888     afs_sfsize_t bytesToXfer;
2889     afs_sfsize_t bytesXferred;
2890     static int remainder = 0;
2891
2892     ViceLog(1,
2893             ("StoreData: Fid = %u.%u.%u\n", Fid->Volume, Fid->Vnode,
2894              Fid->Unique));
2895
2896     fsstats_StartOp(&fsstats, FS_STATS_RPCIDX_STOREDATA);
2897
2898     FS_LOCK;
2899     AFSCallStats.StoreData++, AFSCallStats.TotalCalls++;
2900     FS_UNLOCK;
2901     if ((errorCode = CallPreamble(acall, ACTIVECALL, &tcon, &thost)))
2902         goto Bad_StoreData;
2903
2904     /* Get ptr to client data for user Id for logging */
2905     t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
2906     logHostAddr.s_addr = rxr_HostOf(tcon);
2907     ViceLog(5,
2908             ("StoreData: Fid = %u.%u.%u, Host %s:%d, Id %d\n", Fid->Volume,
2909              Fid->Vnode, Fid->Unique, inet_ntoa(logHostAddr),
2910              ntohs(rxr_PortOf(tcon)), t_client->ViceId));
2911
2912     /*
2913      * Get associated volume/vnode for the stored file; caller's rights
2914      * are also returned
2915      */
2916     if ((errorCode =
2917          GetVolumePackage(acall, Fid, &volptr, &targetptr, MustNOTBeDIR,
2918                           &parentwhentargetnotdir, &client, WRITE_LOCK,
2919                           &rights, &anyrights))) {
2920         goto Bad_StoreData;
2921     }
2922
2923     rx_KeepAliveOn(acall);
2924
2925     /* set volume synchronization information */
2926     SetVolumeSync(Sync, volptr);
2927
2928     if (targetptr->disk.type == vSymlink) {
2929         /* Should we return a better error code here??? */
2930         errorCode = EISDIR;
2931         goto Bad_StoreData;
2932     }
2933
2934     /* Check if we're allowed to store the data */
2935     if ((errorCode =
2936          Check_PermissionRights(targetptr, client, rights, CHK_STOREDATA,
2937                                 InStatus))) {
2938         goto Bad_StoreData;
2939     }
2940
2941     /*
2942      * Drop the read lock on the parent directory after saving the parent
2943      * vnode information we need to pass to GetStatus
2944      */
2945     if (parentwhentargetnotdir != NULL) {
2946         tparentwhentargetnotdir = *parentwhentargetnotdir;
2947         rx_KeepAliveOff(acall);
2948         VPutVnode(&fileCode, parentwhentargetnotdir);
2949         rx_KeepAliveOn(acall);
2950         opr_Assert(!fileCode || (fileCode == VSALVAGE));
2951         parentwhentargetnotdir = NULL;
2952     }
2953
2954     fsstats_StartXfer(&fsstats, FS_STATS_XFERIDX_STOREDATA);
2955
2956     errorCode =
2957         StoreData_RXStyle(volptr, targetptr, Fid, client, acall, Pos, Length,
2958                           FileLength, (InStatus->Mask & AFS_FSYNC),
2959                           &bytesToXfer, &bytesXferred);
2960
2961     fsstats_FinishXfer(&fsstats, errorCode, bytesToXfer, bytesXferred,
2962                        &remainder);
2963
2964     if (errorCode && (!targetptr->changed_newTime))
2965         goto Bad_StoreData;
2966
2967     rx_KeepAliveOff(acall);
2968     /* Update the status of the target's vnode */
2969     Update_TargetVnodeStatus(targetptr, TVS_SDATA, client, InStatus,
2970                              targetptr, volptr, 0, 0);
2971     rx_KeepAliveOn(acall);
2972
2973     /* Get the updated File's status back to the caller */
2974     GetStatus(targetptr, OutStatus, rights, anyrights,
2975               &tparentwhentargetnotdir);
2976
2977   Bad_StoreData:
2978     /* Update and store volume/vnode and parent vnodes back */
2979     (void)PutVolumePackage(acall, parentwhentargetnotdir, targetptr,
2980                            (Vnode *) 0, volptr, &client);
2981     ViceLog(2, ("SAFS_StoreData returns %d\n", errorCode));
2982
2983     errorCode = CallPostamble(tcon, errorCode, thost);
2984
2985     fsstats_FinishOp(&fsstats, errorCode);
2986
2987     osi_auditU(acall, StoreDataEvent, errorCode,
2988                AUD_ID, t_client ? t_client->ViceId : 0,
2989                AUD_FID, Fid, AUD_END);
2990     return (errorCode);
2991 }                               /*common_StoreData64 */
2992
2993 afs_int32
2994 SRXAFS_StoreData(struct rx_call * acall, struct AFSFid * Fid,
2995                  struct AFSStoreStatus * InStatus, afs_uint32 Pos,
2996                  afs_uint32 Length, afs_uint32 FileLength,
2997                  struct AFSFetchStatus * OutStatus, struct AFSVolSync * Sync)
2998 {
2999     if (FileLength > 0x7fffffff || Pos > 0x7fffffff ||
3000         (0x7fffffff - Pos) < Length)
3001         return EFBIG;
3002
3003     return common_StoreData64(acall, Fid, InStatus, Pos, Length, FileLength,
3004                               OutStatus, Sync);
3005 }                               /*SRXAFS_StoreData */
3006
3007 afs_int32
3008 SRXAFS_StoreData64(struct rx_call * acall, struct AFSFid * Fid,
3009                    struct AFSStoreStatus * InStatus, afs_uint64 Pos,
3010                    afs_uint64 Length, afs_uint64 FileLength,
3011                    struct AFSFetchStatus * OutStatus,
3012                    struct AFSVolSync * Sync)
3013 {
3014     int code;
3015     afs_fsize_t tPos;
3016     afs_fsize_t tLength;
3017     afs_fsize_t tFileLength;
3018
3019     tPos = (afs_fsize_t) Pos;
3020     tLength = (afs_fsize_t) Length;
3021     tFileLength = (afs_fsize_t) FileLength;
3022
3023     code =
3024         common_StoreData64(acall, Fid, InStatus, tPos, tLength, tFileLength,
3025                            OutStatus, Sync);
3026     return code;
3027 }
3028
3029 afs_int32
3030 SRXAFS_StoreACL(struct rx_call * acall, struct AFSFid * Fid,
3031                 struct AFSOpaque * AccessList,
3032                 struct AFSFetchStatus * OutStatus, struct AFSVolSync * Sync)
3033 {
3034     Vnode *targetptr = 0;       /* pointer to input fid */
3035     Vnode *parentwhentargetnotdir = 0;  /* parent of Fid to get ACL */
3036     Error errorCode = 0;                /* return code for caller */
3037     struct AFSStoreStatus InStatus;     /* Input status for fid */
3038     Volume *volptr = 0;         /* pointer to the volume header */
3039     struct client *client = 0;  /* pointer to client structure */
3040     afs_int32 rights, anyrights;        /* rights for this and any user */
3041     struct rx_connection *tcon;
3042     struct host *thost;
3043     struct client *t_client = NULL;     /* tmp ptr to client data */
3044     struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
3045     struct fsstats fsstats;
3046
3047     fsstats_StartOp(&fsstats, FS_STATS_RPCIDX_STOREACL);
3048
3049     if ((errorCode = CallPreamble(acall, ACTIVECALL, &tcon, &thost)))
3050         goto Bad_StoreACL;
3051
3052     /* Get ptr to client data for user Id for logging */
3053     t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
3054     logHostAddr.s_addr = rxr_HostOf(tcon);
3055     ViceLog(1,
3056             ("SAFS_StoreACL, Fid = %u.%u.%u, ACL=%s, Host %s:%d, Id %d\n",
3057              Fid->Volume, Fid->Vnode, Fid->Unique, AccessList->AFSOpaque_val,
3058              inet_ntoa(logHostAddr), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
3059     FS_LOCK;
3060     AFSCallStats.StoreACL++, AFSCallStats.TotalCalls++;
3061     FS_UNLOCK;
3062     InStatus.Mask = 0;          /* not storing any status */
3063
3064     /*
3065      * Get associated volume/vnode for the target dir; caller's rights
3066      * are also returned.
3067      */
3068     if ((errorCode =
3069          GetVolumePackage(acall, Fid, &volptr, &targetptr, MustBeDIR,
3070                           &parentwhentargetnotdir, &client, WRITE_LOCK,
3071                           &rights, &anyrights))) {
3072         goto Bad_StoreACL;
3073     }
3074
3075     /* set volume synchronization information */
3076     SetVolumeSync(Sync, volptr);
3077
3078     /* Check if we have permission to change the dir's ACL */
3079     if ((errorCode =
3080          Check_PermissionRights(targetptr, client, rights, CHK_STOREACL,
3081                                 &InStatus))) {
3082         goto Bad_StoreACL;
3083     }
3084
3085     /* Build and store the new Access List for the dir */
3086     if ((errorCode = RXStore_AccessList(targetptr, AccessList))) {
3087         goto Bad_StoreACL;
3088     }
3089
3090     targetptr->changed_newTime = 1;     /* status change of directory */
3091
3092     /* convert the write lock to a read lock before breaking callbacks */
3093     VVnodeWriteToRead(&errorCode, targetptr);
3094     opr_Assert(!errorCode || errorCode == VSALVAGE);
3095
3096     rx_KeepAliveOn(acall);
3097
3098     /* break call backs on the directory  */
3099     BreakCallBack(client->host, Fid, 0);
3100
3101     /* Get the updated dir's status back to the caller */
3102     GetStatus(targetptr, OutStatus, rights, anyrights, 0);
3103
3104   Bad_StoreACL:
3105     /* Update and store volume/vnode and parent vnodes back */
3106     PutVolumePackage(acall, parentwhentargetnotdir, targetptr, (Vnode *) 0,
3107                      volptr, &client);
3108     ViceLog(2, ("SAFS_StoreACL returns %d\n", errorCode));
3109     errorCode = CallPostamble(tcon, errorCode, thost);
3110
3111     fsstats_FinishOp(&fsstats, errorCode);
3112
3113     osi_auditU(acall, StoreACLEvent, errorCode,
3114                AUD_ID, t_client ? t_client->ViceId : 0,
3115                AUD_FID, Fid, AUD_ACL, AccessList->AFSOpaque_val, AUD_END);
3116     return errorCode;
3117
3118 }                               /*SRXAFS_StoreACL */
3119
3120
3121 /*
3122  * Note: This routine is called exclusively from SRXAFS_StoreStatus(), and
3123  * should be merged when possible.
3124  */
3125 static afs_int32
3126 SAFSS_StoreStatus(struct rx_call *acall, struct AFSFid *Fid,
3127                   struct AFSStoreStatus *InStatus,
3128                   struct AFSFetchStatus *OutStatus, struct AFSVolSync *Sync)
3129 {
3130     Vnode *targetptr = 0;       /* pointer to input fid */
3131     Vnode *parentwhentargetnotdir = 0;  /* parent of Fid to get ACL */
3132     Error errorCode = 0;                /* return code for caller */
3133     Volume *volptr = 0;         /* pointer to the volume header */
3134     struct client *client = 0;  /* pointer to client structure */
3135     afs_int32 rights, anyrights;        /* rights for this and any user */
3136     struct client *t_client = NULL;     /* tmp ptr to client data */
3137     struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
3138     struct rx_connection *tcon = rx_ConnectionOf(acall);
3139
3140     /* Get ptr to client data for user Id for logging */
3141     t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
3142     logHostAddr.s_addr = rxr_HostOf(tcon);
3143     ViceLog(1,
3144             ("SAFS_StoreStatus,  Fid    = %u.%u.%u, Host %s:%d, Id %d\n",
3145              Fid->Volume, Fid->Vnode, Fid->Unique, inet_ntoa(logHostAddr),
3146              ntohs(rxr_PortOf(tcon)), t_client->ViceId));
3147     FS_LOCK;
3148     AFSCallStats.StoreStatus++, AFSCallStats.TotalCalls++;
3149     FS_UNLOCK;
3150     /*
3151      * Get volume/vnode for the target file; caller's rights to it are
3152      * also returned
3153      */
3154     if ((errorCode =
3155          GetVolumePackage(acall, Fid, &volptr, &targetptr, DONTCHECK,
3156                           &parentwhentargetnotdir, &client, WRITE_LOCK,
3157                           &rights, &anyrights))) {
3158         goto Bad_StoreStatus;
3159     }
3160
3161     /* set volume synchronization information */
3162     SetVolumeSync(Sync, volptr);
3163
3164     /* Check if the caller has proper permissions to store status to Fid */
3165     if ((errorCode =
3166          Check_PermissionRights(targetptr, client, rights, CHK_STORESTATUS,
3167                                 InStatus))) {
3168         goto Bad_StoreStatus;
3169     }
3170     /*
3171      * Check for a symbolic link; we can't chmod these (otherwise could
3172      * change a symlink to a mt pt or vice versa)
3173      */
3174     if (targetptr->disk.type == vSymlink && (InStatus->Mask & AFS_SETMODE)) {
3175         errorCode = EINVAL;
3176         goto Bad_StoreStatus;
3177     }
3178
3179     /* Update the status of the target's vnode */
3180     Update_TargetVnodeStatus(targetptr, TVS_SSTATUS, client, InStatus,
3181                              (parentwhentargetnotdir ? parentwhentargetnotdir
3182                               : targetptr), volptr, 0, 0);
3183
3184     rx_KeepAliveOn(acall);
3185
3186     /* convert the write lock to a read lock before breaking callbacks */
3187     VVnodeWriteToRead(&errorCode, targetptr);
3188     opr_Assert(!errorCode || errorCode == VSALVAGE);
3189
3190     /* Break call backs on Fid */
3191     BreakCallBack(client->host, Fid, 0);
3192
3193     /* Return the updated status back to caller */
3194     GetStatus(targetptr, OutStatus, rights, anyrights,
3195               parentwhentargetnotdir);
3196
3197   Bad_StoreStatus:
3198     /* Update and store volume/vnode and parent vnodes back */
3199     PutVolumePackage(acall, parentwhentargetnotdir, targetptr, (Vnode *) 0,
3200                      volptr, &client);
3201     ViceLog(2, ("SAFS_StoreStatus returns %d\n", errorCode));
3202     return errorCode;
3203
3204 }                               /*SAFSS_StoreStatus */
3205
3206
3207 afs_int32
3208 SRXAFS_StoreStatus(struct rx_call * acall, struct AFSFid * Fid,
3209                    struct AFSStoreStatus * InStatus,
3210                    struct AFSFetchStatus * OutStatus,
3211                    struct AFSVolSync * Sync)
3212 {
3213     afs_int32 code;
3214     struct rx_connection *tcon;
3215     struct host *thost;
3216     struct client *t_client = NULL;     /* tmp ptr to client data */
3217     struct fsstats fsstats;
3218
3219     fsstats_StartOp(&fsstats, FS_STATS_RPCIDX_STORESTATUS);
3220
3221     if ((code = CallPreamble(acall, ACTIVECALL, &tcon, &thost)))
3222         goto Bad_StoreStatus;
3223
3224     code = SAFSS_StoreStatus(acall, Fid, InStatus, OutStatus, Sync);
3225
3226   Bad_StoreStatus:
3227     code = CallPostamble(tcon, code, thost);
3228
3229     t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
3230
3231     fsstats_FinishOp(&fsstats, code);
3232
3233     osi_auditU(acall, StoreStatusEvent, code,
3234                AUD_ID, t_client ? t_client->ViceId : 0,
3235                AUD_FID, Fid, AUD_END);
3236     return code;
3237
3238 }                               /*SRXAFS_StoreStatus */
3239
3240
3241 /*
3242  * This routine is called exclusively by SRXAFS_RemoveFile(), and should be
3243  * merged in when possible.
3244  */
3245 static afs_int32
3246 SAFSS_RemoveFile(struct rx_call *acall, struct AFSFid *DirFid, char *Name,
3247                  struct AFSFetchStatus *OutDirStatus, struct AFSVolSync *Sync)
3248 {
3249     Vnode *parentptr = 0;       /* vnode of input Directory */
3250     Vnode *parentwhentargetnotdir = 0;  /* parent for use in SetAccessList */
3251     Vnode *targetptr = 0;       /* file to be deleted */
3252     Volume *volptr = 0;         /* pointer to the volume header */
3253     AFSFid fileFid;             /* area for Fid from the directory */
3254     Error errorCode = 0;                /* error code */
3255     DirHandle dir;              /* Handle for dir package I/O */
3256     struct client *client = 0;  /* pointer to client structure */
3257     afs_int32 rights, anyrights;        /* rights for this and any user */
3258     struct client *t_client;    /* tmp ptr to client data */
3259     struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
3260     struct rx_connection *tcon = rx_ConnectionOf(acall);
3261
3262     FidZero(&dir);
3263     /* Get ptr to client data for user Id for logging */
3264     t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
3265     logHostAddr.s_addr = rxr_HostOf(tcon);
3266     ViceLog(1,
3267             ("SAFS_RemoveFile %s,  Did = %u.%u.%u, Host %s:%d, Id %d\n", Name,
3268              DirFid->Volume, DirFid->Vnode, DirFid->Unique,
3269              inet_ntoa(logHostAddr), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
3270     FS_LOCK;
3271     AFSCallStats.RemoveFile++, AFSCallStats.TotalCalls++;
3272     FS_UNLOCK;
3273     /*
3274      * Get volume/vnode for the parent dir; caller's access rights are
3275      * also returned
3276      */
3277     if ((errorCode =
3278          GetVolumePackage(acall, DirFid, &volptr, &parentptr, MustBeDIR,
3279                           &parentwhentargetnotdir, &client, WRITE_LOCK,
3280                           &rights, &anyrights))) {
3281         goto Bad_RemoveFile;
3282     }
3283     /* set volume synchronization information */
3284     SetVolumeSync(Sync, volptr);
3285
3286     /* Does the caller has delete (& write) access to the parent directory? */
3287     if ((errorCode = CheckWriteMode(parentptr, rights, PRSFS_DELETE))) {
3288         goto Bad_RemoveFile;
3289     }
3290
3291     /* Actually delete the desired file */
3292     if ((errorCode =
3293          DeleteTarget(parentptr, volptr, &targetptr, &dir, &fileFid, Name,
3294                       MustNOTBeDIR))) {
3295         goto Bad_RemoveFile;
3296     }
3297
3298     /* Update the vnode status of the parent dir */
3299     Update_ParentVnodeStatus(parentptr, volptr, &dir, client->ViceId,
3300                              parentptr->disk.linkCount,
3301                              client->InSameNetwork);
3302
3303     rx_KeepAliveOn(acall);
3304
3305     /* Return the updated parent dir's status back to caller */
3306     GetStatus(parentptr, OutDirStatus, rights, anyrights, 0);
3307
3308     /* Handle internal callback state for the parent and the deleted file */
3309     if (targetptr->disk.linkCount == 0) {
3310         /* no references left, discard entry */
3311         DeleteFileCallBacks(&fileFid);
3312         /* convert the parent lock to a read lock before breaking callbacks */
3313         VVnodeWriteToRead(&errorCode, parentptr);
3314         opr_Assert(!errorCode || errorCode == VSALVAGE);
3315     } else {
3316         /* convert the parent lock to a read lock before breaking callbacks */
3317         VVnodeWriteToRead(&errorCode, parentptr);
3318         opr_Assert(!errorCode || errorCode == VSALVAGE);
3319         /* convert the target lock to a read lock before breaking callbacks */
3320         VVnodeWriteToRead(&errorCode, targetptr);
3321         opr_Assert(!errorCode || errorCode == VSALVAGE);
3322         /* tell all the file has changed */
3323         BreakCallBack(client->host, &fileFid, 1);
3324     }
3325
3326     /* break call back on the directory */
3327     BreakCallBack(client->host, DirFid, 0);
3328
3329   Bad_RemoveFile:
3330     /* Update and store volume/vnode and parent vnodes back */
3331     PutVolumePackage(acall, parentwhentargetnotdir, targetptr, parentptr,
3332                      volptr, &client);
3333     FidZap(&dir);
3334     ViceLog(2, ("SAFS_RemoveFile returns %d\n", errorCode));
3335     return errorCode;
3336
3337 }                               /*SAFSS_RemoveFile */
3338
3339
3340 afs_int32
3341 SRXAFS_RemoveFile(struct rx_call * acall, struct AFSFid * DirFid, char *Name,
3342                   struct AFSFetchStatus * OutDirStatus,
3343                   struct AFSVolSync * Sync)
3344 {
3345     afs_int32 code;
3346     struct rx_connection *tcon;
3347     struct host *thost;
3348     struct client *t_client = NULL;     /* tmp ptr to client data */
3349     struct fsstats fsstats;
3350
3351     fsstats_StartOp(&fsstats, FS_STATS_RPCIDX_REMOVEFILE);
3352
3353     if ((code = CallPreamble(acall, ACTIVECALL, &tcon, &thost)))
3354         goto Bad_RemoveFile;
3355
3356     code = SAFSS_RemoveFile(acall, DirFid, Name, OutDirStatus, Sync);
3357
3358   Bad_RemoveFile:
3359     code = CallPostamble(tcon, code, thost);
3360
3361     t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
3362
3363     fsstats_FinishOp(&fsstats, code);
3364
3365     osi_auditU(acall, RemoveFileEvent, code,
3366                AUD_ID, t_client ? t_client->ViceId : 0,
3367                AUD_FID, DirFid, AUD_STR, Name, AUD_END);
3368     return code;
3369
3370 }                               /*SRXAFS_RemoveFile */
3371
3372
3373 /*
3374  * This routine is called exclusively from SRXAFS_CreateFile(), and should
3375  * be merged in when possible.
3376  */
3377 static afs_int32
3378 SAFSS_CreateFile(struct rx_call *acall, struct AFSFid *DirFid, char *Name,
3379                  struct AFSStoreStatus *InStatus, struct AFSFid *OutFid,
3380                  struct AFSFetchStatus *OutFidStatus,
3381                  struct AFSFetchStatus *OutDirStatus,
3382                  struct AFSCallBack *CallBack, struct AFSVolSync *Sync)
3383 {
3384     Vnode *parentptr = 0;       /* vnode of input Directory */
3385     Vnode *targetptr = 0;       /* vnode of the new file */
3386     Vnode *parentwhentargetnotdir = 0;  /* parent for use in SetAccessList */
3387     Volume *volptr = 0;         /* pointer to the volume header */
3388     Error errorCode = 0;                /* error code */
3389     DirHandle dir;              /* Handle for dir package I/O */
3390     struct client *client = 0;  /* pointer to client structure */
3391     afs_int32 rights, anyrights;        /* rights for this and any user */
3392     struct client *t_client;    /* tmp ptr to client data */
3393     struct in_addr logHostAddr; /* host ip holder for inet_ntoa */
3394     struct rx_connection *tcon = rx_ConnectionOf(acall);
3395
3396     FidZero(&dir);
3397
3398     /* Get ptr to client data for user Id for logging */
3399     t_client = (struct client *)rx_GetSpecific(tcon, rxcon_client_key);
3400     logHostAddr.s_addr = rxr_HostOf(tcon);
3401     ViceLog(1,
3402             ("SAFS_CreateFile %s,  Did = %u.%u.%u, Host %s:%d, Id %d\n", Name,
3403              DirFid->Volume, DirFid->Vnode, DirFid->Unique,
3404              inet_ntoa(logHostAddr), ntohs(rxr_PortOf(tcon)), t_client->ViceId));
3405     FS_LOCK;
3406     AFSCallStats.CreateFile++, AFSCallStats.TotalCalls++;
3407     FS_UNLOCK;
3408     if (!FileNameOK(Name)) {
3409         errorCode = EINVAL;
3410         goto Bad_CreateFile;
3411     }
3412
3413     /*
3414      * Get associated volume/vnode for the parent dir; caller long are
3415      * also returned
3416      */
3417     if ((errorCode =
3418          GetVolumePackage(acall, DirFid, &volptr, &parentptr, MustBeDIR,
3419                           &parentwhentargetnotdir, &client, WRITE_LOCK,
3420                           &rights, &anyrights))) {
3421         goto Bad_CreateFile;
3422     }
3423
3424     /* set volume synchronization information */
3425     SetVolumeSync(Sync, volptr);
3426
3427     /* Can we write (and insert) onto the parent directory? */
3428     if ((errorCode = CheckWriteMode(parentptr, rights, PRSFS_INSERT))) {
3429         goto Bad_CreateFile;
3430     }
3431
3432     /* get a new vnode for the file to be created and set it up */
3433     if ((errorCode =
3434          Alloc_NewVnode(parentptr, &dir, volptr, &targetptr, Name, OutFid,