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>
16 #include <afs/afsint.h>
17 #include <rx/rx_globals.h>
19 #include <sys/socket.h>
20 #include <netinet/in.h>
34 struct ubik_client *cstruct;
35 struct rx_connection *serverconns[MAXSERVERS];
38 extern int AFS_FetchData(), AFS_StoreData(), AFS_StoreACL();
39 extern int RXAFS_GetTime(), AFS_GetStatistics(), AFS_FetchStatus(), AFS_FetchACL();
40 extern int AFS_StoreStatus(), AFS_RemoveFile(), AFS_CreateFile();
41 extern int AFS_Rename(), AFS_Symlink(), AFS_HardLink(), AFS_MakeDir(), AFS_RemoveDir();
42 extern int AFS_Readdir(), AFS_MakeMountPoint(), AFS_ReleaseTokens(), AFS_GetToken();
43 extern int AFS_BulkStatus(), AFS_Lookup();
44 extern int AFS_BulkStatus(), AFS_BulkLookup(), AFS_RenewAllTokens();
45 extern int AFS_BulkFetchVV(), AFS_BulkKeepAlive();
46 extern int AFS_Spare1(), AFS_Spare2(), AFS_Spare3(), AFS_Spare4(), AFS_Spare5(), AFS_Spare6();
48 afs_int32 pxclient_Initialize(auth, serverAddr)
53 struct rx_securityClass *sc;
55 code = rx_Init(htons(2115)/*0*/);
57 fprintf(stderr,"pxclient_Initialize: Could not initialize rx.\n");
64 sc = rxnull_NewClientSecurityObject();
67 #ifdef notdef /* security */
69 sc = rxvab_NewClientSecurityObject(&ttoken.sessionKey, ttoken.ticket, 0);
73 sc = rxkad_NewClientSecurityObject (rxkad_clear,
74 &ttoken.sessionKey, ttoken.kvno, ttoken.ticketLen, ttoken.ticket);
77 serverconns[0] = rx_NewConnection(serverAddr, htons(7000), 1, sc, scIndex);
79 code = ubik_ClientInit(serverconns, &cstruct);
82 fprintf(stderr,"pxclient_Initialize: ubik client init failed.\n");
90 #include "AFS_component_version_number.c"
96 struct sockaddr_in host;
97 register afs_int32 code;
98 extern struct hostent *gethostbyname();
103 int noAuth = 1; /* Default is authenticated connections */
107 printf("usage: pxclient <serverHost>\n");
110 memset((char *)&host, 0, sizeof(struct sockaddr_in));
111 host.sin_family = AF_INET;
112 host.sin_addr.s_addr = inet_addr(av[0]);
113 #ifdef STRUCT_SOCKADDR_HAS_SA_LEN
114 host.sin_len = sizeof(struct sockaddr_in);
116 if (host.sin_addr.s_addr != -1) {
117 strcpy(hnamebuf, av[0]);
120 hp = gethostbyname(av[0]);
122 host.sin_family = hp->h_addrtype;
123 memcpy((caddr_t)&host.sin_addr, hp->h_addr, hp->h_length);
124 hostname = hp->h_name;
126 printf("unknown server host %s\n", av[0]);
130 if (code = pxclient_Initialize(noAuth, host.sin_addr.s_addr)) {
131 printf("Couldn't initialize fs library (code=%d).\n",code);
135 code = ubik_Call(RXAFS_GetTime, cstruct, 0, &tv.tv_sec, &tv.tv_usec);
137 printf("AFS_GetTime on %s sec=%d, usec=%d\n", av[0], tv.tv_sec, tv.tv_usec);
139 printf("return code is %d\n", code);
147 if (fgets(line, 499, stdin) != NULL) {
149 register char **argp = args;
150 GetArgs(line, argp, &nargs);
153 if (!strcmp(oper, "probe")) {
154 code = ubik_Call(RXAFS_GetTime, cstruct, 0, &tv.tv_sec, &tv.tv_usec);
155 printf("return code is %d\n", code);
157 printf("sec=%d\n", tv.tv_sec);
158 } else if (!strcmp(oper, "fsstats")) {
159 struct afsStatistics stats;
161 code = ubik_Call(AFS_GetStatistics, cstruct, 0, &stats);
162 printf("return code is %d\n", code);
163 } else if (!strcmp(oper, "fd")) {
164 code = FetchData(argp);
165 printf("return code is %d\n", code);
166 } else if (!strcmp(oper, "fs")) {
167 code = FetchStatus(argp);
168 printf("return code is %d\n", code);
169 } else if (!strcmp(oper, "fa")) {
170 code = FetchACL(argp);
171 printf("return code is %d\n", code);
172 } else if (!strcmp(oper, "sd")) {
173 code = StoreData(argp);
174 printf("return code is %d\n", code);
175 } else if (!strcmp(oper, "ss")) {
176 code = StoreStatus(argp);
177 printf("return code is %d\n", code);
178 } else if (!strcmp(oper, "sa")) {
179 code = StoreACL(argp);
180 printf("return code is %d\n", code);
181 } else if (!strcmp(oper, "cf")) {
182 code = CreateFile(argp);
183 printf("return code is %d\n", code);
184 } else if (!strcmp(oper, "rf")) {
185 code = RemoveFile(argp);
186 printf("return code is %d\n", code);
187 } else if (!strcmp(oper, "rn")) {
189 printf("return code is %d\n", code);
190 } else if (!strcmp(oper, "sl")) {
191 code = Symlink(argp);
192 printf("return code is %d\n", code);
193 } else if (!strcmp(oper, "hl")) {
194 code = HardLink(argp);
195 printf("return code is %d\n", code);
196 } else if (!strcmp(oper, "md")) {
197 code = MakeDir(argp);
198 printf("return code is %d\n", code);
199 } else if (!strcmp(oper, "rd")) {
200 code = RemoveDir(argp);
201 printf("return code is %d\n", code);
202 } else if (!strcmp(oper, "rdd")) {
203 code = Readdir(argp);
204 printf("return code is %d\n", code);
205 } else if (!strcmp(oper, "mm")) {
206 code = MakeMountPoint(argp);
207 printf("return code is %d\n", code);
208 } else if (!strcmp(oper, "rt")) {
209 code = ReleaseTokens(argp);
210 printf("return code is %d\n", code);
211 } else if (!strcmp(oper, "bs")) {
212 code = BulkStatus(argp);
213 printf("return code is %d\n", code);
214 } else if (!strcmp(oper, "lk")) {
216 printf("return code is %d\n", code);
217 } else if (!strcmp(oper, "gt")) {
218 code = GetToken(argp);
219 printf("return code is %d\n", code);
220 } else if (!strcmp(oper, "ka")) {
221 code = KeepAlive(argp);
222 printf("return code is %d\n", code);
223 } else if ((!strcmp(oper,"q")) || !strcmp(oper, "quit"))
226 printf("Unknown oper! Available operations: \n\n");
227 printf("fd <vnode> <unique> <pos> <len>\n");
228 printf("fs <vnode> <unique>\n");
229 printf("fa <vnode> <unique>\n");
230 printf("sd <vnode> <unique> <pos> <len> <flen> [<mode>|-1] [<owner>|-1] [<length>|-1] <string>\n");
231 printf("ss <vnode> <unique> [<mode>|-1] [<owner>|-1] [<length>|-1]\n");
232 printf("sa <vnode> <unique> <string>\n");
233 printf("rf <vnode> <unique> <name>\n");
234 printf("cf <vnode> <unique> <name> [<mode>|-1] [<owner>|-1] [<length>|-1]\n");
235 printf("rn <ovnode> <ounique> <oname> <nvnode> <nunique> <nname>\n");
236 printf("sl <vnode> <unique> <name> <contents> [<mode>|-1] [<owner>|-1] [<length>|-1]\n");
237 printf("hl <dvnode> <dunique> <name> <evnode> <eunique>\n");
238 printf("md <vnode> <unique> <name> [<mode>|-1] [<owner>|-1] [<length>|-1]\n");
239 printf("rd <vnode> <unique> <name>\n");
240 printf("rdd <vnode> <unique> <pos> <len>\n");
241 printf("lk <vnode> <unique> <name>\n");
242 printf("gt <vnode> <unique> <tokenID>\n");
243 printf("ka <vol.l> <vnode> <unique> <isExec> <kaTime>\n");
251 GetArgs(line,args, nargs)
253 register char **args;
258 register char *last = line;
265 *args++ = line, (*nargs)++;
266 while (*line && *line != ' ')
275 struct afsFetchStatus OutStatus;
276 struct afsToken Token;
277 struct afsVolSync tsync;
279 int vnode, unique, position, length;
281 struct rx_call *tcall;
283 sscanf(&(*argp)[0], "%d", &vnode);
285 sscanf(&(*argp)[0], "%d", &unique);
287 memset(&fid, 0, sizeof(struct afsFid));
288 fid.Volume.low = 10; /* XXX */
291 sscanf(&(*argp)[0], "%d", &position);
293 sscanf(&(*argp)[0], "%d", &length);
295 tcall = rx_NewCall(cstruct->conns[0]);
296 code = StartAFS_FetchData(tcall, &fid, &hyp0, position, length, 0);
298 code = FetchProc(tcall);
301 code = EndAFS_FetchData(tcall, &OutStatus, &Token, &tsync);
303 code = rx_EndCall(tcall, code);
307 static FetchProc(acall)
308 register struct rx_call *acall;
310 extern char *malloc();
311 register char *tbuffer;
312 afs_int32 tlen, length, code;
314 code = rx_Read(acall, &length, sizeof(afs_int32));
315 length = ntohl(length);
316 if (code != sizeof(afs_int32))
318 tbuffer = malloc(256);
320 tlen = (length > 256? 256 : length);
321 code = rx_Read(acall, tbuffer, tlen);
336 struct afsFetchStatus OutStatus;
337 struct afsToken Token;
338 struct afsVolSync tsync;
343 sscanf(&(*argp)[0], "%d", &vnode);
345 sscanf(&(*argp)[0], "%d", &unique);
347 memset(&fid, 0, sizeof(struct afsFid));
348 fid.Volume.low = 10; /* XXX */
351 code = ubik_Call(AFS_FetchStatus, cstruct, 0, &fid, &hyp0, 0,
352 &OutStatus, &Token, &tsync);
360 struct afsFetchStatus OutStatus;
361 struct afsACL AccessList;
362 struct afsToken Token;
363 struct afsVolSync tsync;
368 sscanf(&(*argp)[0], "%d", &vnode);
370 sscanf(&(*argp)[0], "%d", &unique);
372 memset(&fid, 0, sizeof(struct afsFid));
373 fid.Volume.low = 10; /* XXX */
376 code = ubik_Call(AFS_FetchACL, cstruct, 0, &fid, &hyp0, 0,
377 &AccessList, &OutStatus, &tsync);
385 struct afsStoreStatus InStatus;
386 struct afsFetchStatus OutStatus;
387 struct afsVolSync tsync;
389 int vnode, unique, position, length, filelength;
390 int mode, owner, len;
393 struct rx_call *tcall;
395 sscanf(&(*argp)[0], "%d", &vnode);
397 sscanf(&(*argp)[0], "%d", &unique);
399 memset(&fid, 0, sizeof(struct afsFid));
400 fid.Volume.low = 10; /* XXX */
403 sscanf(&(*argp)[0], "%d", &position);
405 sscanf(&(*argp)[0], "%d", &length);
407 sscanf(&(*argp)[0], "%d", &filelength);
409 memset(&InStatus, 0, sizeof(struct afsStoreStatus));
410 sscanf(&(*argp)[0], "%d", &mode);
412 sscanf(&(*argp)[0], "%d", &owner);
414 sscanf(&(*argp)[0], "%d", &len);
417 InStatus.mode = mode;
418 InStatus.mask |= AFS_SETMODE;
421 InStatus.owner = owner;
422 InStatus.mask |= AFS_SETOWNER;
425 InStatus.length = length;
426 InStatus.mask |= AFS_SETLENGTH;
428 string = &argp[0][0];
431 tcall = rx_NewCall(cstruct->conns[0]);
432 code = StartAFS_StoreData(tcall, &fid, &InStatus, position, length, filelength, &hyp0, 0);
434 code = StoreProc(tcall, string, length);
437 code = EndAFS_StoreData(tcall, &OutStatus, &tsync);
439 code = rx_EndCall(tcall, code);
444 static StoreProc(acall, string, length)
445 register struct rx_call *acall;
449 afs_int32 tlen, code;
452 tlen = (length > 256? 256 : length);
453 code = rx_Write(acall, string, tlen);
466 struct afsStoreStatus InStatus;
467 struct afsFetchStatus OutStatus;
468 struct afsVolSync tsync;
470 int vnode, unique, mode, owner, length;
473 sscanf(&(*argp)[0], "%d", &vnode);
475 sscanf(&(*argp)[0], "%d", &unique);
477 memset(&fid, 0, sizeof(struct afsFid));
478 fid.Volume.low = 10; /* XXX */
481 memset(&InStatus, 0, sizeof(struct afsStoreStatus));
482 sscanf(&(*argp)[0], "%d", &mode);
484 sscanf(&(*argp)[0], "%d", &owner);
486 sscanf(&(*argp)[0], "%d", &length);
489 InStatus.mode = mode;
490 InStatus.mask |= AFS_SETMODE;
493 InStatus.owner = owner;
494 InStatus.mask |= AFS_SETOWNER;
497 InStatus.length = length;
498 InStatus.mask |= AFS_SETLENGTH;
500 code = ubik_Call(AFS_StoreStatus, cstruct, 0, &fid, &InStatus, &hyp0, 0,
509 struct afsFetchStatus OutStatus;
510 struct afsACL AccessList;
511 struct afsToken Token;
512 struct afsVolSync tsync;
518 sscanf(&(*argp)[0], "%d", &vnode);
520 sscanf(&(*argp)[0], "%d", &unique);
522 memset(&fid, 0, sizeof(struct afsFid));
523 fid.Volume.low = 10; /* XXX */
526 string = &argp[0][0];
528 AccessList.afsACL_len = strlen(string)+1;
529 AccessList.afsACL_val = string;
530 code = ubik_Call(AFS_StoreACL, cstruct, 0, &fid,
531 &AccessList, &hyp0, 0, &OutStatus, &tsync);
539 struct afsFetchStatus OutDirStatus, OutFidStatus;
540 struct afsVolSync tsync;
541 struct afsFidName nameFid;
542 struct afsFid fid, outFid;
547 sscanf(&(*argp)[0], "%d", &vnode);
549 sscanf(&(*argp)[0], "%d", &unique);
551 memset(&fid, 0, sizeof(struct afsFid));
552 fid.Volume.low = 10; /* XXX */
557 memset(&nameFid, 0, sizeof(struct afsFidName));
558 strcpy(nameFid.name, name);
559 code = ubik_Call(AFS_RemoveFile, cstruct, 0, &fid, &nameFid, &hyp0, 0,
560 &OutDirStatus, &OutFidStatus, &outFid, &tsync);
568 struct afsFetchStatus OutDirStatus, OutFidStatus;
569 struct afsStoreStatus InStatus;
570 struct afsVolSync tsync;
571 struct afsFid fid, outFid;
572 struct afsToken Token;
574 int vnode, unique, mode, owner, length;
577 sscanf(&(*argp)[0], "%d", &vnode);
579 sscanf(&(*argp)[0], "%d", &unique);
581 memset(&fid, 0, sizeof(struct afsFid));
582 fid.Volume.low = 10; /* XXX */
587 memset(&InStatus, 0, sizeof(struct afsStoreStatus));
588 sscanf(&(*argp)[0], "%d", &mode);
590 sscanf(&(*argp)[0], "%d", &owner);
592 sscanf(&(*argp)[0], "%d", &length);
595 InStatus.mode = mode;
596 InStatus.mask |= AFS_SETMODE;
599 InStatus.owner = owner;
600 InStatus.mask |= AFS_SETOWNER;
603 InStatus.length = length;
604 InStatus.mask |= AFS_SETLENGTH;
606 code = ubik_Call(AFS_CreateFile, cstruct, 0, &fid, name, &InStatus, &hyp0, 0,
607 &outFid, &OutFidStatus, &OutDirStatus, &Token, &tsync);
615 struct afsFetchStatus OutOldDirStatus, OutNewDirStatus;
616 struct afsFetchStatus OutOldFileStatus, OutNewFileStatus;
617 struct afsVolSync tsync;
618 struct afsFid OldDirFid, NewDirFid, OutOldFileFid, OutNewFileFid;
619 struct afsFidName OldName, NewName;
621 int ovnode, ounique, nvnode, nunique;
624 sscanf(&(*argp)[0], "%d", &ovnode);
626 sscanf(&(*argp)[0], "%d", &ounique);
628 memset(&OldDirFid, 0, sizeof(struct afsFid));
629 OldDirFid.Volume.low = 10; /* XXX */
630 OldDirFid.Vnode = ovnode;
631 OldDirFid.Unique = ounique;
634 memset(&OldName, 0, sizeof(struct afsFidName));
635 strcpy(OldName.name, oname);
636 sscanf(&(*argp)[0], "%d", &nvnode);
638 sscanf(&(*argp)[0], "%d", &nunique);
640 memset(&NewDirFid, 0, sizeof(struct afsFid));
641 NewDirFid.Volume.low = 10; /* XXX */
642 NewDirFid.Vnode = nvnode;
643 NewDirFid.Unique = nunique;
646 memset(&NewName, 0, sizeof(struct afsFidName));
647 strcpy(NewName.name, nname);
648 code = ubik_Call(AFS_Rename, cstruct, 0, &OldDirFid, &OldName, &NewDirFid, &NewName, &hyp0, 0,
649 &OutOldDirStatus, &OutNewDirStatus,
650 &OutOldFileFid, &OutOldFileStatus,
651 &OutNewFileFid, &OutNewFileStatus, &tsync);
659 struct afsFetchStatus OutDirStatus, OutFidStatus;
660 struct afsStoreStatus InStatus;
661 struct afsVolSync tsync;
662 struct afsFid fid, outFid;
663 struct afsToken Token;
664 char *name, *linkcontents;
665 int vnode, unique, mode, owner, length;
668 sscanf(&(*argp)[0], "%d", &vnode);
670 sscanf(&(*argp)[0], "%d", &unique);
672 memset(&fid, 0, sizeof(struct afsFid));
673 fid.Volume.low = 10; /* XXX */
678 linkcontents = &argp[0][0];
680 memset(&InStatus, 0, sizeof(struct afsStoreStatus));
681 sscanf(&(*argp)[0], "%d", &mode);
683 sscanf(&(*argp)[0], "%d", &owner);
685 sscanf(&(*argp)[0], "%d", &length);
688 InStatus.mode = mode;
689 InStatus.mask |= AFS_SETMODE;
692 InStatus.owner = owner;
693 InStatus.mask |= AFS_SETOWNER;
696 InStatus.length = length;
697 InStatus.mask |= AFS_SETLENGTH;
699 code = ubik_Call(AFS_Symlink, cstruct, 0, &fid, name, linkcontents, &InStatus, &hyp0, 0,
700 &outFid, &OutFidStatus, &OutDirStatus, &Token, &tsync);
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;
733 code = ubik_Call(AFS_HardLink, cstruct, 0, &fid, name, &existingFid, &hyp0, 0,
734 &OutFidStatus, &OutDirStatus, &tsync);
742 struct afsFetchStatus OutDirStatus, OutFidStatus;
743 struct afsStoreStatus InStatus;
744 struct afsVolSync tsync;
745 struct afsFid fid, outFid;
746 struct afsToken Token;
748 int vnode, unique, mode, owner, length;
751 sscanf(&(*argp)[0], "%d", &vnode);
753 sscanf(&(*argp)[0], "%d", &unique);
755 memset(&fid, 0, sizeof(struct afsFid));
756 fid.Volume.low = 10; /* XXX */
761 memset(&InStatus, 0, sizeof(struct afsStoreStatus));
762 sscanf(&(*argp)[0], "%d", &mode);
764 sscanf(&(*argp)[0], "%d", &owner);
766 sscanf(&(*argp)[0], "%d", &length);
769 InStatus.mode = mode;
770 InStatus.mask |= AFS_SETMODE;
773 InStatus.owner = owner;
774 InStatus.mask |= AFS_SETOWNER;
777 InStatus.length = length;
778 InStatus.mask |= AFS_SETLENGTH;
780 code = ubik_Call(AFS_MakeDir, cstruct, 0, &fid, name, &InStatus, &hyp0, 0,
781 &outFid, &OutFidStatus, &OutDirStatus, &Token, &tsync);
789 struct afsFetchStatus OutDirStatus;
790 struct afsVolSync tsync;
791 struct afsFid fid, outFid;
792 struct afsFidName nameFid;
797 sscanf(&(*argp)[0], "%d", &vnode);
799 sscanf(&(*argp)[0], "%d", &unique);
801 memset(&fid, 0, sizeof(struct afsFid));
802 fid.Volume.low = 10; /* XXX */
807 memset(&nameFid, 0, sizeof(struct afsFidName));
808 strcpy(nameFid.name, name);
809 code = ubik_Call(AFS_RemoveDir, cstruct, 0, &fid, &nameFid, &hyp0, 0,
810 &OutDirStatus, &outFid, &tsync);
818 struct afsFetchStatus OutDirStatus;
819 struct afsVolSync tsync;
821 struct afsToken Token;
823 struct rx_call *tcall;
824 int vnode, unique, offset, length, NextOffset;
827 sscanf(&(*argp)[0], "%d", &vnode);
829 sscanf(&(*argp)[0], "%d", &unique);
831 sscanf(&(*argp)[0], "%d", &offset);
833 sscanf(&(*argp)[0], "%d", &length);
835 memset(&fid, 0, sizeof(struct afsFid));
836 fid.Volume.low = 10; /* XXX */
839 tcall = rx_NewCall(cstruct->conns[0]);
840 code = StartAFS_Readdir(tcall, &fid, offset, length, &hyp0, 0);
842 code = FetchDir(tcall);
845 code = EndAFS_FetchData(tcall, &NextOffset, &OutDirStatus, &Token, &tsync);
847 code = rx_EndCall(tcall, code);
852 static FetchDir(acall)
853 register struct rx_call *acall;
855 extern char *malloc();
856 register char *tbuffer;
857 afs_int32 tlen, length, code;
861 tbuffer = malloc(256);
863 code = rx_Read(acall, &length, sizeof(afs_int32));
864 length = ntohl(length);
865 if (code != sizeof(afs_int32))
869 tlen = (length > 8192? 8192 : length);
870 code = rx_Read(acall, tbuffer, tlen);
877 dp = (struct dirent *)dp;
886 struct afsFetchStatus OutDirStatus, OutFidStatus;
887 struct afsVolSync tsync;
888 struct afsFid fid, outFid;
893 sscanf(&(*argp)[0], "%d", &vnode);
895 sscanf(&(*argp)[0], "%d", &unique);
897 memset(&fid, 0, sizeof(struct afsFid));
898 fid.Volume.low = 10; /* XXX */
903 code = ubik_Call(AFS_Lookup, cstruct, 0, &fid, name, &hyp0, 0,
904 &outFid, &OutFidStatus, &OutDirStatus, &tsync);
912 struct afsFetchStatus OutStatus;
913 struct afsVolSync tsync;
914 struct afsToken MinToken, RealToken;
916 int vnode, unique, tokenId;
919 sscanf(&(*argp)[0], "%d", &vnode);
921 sscanf(&(*argp)[0], "%d", &unique);
923 memset(&fid, 0, sizeof(struct afsFid));
924 fid.Volume.low = 10; /* XXX */
927 sscanf(&(*argp)[0], "%d", &tokenId);
929 memset(&MinToken, 0, sizeof(struct afsToken));
930 MinToken.tokenID.low = tokenId; /* XXX */
931 code = ubik_Call(AFS_GetToken, cstruct, 0, &fid, &MinToken, &hyp0, 0,
932 &RealToken, &OutStatus, &tsync);
951 /* printf("ka <vol.l> <vnode> <unique> <isExec> <kaTime>\n"); */
955 struct afsBulkFEX fex;
956 afs_uint32 numExec, spare4;
960 memset(&fx, 0, sizeof(struct afsFidExp));
961 sscanf(&(*argp)[0], "%d", &fx.fid.Volume.low);
963 sscanf(&(*argp)[0], "%d", &fx.fid.Vnode);
965 sscanf(&(*argp)[0], "%d", &fx.fid.Unique);
967 sscanf(&(*argp)[0], "%d", &numExec);
969 sscanf(&(*argp)[0], "%d", &fx.keepAliveTime);
970 memset(&fex, 0, sizeof(struct afsBulkFEX));
971 fex.afsBulkFEX_val = &fx;
972 fex.afsBulkFEX_len = 1;
973 code = ubik_Call(AFS_BulkKeepAlive, cstruct, 0, &fex, numExec, 0, 0, 0, &spare4);