afscp: tellmeaboutyourself stub wants host byte order
[openafs.git] / src / libafscp / afscp_callback.c
1 /* AUTORIGHTS
2 Copyright (C) 2003 - 2010 Chaskiel Grundman
3 All rights reserved
4
5 Redistribution and use in source and binary forms, with or without
6 modification, are permitted provided that the following conditions
7 are met:
8
9 1. Redistributions of source code must retain the above copyright
10    notice, this list of conditions and the following disclaimer.
11
12 2. Redistributions in binary form must reproduce the above copyright
13    notice, this list of conditions and the following disclaimer in the
14    documentation and/or other materials provided with the distribution.
15
16 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27 #include <afsconfig.h>
28 #include <afs/param.h>
29
30 #include <roken.h>
31
32 #ifdef AFS_NT40_ENV
33 #include <windows.h>
34 #include <rpc.h>
35 #include <afs/cm_server.h>
36 #include <WINNT/syscfg.h>
37 #endif
38
39 #include <afs/afsutil.h>
40 #include "afscp.h"
41 #include "afscp_internal.h"
42
43 int afs_cb_inited = 0;
44 struct interfaceAddr afs_cb_interface;
45 static int afscp_maxcallbacks = 0, afscp_cballoced = 0;
46 struct afscp_callback *allcallbacks = NULL;
47
48 /*!
49  * Initialize the callback interface structure
50  */
51 static int
52 init_afs_cb(void)
53 {
54     int cm_noIPAddr;            /* number of client network interfaces */
55     int i;
56 #ifdef AFS_NT40_ENV
57     /*
58      * This Windows section was pulled in from changes to src/venus/afsio.c but is
59      * untested here and may be unnecessary if rx_getAllAddr() can be used on that
60      * platform.  However, there was already an ifdef here surrounding UuidCreate().
61      */
62     long rx_mtu = -1;
63     int code;
64     int cm_IPAddr[CM_MAXINTERFACE_ADDR];        /* client's IP address in host order */
65     int cm_SubnetMask[CM_MAXINTERFACE_ADDR];    /* client's subnet mask in host order */
66     int cm_NetMtu[CM_MAXINTERFACE_ADDR];        /* client's MTU sizes */
67     int cm_NetFlags[CM_MAXINTERFACE_ADDR];      /* network flags */
68
69     UuidCreate((UUID *) & afs_cb_interface.uuid);
70     cm_noIPAddr = CM_MAXINTERFACE_ADDR;
71     code = syscfg_GetIFInfo(&cm_noIPAddr,
72                             cm_IPAddr, cm_SubnetMask, cm_NetMtu, cm_NetFlags);
73     if (code > 0) {
74         /* return all network interface addresses */
75         afs_cb_interface.numberOfInterfaces = cm_noIPAddr;
76         for (i = 0; i < cm_noIPAddr; i++) {
77             afs_cb_interface.addr_in[i] = cm_IPAddr[i];
78             afs_cb_interface.subnetmask[i] = cm_SubnetMask[i];
79             afs_cb_interface.mtu[i] = (rx_mtu == -1
80                                        || (rx_mtu != -1
81                                            && cm_NetMtu[i] <
82                                            rx_mtu)) ? cm_NetMtu[i] : rx_mtu;
83         }
84     } else {
85         afs_cb_interface.numberOfInterfaces = 0;
86     }
87 #else
88     afs_uuid_create(&afs_cb_interface.uuid);
89     cm_noIPAddr =
90         rx_getAllAddr((afs_uint32 *) afs_cb_interface.addr_in,
91                       AFS_MAX_INTERFACE_ADDR);
92     if (cm_noIPAddr < 0)
93         afs_cb_interface.numberOfInterfaces = 0;
94     else {
95         afs_cb_interface.numberOfInterfaces = cm_noIPAddr;
96         /* we expect these in host byte order */
97         for (i = 0; i < cm_noIPAddr; i++)
98             afs_cb_interface.addr_in[i] = ntohl(afs_cb_interface.addr_in[i]);
99     }
100 #endif
101     afs_cb_inited = 1;
102     return 0;
103 }                               /* init_afs_cb */
104
105 int
106 afscp_FindCallBack(const struct afscp_venusfid *f, const struct afscp_server *server, struct afscp_callback *ret)
107 {
108     int i;
109     struct afscp_callback *use = NULL, *cb;
110     time_t now;
111     struct afscp_venusfid fid;
112
113     ret = NULL;
114
115     time(&now);
116     for (i = 0; i < afscp_maxcallbacks; i++) {
117         cb = &allcallbacks[i];
118         if ((f->fid.Volume == cb->fid.Volume) &&
119             (f->fid.Vnode == cb->fid.Vnode) &&
120             (f->fid.Unique == cb->fid.Unique)) {
121             if (server && (cb->server != server))
122                 continue;
123             use = cb;
124             break;
125         }
126     }
127     if (!use)
128         return -1;
129
130     if (use->cb.ExpirationTime + use->as_of < now) {
131         if (use->valid) {
132             fid.cell = afscp_CellById(use->server->cell);
133             memcpy(&fid.fid, &use->fid, sizeof(struct AFSFid));
134             _StatInvalidate(&fid);
135         }
136         use->valid = 0;
137     }
138
139     if (use->valid)
140         ret = use;
141     else
142         return -1;
143
144     return 0;
145 }
146
147 int
148 afscp_AddCallBack(const struct afscp_server *server,
149                   const struct AFSFid *fid,
150                   const struct AFSFetchStatus *fst,
151                   const struct AFSCallBack *cb, const time_t as_of)
152 {
153     int i;
154     struct afscp_callback *use = NULL, *newlist;
155     struct afscp_venusfid f;
156     time_t now;
157     
158     time(&now);
159     
160     for (i = 0; i < afscp_maxcallbacks; i++) {
161         if (allcallbacks[i].cb.ExpirationTime + allcallbacks[i].as_of < now) {
162             if (allcallbacks[i].valid) {
163                 f.cell = afscp_CellById(allcallbacks[i].server->cell);
164                 memcpy(&f.fid, &allcallbacks[i].fid, sizeof(struct AFSFid));
165                 _StatInvalidate(&f);
166             }
167             allcallbacks[i].valid = 0;
168         }
169         
170         if (allcallbacks[i].valid == 0)
171             use = &allcallbacks[i];
172         if ((allcallbacks[i].server == server) &&
173             (fid->Volume == allcallbacks[i].fid.Volume) &&
174             (fid->Vnode == allcallbacks[i].fid.Vnode) &&
175             (fid->Unique == allcallbacks[i].fid.Unique)) {
176             use = &allcallbacks[i];
177             break;
178         }
179     }
180     if (use == NULL) {
181         if (afscp_maxcallbacks >= afscp_cballoced) {
182             if (afscp_cballoced != 0)
183                 afscp_cballoced = afscp_cballoced * 2;
184             else
185                 afscp_cballoced = 4;
186             newlist = realloc(allcallbacks, afscp_cballoced *
187                               sizeof(struct afscp_callback));
188             if (newlist == NULL) {
189                 return -1;
190             }
191             allcallbacks = newlist;
192         }
193         use = &allcallbacks[afscp_maxcallbacks++];
194     }
195     use->valid = 1;
196     use->server = server;
197     memmove(&use->fid, fid, sizeof(struct AFSFid));
198     memmove(&use->cb, cb, sizeof(struct AFSCallBack));
199     use->as_of = as_of;
200     f.cell = afscp_CellById(server->cell);
201     memcpy(&f.fid, fid, sizeof(struct AFSFid));
202     _StatStuff(&f, fst);
203     return 0;
204 }                               /* afscp_AddCallBack */
205
206 int
207 afscp_RemoveCallBack(const struct afscp_server *server,
208                      const struct afscp_venusfid *f)
209 {
210     struct afscp_callback *cb;
211     int i;
212
213     _StatInvalidate(f);
214     if (server == NULL) {
215         return 0;
216     }
217     for (i = 0; i < afscp_maxcallbacks; i++) {
218         cb = &allcallbacks[i];
219         if ((cb->server == server) &&
220             (f->fid.Volume == cb->fid.Volume) &&
221             (f->fid.Vnode == cb->fid.Vnode) &&
222             (f->fid.Unique == cb->fid.Unique)) {
223             cb->valid = 0;
224             break;
225         }
226     }
227     return 0;
228 }                               /* afscp_ReturnCallBacks */
229
230 int
231 afscp_ReturnCallBacks(const struct afscp_server *server)
232 {
233     struct AFSCBFids theFids;
234     struct AFSCBs theCBs;
235     struct afscp_callback *cb;
236     struct afscp_venusfid f;
237     struct rx_connection *c;
238     int inited = 0;
239     int ncallbacks = 0;
240     int i, j, code;
241     time_t now;
242
243     time(&now);
244
245     for (i = 0; i < afscp_maxcallbacks; i++) {
246         cb = &allcallbacks[i];
247         if (cb->server != server) {
248             continue;
249         }
250         if (cb->cb.ExpirationTime + cb->as_of < now) {
251             if (cb->valid) {
252                 f.cell = afscp_CellById(cb->server->cell);
253                 memcpy(&f.fid, &cb->fid, sizeof(struct AFSFid));
254                 _StatInvalidate(&f);
255             }
256             cb->valid = 0;
257             continue;
258         }
259         if (!inited) {
260             theFids.AFSCBFids_val = malloc(sizeof(struct AFSFid) * AFSCBMAX);
261             if (!theFids.AFSCBFids_val) {
262                 return -1;
263             }
264             memset(theFids.AFSCBFids_val, 0,
265                    sizeof(struct AFSFid) * AFSCBMAX);
266             theCBs.AFSCBs_val = malloc(sizeof(struct AFSCallBack) * AFSCBMAX);
267             if (!theCBs.AFSCBs_val) {
268                 free(theFids.AFSCBFids_val);
269                 return -1;
270             }
271             memset(theCBs.AFSCBs_val, 0,
272                    sizeof(struct AFSCallBack) * AFSCBMAX);
273             inited = 1;
274         }
275
276         if (ncallbacks == AFSCBMAX) {
277             theFids.AFSCBFids_len = ncallbacks;
278             theCBs.AFSCBs_len = ncallbacks;
279             for (j = 0; j < server->naddrs; j++) {
280                 c = afscp_ServerConnection(server, j);
281                 if (c == NULL)
282                     break;
283                 code = RXAFS_GiveUpCallBacks(c, &theFids, &theCBs);
284                 if (code == 0)
285                     break;
286             }
287             ncallbacks = 0;
288         }
289         memmove(&theFids.AFSCBFids_val[ncallbacks], &cb->fid,
290                 sizeof(struct AFSFid));
291         memmove(&theCBs.AFSCBs_val[ncallbacks], &cb->cb,
292                 sizeof(struct AFSCallBack));
293
294         theCBs.AFSCBs_val[ncallbacks].CallBackType = CB_DROPPED;
295         ncallbacks++;
296         if (cb->valid) {
297             f.cell = afscp_CellById(cb->server->cell);
298             memcpy(&f.fid, &cb->fid, sizeof(struct AFSFid));
299             _StatInvalidate(&f);
300         }
301
302         cb->valid = 0;
303     }
304     if (ncallbacks > 0) {
305         theFids.AFSCBFids_len = ncallbacks;
306         theCBs.AFSCBs_len = ncallbacks;
307         for (j = 0; j < server->naddrs; j++) {
308             c = afscp_ServerConnection(server, j);
309             if (c == NULL)
310                 break;
311             code = RXAFS_GiveUpCallBacks(c, &theFids, &theCBs);
312             if (code == 0)
313                 break;
314         }
315         free(theFids.AFSCBFids_val);
316         free(theCBs.AFSCBs_val);
317     }
318     return 0;
319 }                               /* afscp_ReturnCallBacks */
320
321 int
322 afscp_ReturnAllCallBacks(void)
323 {
324     struct afscp_server *s;
325     int i;
326
327     if (allcallbacks == NULL)
328         return 0;
329     for (i = 0; (s = afscp_ServerByIndex(i)); i++) {
330         afscp_ReturnCallBacks(s);
331     }
332     free(allcallbacks);
333     allcallbacks = NULL;
334     afscp_maxcallbacks = 0;
335     afscp_cballoced = 0;
336     return 0;
337 }                               /* afscp_ReturnAllCallBacks */
338
339 /*!
340  * Handle a set of callbacks from the File Server.
341  *
342  * \param[in]   rxcall          Ptr to the associated Rx call structure.
343  * \param[in]   Fids_Array      Ptr to the set of Fids.
344  * \param[in]   CallBacks_Array Ptr to the set of callbacks.
345  *
346  * \post Returns RXGEN_SUCCESS on success, Error value otherwise.
347  *
348  */
349 afs_int32
350 SRXAFSCB_CallBack(struct rx_call * rxcall, AFSCBFids * Fids_Array,
351                   AFSCBs * CallBack_Array)
352 {
353     struct rx_connection *rxconn = rx_ConnectionOf(rxcall);
354     struct rx_peer *rxpeer = rx_PeerOf(rxconn);
355     struct afscp_server *server = afscp_AnyServerByAddr(rx_HostOf(rxpeer));
356     struct afscp_callback *cb;
357     struct afscp_venusfid f;
358     struct AFSFid *fid;
359     int i;
360     unsigned int j;
361
362     if (server == NULL) {
363         return 0;
364     }
365     for (i = 0; i < afscp_maxcallbacks; i++) {
366         cb = &allcallbacks[i];
367         if (cb->server != server)
368             continue;
369         for (j = 0; j < Fids_Array->AFSCBFids_len; j++) {
370             fid = &Fids_Array->AFSCBFids_val[j];
371             if ((fid->Volume == cb->fid.Volume) &&
372                 (fid->Vnode == cb->fid.Vnode) &&
373                 (fid->Unique == cb->fid.Unique))
374                 cb->valid = 0;
375             f.cell = afscp_CellById(cb->server->cell);
376             memcpy(&f.fid, &cb->fid, sizeof(struct AFSFid));
377             _StatInvalidate(&f);
378         }
379     }
380
381     return RXGEN_SUCCESS;
382 }                               /*SRXAFSCB_CallBack */
383
384 /*!
385  * Initialize callback state on this ``Cache Manager''.
386  *
387  * \param[in]   rxcall  Ptr to the associated Rx call structure.
388  *
389  * \post Returns RXGEN_SUCCESS on success, Error value otherwise.
390  *
391  * \note This will definitely be called by the File Server (exactly once),
392  *       since it will think we are another new ``Cache Manager''.
393  */
394 afs_int32
395 SRXAFSCB_InitCallBackState(struct rx_call * rxcall)
396 {
397     struct rx_connection *rxconn = rx_ConnectionOf(rxcall);
398     struct rx_peer *rxpeer = rx_PeerOf(rxconn);
399     struct afscp_server *server = afscp_AnyServerByAddr(rx_HostOf(rxpeer));
400     struct afscp_callback *cb;
401     struct afscp_venusfid f;
402     int i;
403
404     if (server == NULL) {
405         return 0;
406     }
407     for (i = 0; i < afscp_maxcallbacks; i++) {
408         cb = &allcallbacks[i];
409         if (cb->server != server)
410             continue;
411         if (cb->valid) {
412             f.cell = afscp_CellById(cb->server->cell);
413             memcpy(&f.fid, &cb->fid, sizeof(struct AFSFid));
414             _StatInvalidate(&f);
415         }
416         cb->valid = 0;
417     }
418     return RXGEN_SUCCESS;
419 }                               /* SRXAFSCB_InitCallBackState */
420
421 /*!
422  * Respond to a probe from the File Server.
423  *
424  * \param[in] rxcall    Ptr to the associated Rx call structure.
425  *
426  * \post Returns RXGEN_SUCCESS (always)
427  *
428  * \note If a File Server doesn't hear from you every so often, it will
429  *       send you a probe to make sure you're there, just like any other
430  *       ``Cache Manager'' it's keeping track of.
431  *
432  */
433 afs_int32
434 SRXAFSCB_Probe(struct rx_call * rxcall)
435 {
436     return RXGEN_SUCCESS;
437 }                               /* SRXAFSCB_Probe */
438
439 /*!
440  * Respond minimally to a request for returning the contents of
441  * a cache lock, since someone out there thinks you're a Cache
442  * Manager.
443  *
444  * \param[in]   rxcall  Ptr to the associated Rx call structure.
445  * \param[in]   index
446  * \param[out]  lock
447  *
448  * \post Returns RXGEN_SUCCESS (always)
449  *
450  */
451 afs_int32
452 SRXAFSCB_GetLock(struct rx_call * rxcall, afs_int32 index, AFSDBLock * lock)
453 {
454     return RXGEN_SUCCESS;
455
456 }                               /*SRXAFSCB_GetLock */
457
458 /*!
459  * Respond minimally to a request for returning the contents of
460  * a cache entry, since someone out there thinks you're a Cache
461  * Manager.
462  *
463  * \param[in]   rxcall  Ptr to the associated Rx call structure.
464  * \param[in]   index
465  * \param[out]  ce      Ptr to cache entry
466  *
467  * \post Returns RXGEN_SUCCESS (always)
468  *
469  */
470 afs_int32
471 SRXAFSCB_GetCE(struct rx_call * rxcall, afs_int32 index, AFSDBCacheEntry * ce)
472 {
473     return RXGEN_SUCCESS;
474 }                               /* SRXAFSCB_GetCE */
475
476 /*!
477  * Respond minimally to a request for returning the contents of
478  * a cache entry, since someone out there thinks you're a Cache
479  * Manager. (64-bit version, though same as SRXAFSCB_GetCE())
480  *
481  * \param[in]   rxcall  Ptr to the associated Rx call structure.
482  * \param[in]   index
483  * \param[out]  ce      Ptr to cache entry
484  *
485  * \post Returns RXGEN_SUCCESS (always)
486  *
487  */
488 afs_int32
489 SRXAFSCB_GetCE64(struct rx_call * rxcall, afs_int32 index,
490                  AFSDBCacheEntry64 * ce)
491 {
492     return RXGEN_SUCCESS;
493 }                               /*SRXAFSCB_GetCE */
494
495 /*!
496  * Respond minimally to a request for fetching the version of
497  * extended Cache Manager statistics offered, since someone out
498  * there thinks you're a Cache Manager.
499  *
500  * \param[in]   rxcall          Ptr to the associated Rx call structure
501  * \param[out]  versionNumberP
502  *
503  * \post Returns RXGEN_SUCCESS (always)
504  *
505  */
506 afs_int32
507 SRXAFSCB_XStatsVersion(struct rx_call * rxcall, afs_int32 * versionNumberP)
508 {
509     return RXGEN_SUCCESS;
510 }                               /*SRXAFSCB_XStatsVersion */
511
512 /*!
513  * Respond minimally to a request for returning extended
514  * statistics for a Cache Manager, since someone out there thinks
515  * you're a Cache Manager.
516  *
517  * \param[in]   z_call                  Ptr to the associated Rx call structure
518  * \param[in]   clientVersionNumber
519  * \param[in]   collectionNumber
520  * \param[out]  srvVersionNumberP
521  * \param[out]  timeP
522  * \param[out]  dataP
523  *
524  * \post Returns RXGEN_SUCCESS (always)
525  *
526  */
527 afs_int32
528 SRXAFSCB_GetXStats(struct rx_call * z_call, afs_int32 clientVersionNumber,
529                    afs_int32 collectionNumber, afs_int32 * srvVersionNumberP,
530                    afs_int32 * timeP, AFSCB_CollData * dataP)
531 {
532     return RXGEN_SUCCESS;
533 }                               /*SRXAFSCB_GetXStats */
534
535 /*!
536  * This routine was used in the AFS 3.5 beta release, but not anymore.
537  * It has since been replaced by SRXAFSCB_InitCallBackState3.
538  *
539  * \param[in]   rxcall  Ptr to the associated Rx call structure.
540  * \param[out]  addr    Ptr to return the list of interfaces for this client
541  *
542  * \post Returns RXGEN_SUCCESS (always)
543  *
544  */
545 afs_int32
546 SRXAFSCB_InitCallBackState2(struct rx_call * rxcall,
547                             struct interfaceAddr * addr)
548 {
549     return RXGEN_OPCODE;
550 }                               /* SRXAFSCB_InitCallBackState2 */
551
552 /*!
553  *
554  * \param       rxcall  Ptr to the associated Rx call structure.
555  *
556  * \post Returns RXGEN_SUCCESS (always)
557  *
558  */
559 afs_int32
560 SRXAFSCB_TellMeAboutYourself(struct rx_call * a_call,
561                              struct interfaceAddr * addr,
562                              Capabilities * capabilities)
563 {
564 #ifdef AFS_NT40_ENV
565     int code;
566     int cm_noIPAddr;            /* number of client network interfaces */
567     int cm_IPAddr[CM_MAXINTERFACE_ADDR];        /* client's IP address in host order */
568     int cm_SubnetMask[CM_MAXINTERFACE_ADDR];    /* client's subnet mask in host order */
569     int cm_NetMtu[CM_MAXINTERFACE_ADDR];        /* client's MTU sizes */
570     int cm_NetFlags[CM_MAXINTERFACE_ADDR];      /* network flags */
571     int i;
572
573     cm_noIPAddr = CM_MAXINTERFACE_ADDR;
574     code = syscfg_GetIFInfo(&cm_noIPAddr,
575                             cm_IPAddr, cm_SubnetMask, cm_NetMtu, cm_NetFlags);
576     if (code > 0) {
577         /* return all network interface addresses */
578         addr->numberOfInterfaces = cm_noIPAddr;
579         for (i = 0; i < cm_noIPAddr; i++) {
580             addr->addr_in[i] = cm_IPAddr[i];
581             addr->subnetmask[i] = cm_SubnetMask[i];
582             addr->mtu[i] = cm_NetMtu[i];
583         }
584     } else {
585         addr->numberOfInterfaces = 0;
586     }
587 #else
588     if (a_call && addr) {
589         if (!afs_cb_inited)
590             init_afs_cb();
591         *addr = afs_cb_interface;
592     }
593 #endif
594     if (capabilities != NULL) {
595         afs_uint32 *dataBuffP;
596         afs_int32 dataBytes;
597
598         dataBytes = 1 * sizeof(afs_uint32);
599         dataBuffP = (afs_uint32 *) xdr_alloc(dataBytes);
600         dataBuffP[0] = CLIENT_CAPABILITY_ERRORTRANS;
601         capabilities->Capabilities_len = dataBytes / sizeof(afs_uint32);
602         capabilities->Capabilities_val = dataBuffP;
603     }
604     return RXGEN_SUCCESS;
605 }                               /* SRXAFSCB_TellMeAboutYourself */
606
607 /*!
608  * Routine called by the server-side callback RPC interface to
609  * obtain a unique identifier for the client. The server uses
610  * this identifier to figure out whether or not two RX connections
611  * are from the same client, and to find out which addresses go
612  * with which clients.
613  *
614  * \param[in]   rxcall  Ptr to the associated Rx call structure.
615  * \param[out]  addr    Ptr to return the list of interfaces for this client
616  *
617  * \post Returns output of TellMeAboutYourself (which
618  *       should be RXGEN_SUCCESS).
619  *
620  */
621 afs_int32
622 SRXAFSCB_WhoAreYou(struct rx_call * rxcall, struct interfaceAddr * addr)
623 {
624     return SRXAFSCB_TellMeAboutYourself(rxcall, addr, NULL);
625 }                               /* SRXAFSCB_WhoAreYou */
626
627 /*!
628  * Routine called by the server-side callback RPC interface to
629  * implement clearing all callbacks from this host.
630  *
631  * \param[in]   rxcall          Ptr to the associated Rx call structure.
632  * \param[in]   serverUuid      Ptr to UUID
633  *
634  * \post Returns RXGEN_SUCCESS (always)
635  *
636  */
637 afs_int32
638 SRXAFSCB_InitCallBackState3(struct rx_call * rxcall, afsUUID * serverUuid)
639 {
640     struct rx_connection *rxconn = rx_ConnectionOf(rxcall);
641     struct rx_peer *rxpeer = rx_PeerOf(rxconn);
642     struct afscp_server *server = afscp_AnyServerByAddr(rx_HostOf(rxpeer));
643     struct afscp_callback *cb;
644     struct afscp_venusfid f;
645     int i;
646
647     if (server == NULL) {
648         return 0;
649     }
650     for (i = 0; i < afscp_maxcallbacks; i++) {
651         cb = &allcallbacks[i];
652         if (cb->server != server)
653             continue;
654         if (cb->valid) {
655             f.cell = afscp_CellById(cb->server->cell);
656             memcpy(&f.fid, &cb->fid, sizeof(struct AFSFid));
657             _StatInvalidate(&f);
658         }
659         cb->valid = 0;
660     }
661     return RXGEN_SUCCESS;
662 }                               /* SRXAFSCB_InitCallBackState3 */
663
664 /*!
665  * Routine called by the server-side callback RPC interface to
666  * implement ``probing'' the Cache Manager, just making sure it's
667  * still there is still the same client it used to be.
668  *
669  * \param       rxcall          Ptr to the associated Rx call structure.
670  * \param       clientUuid      Ptr to UUID that must match the client's UUID
671  *
672  * \post Returns RXGEN_SUCCESS (always)
673  *
674  */
675 afs_int32
676 SRXAFSCB_ProbeUuid(struct rx_call * rxcall, afsUUID * clientUuid)
677 {
678     int code = 0;
679     if (!afs_cb_inited)
680         init_afs_cb();
681     if (!afs_uuid_equal(clientUuid, &afs_cb_interface.uuid))
682         code = 1;               /* failure */
683     return code;
684 }                               /* SRXAFSCB_ProbeUuid */
685
686 /*!
687  * Routine to list server preferences used by this client.
688  *
689  * \param[in]   a_call          Ptr to Rx call on which this request came in.
690  * \param[in]   a_index         Input server index
691  * \param[out]  a_srvr_addr     Output server address (0xffffffff on last server)
692  * \param[out]  a_srvr_rank     Output server rank
693  *
694  * \post Returns RXGEN_SUCCESS (always)
695  *
696  */
697 afs_int32
698 SRXAFSCB_GetServerPrefs(struct rx_call * a_call, afs_int32 a_index,
699                         afs_int32 * a_srvr_addr, afs_int32 * a_srvr_rank)
700 {
701     *a_srvr_addr = 0xffffffff;
702     *a_srvr_rank = 0xffffffff;
703     return RXGEN_SUCCESS;
704 }                               /* SRXAFSCB_GetServerPrefs */
705
706 /*!
707  * Routine to list cells configured for this client
708  *
709  * \param[in]   a_call  Ptr to Rx call on which this request came in.
710  * \param[in]   a_index Input cell index
711  * \param[out]  a_name  Output cell name ("" on last cell)
712  * \param[out]  a_hosts Output cell database servers
713  *
714  * \post Returns RXGEN_OPCODE (always)
715  *
716  */
717 afs_int32
718 SRXAFSCB_GetCellServDB(struct rx_call * a_call, afs_int32 a_index,
719                        char **a_name, afs_int32 * a_hosts)
720 {
721     return RXGEN_OPCODE;
722 }                               /* SRXAFSCB_GetCellServDB */
723
724 /*!
725  * Routine to return name of client's local cell
726  *
727  * \param[in]   a_call  Ptr to Rx call on which this request came in.
728  * \param[out]  a_name  Output cell name
729  *
730  * \post Returns RXGEN_SUCCESS (always)
731  *
732  */
733 int
734 SRXAFSCB_GetLocalCell(struct rx_call *a_call, char **a_name)
735 {
736     return RXGEN_OPCODE;
737 }                               /* SRXAFSCB_GetLocalCell */
738
739 /*!
740  * Routine to return parameters used to initialize client cache.
741  * Client may request any format version. Server may not return
742  * format version greater than version requested by client.
743  *
744  * \param[in]   a_call          Ptr to Rx call on which this request came in.
745  * \param[in]   callerVersion   Data format version desired by the client.
746  * \param[out]  serverVersion   Data format version of output data.
747  * \param[out]  configCount     Number bytes allocated for output data.
748  * \param[out]  config          Client cache configuration.
749  *
750  * \post Returns RXGEN_SUCCESS (always)
751  *
752  */
753 int
754 SRXAFSCB_GetCacheConfig(struct rx_call *a_call, afs_uint32 callerVersion,
755                         afs_uint32 * serverVersion, afs_uint32 * configCount,
756                         cacheConfig * config)
757 {
758     return RXGEN_OPCODE;
759 }                               /* SRXAFSCB_GetCacheConfig */
760
761 /*!
762
763  *
764  * \param[in]   rxcall  Ptr to the associated Rx call structure.
765  *
766  * \post Returns RXGEN_OPCODE (always)
767  *
768  */
769 int
770 SRXAFSCB_GetCellByNum(struct rx_call *a_call, afs_int32 a_index,
771                       char **a_name, afs_int32 * a_hosts)
772 {
773     return RXGEN_OPCODE;
774 }                               /* SRXAFSCB_GetCellByNum */