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