2 * Copyright 2000, International Business Machines Corporation and others.
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
10 #include <afsconfig.h>
11 #include <afs/param.h>
15 #include <afs/afsint.h>
16 #include <sys/socket.h>
17 #include <rx/rx_globals.h>
18 #include <netinet/in.h>
19 #include <arpa/inet.h>
24 struct ubik_client *cstruct;
25 struct rx_connection *serverconns[MAXSERVERS];
29 pxclient_Initialize(int auth, afs_int32 serverAddr)
33 struct rx_securityClass *sc;
35 code = rx_Init(htons(2115) /*0 */ );
37 fprintf(stderr, "pxclient_Initialize: Could not initialize rx.\n");
44 sc = rxnull_NewClientSecurityObject();
47 #ifdef notdef /* security */
49 sc = rxvab_NewClientSecurityObject(&ttoken.sessionKey, ttoken.ticket,
54 sc = rxkad_NewClientSecurityObject(rxkad_clear, &ttoken.sessionKey,
55 ttoken.kvno, ttoken.ticketLen,
60 rx_NewConnection(serverAddr, htons(7000), 1, sc, scIndex);
62 code = ubik_ClientInit(serverconns, &cstruct);
65 fprintf(stderr, "pxclient_Initialize: ubik client init failed.\n");
73 #include "AFS_component_version_number.c"
76 main(int argc, char **argv)
79 struct sockaddr_in host;
80 register afs_int32 code;
85 int noAuth = 1; /* Default is authenticated connections */
89 printf("usage: pxclient <serverHost>\n");
92 memset((char *)&host, 0, sizeof(struct sockaddr_in));
93 host.sin_family = AF_INET;
94 host.sin_addr.s_addr = inet_addr(av[0]);
95 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
96 host.sin_len = sizeof(struct sockaddr_in);
98 if (host.sin_addr.s_addr != -1) {
99 strcpy(hnamebuf, av[0]);
102 hp = gethostbyname(av[0]);
104 host.sin_family = hp->h_addrtype;
105 memcpy((caddr_t) & host.sin_addr, hp->h_addr, hp->h_length);
106 hostname = hp->h_name;
108 printf("unknown server host %s\n", av[0]);
112 if ((code = pxclient_Initialize(noAuth, host.sin_addr.s_addr)) != 0) {
113 printf("Couldn't initialize fs library (code=%d).\n", code);
117 code = ubik_Call(RXAFS_GetTime, cstruct, 0, &tv.tv_sec, &tv.tv_usec);
119 printf("AFS_GetTime on %s sec=%ld, usec=%ld\n", av[0], tv.tv_sec,
120 (long int)tv.tv_usec);
122 printf("return code is %d\n", code);
130 if (fgets(line, 499, stdin) != NULL) {
132 register char **argp = args;
133 GetArgs(line, argp, &nargs);
136 if (!strcmp(oper, "probe")) {
138 ubik_Call(RXAFS_GetTime, cstruct, 0, &tv.tv_sec,
140 printf("return code is %d\n", code);
142 printf("sec=%d\n", tv.tv_sec);
143 } else if (!strcmp(oper, "fsstats")) {
144 struct afsStatistics stats;
146 code = ubik_AFS_GetStatistics(cstruct, 0, &stats);
147 printf("return code is %d\n", code);
148 } else if (!strcmp(oper, "fd")) {
149 code = FetchData(argp);
150 printf("return code is %d\n", code);
151 } else if (!strcmp(oper, "fs")) {
152 code = FetchStatus(argp);
153 printf("return code is %d\n", code);
154 } else if (!strcmp(oper, "fa")) {
155 code = FetchACL(argp);
156 printf("return code is %d\n", code);
157 } else if (!strcmp(oper, "sd")) {
158 code = StoreData(argp);
159 printf("return code is %d\n", code);
160 } else if (!strcmp(oper, "ss")) {
161 code = StoreStatus(argp);
162 printf("return code is %d\n", code);
163 } else if (!strcmp(oper, "sa")) {
164 code = StoreACL(argp);
165 printf("return code is %d\n", code);
166 } else if (!strcmp(oper, "cf")) {
167 code = CreateFile(argp);
168 printf("return code is %d\n", code);
169 } else if (!strcmp(oper, "rf")) {
170 code = RemoveFile(argp);
171 printf("return code is %d\n", code);
172 } else if (!strcmp(oper, "rn")) {
174 printf("return code is %d\n", code);
175 } else if (!strcmp(oper, "sl")) {
176 code = Symlink(argp);
177 printf("return code is %d\n", code);
178 } else if (!strcmp(oper, "hl")) {
179 code = HardLink(argp);
180 printf("return code is %d\n", code);
181 } else if (!strcmp(oper, "md")) {
182 code = MakeDir(argp);
183 printf("return code is %d\n", code);
184 } else if (!strcmp(oper, "rd")) {
185 code = RemoveDir(argp);
186 printf("return code is %d\n", code);
187 } else if (!strcmp(oper, "rdd")) {
188 code = Readdir(argp);
189 printf("return code is %d\n", code);
190 } else if (!strcmp(oper, "mm")) {
191 code = MakeMountPoint(argp);
192 printf("return code is %d\n", code);
193 } else if (!strcmp(oper, "rt")) {
194 code = ReleaseTokens(argp);
195 printf("return code is %d\n", code);
196 } else if (!strcmp(oper, "bs")) {
197 code = BulkStatus(argp);
198 printf("return code is %d\n", code);
199 } else if (!strcmp(oper, "lk")) {
201 printf("return code is %d\n", code);
202 } else if (!strcmp(oper, "gt")) {
203 code = GetToken(argp);
204 printf("return code is %d\n", code);
205 } else if (!strcmp(oper, "ka")) {
206 code = KeepAlive(argp);
207 printf("return code is %d\n", code);
208 } else if ((!strcmp(oper, "q")) || !strcmp(oper, "quit"))
211 printf("Unknown oper! Available operations: \n\n");
212 printf("fd <vnode> <unique> <pos> <len>\n");
213 printf("fs <vnode> <unique>\n");
214 printf("fa <vnode> <unique>\n");
216 ("sd <vnode> <unique> <pos> <len> <flen> [<mode>|-1] [<owner>|-1] [<length>|-1] <string>\n");
218 ("ss <vnode> <unique> [<mode>|-1] [<owner>|-1] [<length>|-1]\n");
219 printf("sa <vnode> <unique> <string>\n");
220 printf("rf <vnode> <unique> <name>\n");
222 ("cf <vnode> <unique> <name> [<mode>|-1] [<owner>|-1] [<length>|-1]\n");
224 ("rn <ovnode> <ounique> <oname> <nvnode> <nunique> <nname>\n");
226 ("sl <vnode> <unique> <name> <contents> [<mode>|-1] [<owner>|-1] [<length>|-1]\n");
227 printf("hl <dvnode> <dunique> <name> <evnode> <eunique>\n");
229 ("md <vnode> <unique> <name> [<mode>|-1] [<owner>|-1] [<length>|-1]\n");
230 printf("rd <vnode> <unique> <name>\n");
231 printf("rdd <vnode> <unique> <pos> <len>\n");
232 printf("lk <vnode> <unique> <name>\n");
233 printf("gt <vnode> <unique> <tokenID>\n");
234 printf("ka <vol.l> <vnode> <unique> <isExec> <kaTime>\n");
244 GetArgs(register char *line, register char **args, register int *nargs)
248 register char *last = line;
255 *args++ = line, (*nargs)++;
256 while (*line && *line != ' ')
263 FetchData(char **argp)
265 struct afsFetchStatus OutStatus;
266 struct afsToken Token;
267 struct afsVolSync tsync;
269 int vnode, unique, position, length;
271 struct rx_call *tcall;
273 sscanf(&(*argp)[0], "%d", &vnode);
275 sscanf(&(*argp)[0], "%d", &unique);
277 memset(&fid, 0, sizeof(struct afsFid));
278 fid.Volume.low = 10; /* XXX */
281 sscanf(&(*argp)[0], "%d", &position);
283 sscanf(&(*argp)[0], "%d", &length);
285 tcall = rx_NewCall(cstruct->conns[0]);
286 code = StartAFS_FetchData(tcall, &fid, &hyp0, position, length, 0);
288 code = FetchProc(tcall);
291 code = EndAFS_FetchData(tcall, &OutStatus, &Token, &tsync);
293 code = rx_EndCall(tcall, code);
299 FetchProc(register struct rx_call *acall)
301 extern char *malloc();
302 register char *tbuffer;
303 afs_int32 tlen, length, code;
305 code = rx_Read(acall, &length, sizeof(afs_int32));
306 length = ntohl(length);
307 if (code != sizeof(afs_int32))
309 tbuffer = malloc(256);
311 tlen = (length > 256 ? 256 : length);
312 code = rx_Read(acall, tbuffer, tlen);
325 FetchStatus(char **argp)
327 struct afsFetchStatus OutStatus;
328 struct afsToken Token;
329 struct afsVolSync tsync;
334 sscanf(&(*argp)[0], "%d", &vnode);
336 sscanf(&(*argp)[0], "%d", &unique);
338 memset(&fid, 0, sizeof(struct afsFid));
339 fid.Volume.low = 10; /* XXX */
343 ubik_AFS_FetchStatus(cstruct, 0, &fid, &hyp0, 0, &OutStatus,
350 FetchACL(char **argp)
352 struct afsFetchStatus OutStatus;
353 struct afsACL AccessList;
354 struct afsToken Token;
355 struct afsVolSync tsync;
360 sscanf(&(*argp)[0], "%d", &vnode);
362 sscanf(&(*argp)[0], "%d", &unique);
364 memset(&fid, 0, sizeof(struct afsFid));
365 fid.Volume.low = 10; /* XXX */
369 ubik_AFS_FetchACL(cstruct, 0, &fid, &hyp0, 0, &AccessList,
376 StoreData(char **argp)
378 struct afsStoreStatus InStatus;
379 struct afsFetchStatus OutStatus;
380 struct afsVolSync tsync;
382 int vnode, unique, position, length, filelength;
383 int mode, owner, len;
386 struct rx_call *tcall;
388 sscanf(&(*argp)[0], "%d", &vnode);
390 sscanf(&(*argp)[0], "%d", &unique);
392 memset(&fid, 0, sizeof(struct afsFid));
393 fid.Volume.low = 10; /* XXX */
396 sscanf(&(*argp)[0], "%d", &position);
398 sscanf(&(*argp)[0], "%d", &length);
400 sscanf(&(*argp)[0], "%d", &filelength);
402 memset(&InStatus, 0, sizeof(struct afsStoreStatus));
403 sscanf(&(*argp)[0], "%d", &mode);
405 sscanf(&(*argp)[0], "%d", &owner);
407 sscanf(&(*argp)[0], "%d", &len);
410 InStatus.mode = mode;
411 InStatus.mask |= AFS_SETMODE;
414 InStatus.owner = owner;
415 InStatus.mask |= AFS_SETOWNER;
418 InStatus.length = length;
419 InStatus.mask |= AFS_SETLENGTH;
421 string = &argp[0][0];
424 tcall = rx_NewCall(cstruct->conns[0]);
426 StartAFS_StoreData(tcall, &fid, &InStatus, position, length,
427 filelength, &hyp0, 0);
429 code = StoreProc(tcall, string, length);
432 code = EndAFS_StoreData(tcall, &OutStatus, &tsync);
434 code = rx_EndCall(tcall, code);
440 StoreProc(register struct rx_call *acall, char *string, int length)
442 afs_int32 tlen, code;
445 tlen = (length > 256 ? 256 : length);
446 code = rx_Write(acall, string, tlen);
457 StoreStatus(char **argp)
459 struct afsStoreStatus InStatus;
460 struct afsFetchStatus OutStatus;
461 struct afsVolSync tsync;
463 int vnode, unique, mode, owner, length;
466 sscanf(&(*argp)[0], "%d", &vnode);
468 sscanf(&(*argp)[0], "%d", &unique);
470 memset(&fid, 0, sizeof(struct afsFid));
471 fid.Volume.low = 10; /* XXX */
474 memset(&InStatus, 0, sizeof(struct afsStoreStatus));
475 sscanf(&(*argp)[0], "%d", &mode);
477 sscanf(&(*argp)[0], "%d", &owner);
479 sscanf(&(*argp)[0], "%d", &length);
482 InStatus.mode = mode;
483 InStatus.mask |= AFS_SETMODE;
486 InStatus.owner = owner;
487 InStatus.mask |= AFS_SETOWNER;
490 InStatus.length = length;
491 InStatus.mask |= AFS_SETLENGTH;
494 ubik_AFS_StoreStatus(cstruct, 0, &fid, &InStatus, &hyp0, 0,
501 StoreACL(char **argp)
503 struct afsFetchStatus OutStatus;
504 struct afsACL AccessList;
505 struct afsToken Token;
506 struct afsVolSync tsync;
512 sscanf(&(*argp)[0], "%d", &vnode);
514 sscanf(&(*argp)[0], "%d", &unique);
516 memset(&fid, 0, sizeof(struct afsFid));
517 fid.Volume.low = 10; /* XXX */
520 string = &argp[0][0];
522 AccessList.afsACL_len = strlen(string) + 1;
523 AccessList.afsACL_val = string;
525 ubik_AFS_StoreACL(cstruct, 0, &fid, &AccessList, &hyp0, 0,
532 RemoveFile(char **argp)
534 struct afsFetchStatus OutDirStatus, OutFidStatus;
535 struct afsVolSync tsync;
536 struct afsFidName nameFid;
537 struct afsFid fid, outFid;
542 sscanf(&(*argp)[0], "%d", &vnode);
544 sscanf(&(*argp)[0], "%d", &unique);
546 memset(&fid, 0, sizeof(struct afsFid));
547 fid.Volume.low = 10; /* XXX */
552 memset(&nameFid, 0, sizeof(struct afsFidName));
553 strcpy(nameFid.name, name);
555 ubik_AFS_RemoveFile(cstruct, 0, &fid, &nameFid, &hyp0, 0,
556 &OutDirStatus, &OutFidStatus, &outFid, &tsync);
562 CreateFile(char **argp)
564 struct afsFetchStatus OutDirStatus, OutFidStatus;
565 struct afsStoreStatus InStatus;
566 struct afsVolSync tsync;
567 struct afsFid fid, outFid;
568 struct afsToken Token;
570 int vnode, unique, mode, owner, length;
573 sscanf(&(*argp)[0], "%d", &vnode);
575 sscanf(&(*argp)[0], "%d", &unique);
577 memset(&fid, 0, sizeof(struct afsFid));
578 fid.Volume.low = 10; /* XXX */
583 memset(&InStatus, 0, sizeof(struct afsStoreStatus));
584 sscanf(&(*argp)[0], "%d", &mode);
586 sscanf(&(*argp)[0], "%d", &owner);
588 sscanf(&(*argp)[0], "%d", &length);
591 InStatus.mode = mode;
592 InStatus.mask |= AFS_SETMODE;
595 InStatus.owner = owner;
596 InStatus.mask |= AFS_SETOWNER;
599 InStatus.length = length;
600 InStatus.mask |= AFS_SETLENGTH;
603 ubik_AFS_CreateFile(cstruct, 0, &fid, name, &InStatus, &hyp0, 0,
604 &outFid, &OutFidStatus, &OutDirStatus, &Token, &tsync);
612 struct afsFetchStatus OutOldDirStatus, OutNewDirStatus;
613 struct afsFetchStatus OutOldFileStatus, OutNewFileStatus;
614 struct afsVolSync tsync;
615 struct afsFid OldDirFid, NewDirFid, OutOldFileFid, OutNewFileFid;
616 struct afsFidName OldName, NewName;
618 int ovnode, ounique, nvnode, nunique;
621 sscanf(&(*argp)[0], "%d", &ovnode);
623 sscanf(&(*argp)[0], "%d", &ounique);
625 memset(&OldDirFid, 0, sizeof(struct afsFid));
626 OldDirFid.Volume.low = 10; /* XXX */
627 OldDirFid.Vnode = ovnode;
628 OldDirFid.Unique = ounique;
631 memset(&OldName, 0, sizeof(struct afsFidName));
632 strcpy(OldName.name, oname);
633 sscanf(&(*argp)[0], "%d", &nvnode);
635 sscanf(&(*argp)[0], "%d", &nunique);
637 memset(&NewDirFid, 0, sizeof(struct afsFid));
638 NewDirFid.Volume.low = 10; /* XXX */
639 NewDirFid.Vnode = nvnode;
640 NewDirFid.Unique = nunique;
643 memset(&NewName, 0, sizeof(struct afsFidName));
644 strcpy(NewName.name, nname);
646 ubik_AFS_Rename(cstruct, 0, &OldDirFid, &OldName, &NewDirFid,
647 &NewName, &hyp0, 0, &OutOldDirStatus, &OutNewDirStatus,
648 &OutOldFileFid, &OutOldFileStatus, &OutNewFileFid,
649 &OutNewFileStatus, &tsync);
657 struct afsFetchStatus OutDirStatus, OutFidStatus;
658 struct afsStoreStatus InStatus;
659 struct afsVolSync tsync;
660 struct afsFid fid, outFid;
661 struct afsToken Token;
662 char *name, *linkcontents;
663 int vnode, unique, mode, owner, length;
666 sscanf(&(*argp)[0], "%d", &vnode);
668 sscanf(&(*argp)[0], "%d", &unique);
670 memset(&fid, 0, sizeof(struct afsFid));
671 fid.Volume.low = 10; /* XXX */
676 linkcontents = &argp[0][0];
678 memset(&InStatus, 0, sizeof(struct afsStoreStatus));
679 sscanf(&(*argp)[0], "%d", &mode);
681 sscanf(&(*argp)[0], "%d", &owner);
683 sscanf(&(*argp)[0], "%d", &length);
686 InStatus.mode = mode;
687 InStatus.mask |= AFS_SETMODE;
690 InStatus.owner = owner;
691 InStatus.mask |= AFS_SETOWNER;
694 InStatus.length = length;
695 InStatus.mask |= AFS_SETLENGTH;
698 ubik_AFS_Symlink(cstruct, 0, &fid, name, linkcontents,
699 &InStatus, &hyp0, 0, &outFid, &OutFidStatus, &OutDirStatus,
706 HardLink(char **argp)
708 struct afsFetchStatus OutDirStatus, OutFidStatus;
709 struct afsVolSync tsync;
710 struct afsFid fid, existingFid;
715 sscanf(&(*argp)[0], "%d", &vnode);
717 sscanf(&(*argp)[0], "%d", &unique);
719 memset(&fid, 0, sizeof(struct afsFid));
720 fid.Volume.low = 10; /* XXX */
725 sscanf(&(*argp)[0], "%d", &vnode);
727 sscanf(&(*argp)[0], "%d", &unique);
729 memset(&existingFid, 0, sizeof(struct afsFid));
730 existingFid.Volume.low = 10; /* XXX */
731 existingFid.Vnode = vnode;
732 existingFid.Unique = unique;
734 ubik_AFS_HardLink(cstruct, 0, &fid, name, &existingFid, &hyp0,
735 0, &OutFidStatus, &OutDirStatus, &tsync);
743 struct afsFetchStatus OutDirStatus, OutFidStatus;
744 struct afsStoreStatus InStatus;
745 struct afsVolSync tsync;
746 struct afsFid fid, outFid;
747 struct afsToken Token;
749 int vnode, unique, mode, owner, length;
752 sscanf(&(*argp)[0], "%d", &vnode);
754 sscanf(&(*argp)[0], "%d", &unique);
756 memset(&fid, 0, sizeof(struct afsFid));
757 fid.Volume.low = 10; /* XXX */
762 memset(&InStatus, 0, sizeof(struct afsStoreStatus));
763 sscanf(&(*argp)[0], "%d", &mode);
765 sscanf(&(*argp)[0], "%d", &owner);
767 sscanf(&(*argp)[0], "%d", &length);
770 InStatus.mode = mode;
771 InStatus.mask |= AFS_SETMODE;
774 InStatus.owner = owner;
775 InStatus.mask |= AFS_SETOWNER;
778 InStatus.length = length;
779 InStatus.mask |= AFS_SETLENGTH;
782 ubik_AFS_MakeDir(cstruct, 0, &fid, name, &InStatus, &hyp0, 0,
783 &outFid, &OutFidStatus, &OutDirStatus, &Token, &tsync);
789 RemoveDir(char **argp)
791 struct afsFetchStatus OutDirStatus;
792 struct afsVolSync tsync;
793 struct afsFid fid, outFid;
794 struct afsFidName nameFid;
799 sscanf(&(*argp)[0], "%d", &vnode);
801 sscanf(&(*argp)[0], "%d", &unique);
803 memset(&fid, 0, sizeof(struct afsFid));
804 fid.Volume.low = 10; /* XXX */
809 memset(&nameFid, 0, sizeof(struct afsFidName));
810 strcpy(nameFid.name, name);
812 ubik_AFS_RemoveDir(cstruct, 0, &fid, &nameFid, &hyp0, 0,
813 &OutDirStatus, &outFid, &tsync);
821 struct afsFetchStatus OutDirStatus;
822 struct afsVolSync tsync;
824 struct afsToken Token;
826 struct rx_call *tcall;
827 int vnode, unique, offset, length, NextOffset;
830 sscanf(&(*argp)[0], "%d", &vnode);
832 sscanf(&(*argp)[0], "%d", &unique);
834 sscanf(&(*argp)[0], "%d", &offset);
836 sscanf(&(*argp)[0], "%d", &length);
838 memset(&fid, 0, sizeof(struct afsFid));
839 fid.Volume.low = 10; /* XXX */
842 tcall = rx_NewCall(cstruct->conns[0]);
843 code = StartAFS_Readdir(tcall, &fid, offset, length, &hyp0, 0);
845 code = FetchDir(tcall);
849 EndAFS_FetchData(tcall, &NextOffset, &OutDirStatus, &Token,
852 code = rx_EndCall(tcall, code);
858 FetchDir(register struct rx_call *acall)
860 extern char *malloc();
861 register char *tbuffer;
862 afs_int32 tlen, length, code;
866 tbuffer = malloc(256);
868 code = rx_Read(acall, &length, sizeof(afs_int32));
869 length = ntohl(length);
870 if (code != sizeof(afs_int32))
874 tlen = (length > 8192 ? 8192 : length);
875 code = rx_Read(acall, tbuffer, tlen);
882 dp = (struct dirent *)dp;
891 struct afsFetchStatus OutDirStatus, OutFidStatus;
892 struct afsVolSync tsync;
893 struct afsFid fid, outFid;
898 sscanf(&(*argp)[0], "%d", &vnode);
900 sscanf(&(*argp)[0], "%d", &unique);
902 memset(&fid, 0, sizeof(struct afsFid));
903 fid.Volume.low = 10; /* XXX */
909 ubik_AFS_Lookup(cstruct, 0, &fid, name, &hyp0, 0, &outFid,
910 &OutFidStatus, &OutDirStatus, &tsync);
916 GetToken(char **argp)
918 struct afsFetchStatus OutStatus;
919 struct afsVolSync tsync;
920 struct afsToken MinToken, RealToken;
922 int vnode, unique, tokenId;
925 sscanf(&(*argp)[0], "%d", &vnode);
927 sscanf(&(*argp)[0], "%d", &unique);
929 memset(&fid, 0, sizeof(struct afsFid));
930 fid.Volume.low = 10; /* XXX */
933 sscanf(&(*argp)[0], "%d", &tokenId);
935 memset(&MinToken, 0, sizeof(struct afsToken));
936 MinToken.tokenID.low = tokenId; /* XXX */
938 ubik_AFS_GetToken(cstruct, 0, &fid, &MinToken, &hyp0, 0,
939 &RealToken, &OutStatus, &tsync);
945 MakeMountPoint(char **argp)
951 ReleaseTokens(char **argp)
957 BulkStatus(char **argp)
961 /* printf("ka <vol.l> <vnode> <unique> <isExec> <kaTime>\n"); */
963 KeepAlive(char **argp)
965 struct afsBulkFEX fex;
966 afs_uint32 numExec, spare4;
970 memset(&fx, 0, sizeof(struct afsFidExp));
971 sscanf(&(*argp)[0], "%d", &fx.fid.Volume.low);
973 sscanf(&(*argp)[0], "%d", &fx.fid.Vnode);
975 sscanf(&(*argp)[0], "%d", &fx.fid.Unique);
977 sscanf(&(*argp)[0], "%d", &numExec);
979 sscanf(&(*argp)[0], "%d", &fx.keepAliveTime);
980 memset(&fex, 0, sizeof(struct afsBulkFEX));
981 fex.afsBulkFEX_val = &fx;
982 fex.afsBulkFEX_len = 1;
984 ubik_AFS_BulkKeepAlive(cstruct, 0, &fex, numExec, 0, 0, 0,