Bug Summary

File:libafscp/afscp_callback.c
Location:line 140, column 2
Description:Value stored to 'ret' is never read

Annotated Source Code

1/* AUTORIGHTS
2Copyright (C) 2003 - 2010 Chaskiel Grundman
3All rights reserved
4
5Redistribution and use in source and binary forms, with or without
6modification, are permitted provided that the following conditions
7are met:
8
91. Redistributions of source code must retain the above copyright
10 notice, this list of conditions and the following disclaimer.
11
122. 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
16THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
17IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
18OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
22DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
23THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
25OF 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
43int afs_cb_inited = 0;
44struct interfaceAddr afs_cb_interface;
45static int afscp_maxcallbacks = 0, afscp_cballoced = 0;
46struct afscp_callback *allcallbacks = NULL((void *)0);
47
48/*!
49 * Initialize the callback interface structure
50 */
51static int
52init_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_ADDR32);
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])(__builtin_constant_p(afs_cb_interface.addr_in[i]) ? ((((__uint32_t
)(afs_cb_interface.addr_in[i])) >> 24) | ((((__uint32_t
)(afs_cb_interface.addr_in[i])) & (0xff << 16)) >>
8) | ((((__uint32_t)(afs_cb_interface.addr_in[i])) & (0xff
<< 8)) << 8) | (((__uint32_t)(afs_cb_interface.addr_in
[i])) << 24)) : __bswap32_var(afs_cb_interface.addr_in[
i]));
99 }
100#endif
101 afs_cb_inited = 1;
102 return 0;
103} /* init_afs_cb */
104
105int
106afscp_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((void *)0), *cb;
110 time_t now;
111 struct afscp_venusfid fid;
112
113 ret = NULL((void *)0);
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;
Value stored to 'ret' is never read
141 else
142 return -1;
143
144 return 0;
145}
146
147int
148afscp_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((void *)0), *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((void *)0)) {
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((void *)0)) {
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
206int
207afscp_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((void *)0)) {
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
230int
231afscp_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) * AFSCBMAX50);
261 if (!theFids.AFSCBFids_val) {
262 return -1;
263 }
264 memset(theFids.AFSCBFids_val, 0,
265 sizeof(struct AFSFid) * AFSCBMAX50);
266 theCBs.AFSCBs_val = malloc(sizeof(struct AFSCallBack) * AFSCBMAX50);
267 if (!theCBs.AFSCBs_val) {
268 free(theFids.AFSCBFids_val);
269 return -1;
270 }
271 memset(theCBs.AFSCBs_val, 0,
272 sizeof(struct AFSCallBack) * AFSCBMAX50);
273 inited = 1;
274 }
275
276 if (ncallbacks == AFSCBMAX50) {
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((void *)0))
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_DROPPED3;
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((void *)0))
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
321int
322afscp_ReturnAllCallBacks(void)
323{
324 struct afscp_server *s;
325 int i;
326
327 if (allcallbacks == NULL((void *)0))
328 return 0;
329 for (i = 0; (s = afscp_ServerByIndex(i)); i++) {
330 afscp_ReturnCallBacks(s);
331 }
332 free(allcallbacks);
333 allcallbacks = NULL((void *)0);
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 */
349afs_int32
350SRXAFSCB_CallBack(struct rx_call * rxcall, AFSCBFids * Fids_Array,
351 AFSCBs * CallBack_Array)
352{
353 struct rx_connection *rxconn = rx_ConnectionOf(rxcall)((rxcall)->conn);
354 struct rx_peer *rxpeer = rx_PeerOf(rxconn)((rxconn)->peer);
355 struct afscp_server *server = afscp_AnyServerByAddr(rx_HostOf(rxpeer)((rxpeer)->host));
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((void *)0)) {
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_SUCCESS0;
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 */
394afs_int32
395SRXAFSCB_InitCallBackState(struct rx_call * rxcall)
396{
397 struct rx_connection *rxconn = rx_ConnectionOf(rxcall)((rxcall)->conn);
398 struct rx_peer *rxpeer = rx_PeerOf(rxconn)((rxconn)->peer);
399 struct afscp_server *server = afscp_AnyServerByAddr(rx_HostOf(rxpeer)((rxpeer)->host));
400 struct afscp_callback *cb;
401 struct afscp_venusfid f;
402 int i;
403
404 if (server == NULL((void *)0)) {
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_SUCCESS0;
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 */
433afs_int32
434SRXAFSCB_Probe(struct rx_call * rxcall)
435{
436 return RXGEN_SUCCESS0;
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 */
451afs_int32
452SRXAFSCB_GetLock(struct rx_call * rxcall, afs_int32 index, AFSDBLock * lock)
453{
454 return RXGEN_SUCCESS0;
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 */
470afs_int32
471SRXAFSCB_GetCE(struct rx_call * rxcall, afs_int32 index, AFSDBCacheEntry * ce)
472{
473 return RXGEN_SUCCESS0;
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 */
488afs_int32
489SRXAFSCB_GetCE64(struct rx_call * rxcall, afs_int32 index,
490 AFSDBCacheEntry64 * ce)
491{
492 return RXGEN_SUCCESS0;
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 */
506afs_int32
507SRXAFSCB_XStatsVersion(struct rx_call * rxcall, afs_int32 * versionNumberP)
508{
509 return RXGEN_SUCCESS0;
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 */
527afs_int32
528SRXAFSCB_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_SUCCESS0;
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 */
545afs_int32
546SRXAFSCB_InitCallBackState2(struct rx_call * rxcall,
547 struct interfaceAddr * addr)
548{
549 return RXGEN_OPCODE-455;
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 */
559afs_int32
560SRXAFSCB_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((void *)0)) {
595 afs_uint32 *dataBuffP;
596 afs_int32 dataBytes;
597
598 dataBytes = 1 * sizeof(afs_uint32);
599 dataBuffP = (afs_uint32 *) xdr_allocafs_xdr_alloc(dataBytes);
600 dataBuffP[0] = CLIENT_CAPABILITY_ERRORTRANS0x0001;
601 capabilities->Capabilities_len = dataBytes / sizeof(afs_uint32);
602 capabilities->Capabilities_val = dataBuffP;
603 }
604 return RXGEN_SUCCESS0;
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 */
621afs_int32
622SRXAFSCB_WhoAreYou(struct rx_call * rxcall, struct interfaceAddr * addr)
623{
624 return SRXAFSCB_TellMeAboutYourself(rxcall, addr, NULL((void *)0));
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 */
637afs_int32
638SRXAFSCB_InitCallBackState3(struct rx_call * rxcall, afsUUID * serverUuid)
639{
640 struct rx_connection *rxconn = rx_ConnectionOf(rxcall)((rxcall)->conn);
641 struct rx_peer *rxpeer = rx_PeerOf(rxconn)((rxconn)->peer);
642 struct afscp_server *server = afscp_AnyServerByAddr(rx_HostOf(rxpeer)((rxpeer)->host));
643 struct afscp_callback *cb;
644 struct afscp_venusfid f;
645 int i;
646
647 if (server == NULL((void *)0)) {
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_SUCCESS0;
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 */
675afs_int32
676SRXAFSCB_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 */
697afs_int32
698SRXAFSCB_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_SUCCESS0;
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 */
717afs_int32
718SRXAFSCB_GetCellServDB(struct rx_call * a_call, afs_int32 a_index,
719 char **a_name, afs_int32 * a_hosts)
720{
721 return RXGEN_OPCODE-455;
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 */
733int
734SRXAFSCB_GetLocalCell(struct rx_call *a_call, char **a_name)
735{
736 return RXGEN_OPCODE-455;
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 */
753int
754SRXAFSCB_GetCacheConfig(struct rx_call *a_call, afs_uint32 callerVersion,
755 afs_uint32 * serverVersion, afs_uint32 * configCount,
756 cacheConfig * config)
757{
758 return RXGEN_OPCODE-455;
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 */
769int
770SRXAFSCB_GetCellByNum(struct rx_call *a_call, afs_int32 a_index,
771 char **a_name, afs_int32 * a_hosts)
772{
773 return RXGEN_OPCODE-455;
774} /* SRXAFSCB_GetCellByNum */