开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > VxWorks > 查看源码
nfsLib.c
资源名称：vxwork_src.rar　[点击查看]
上传用户：nvosite88
上传日期：2007-01-17
资源大小：4983k
文件大小：60k
源码类别：

VxWorks

开发平台：

C/C++

nfsLib.c：源码内容
  1. /* nfsLib.c - Network File System (NFS) library */
  3. /* Copyright 1984-2001 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 03k,10may02,kbw  making man page edits
  10. 03j,06nov01,vvv  made max path length configurable (SPR #63551)
  11. 03i,15oct01,rae  merge from truestack ver 03m, base 03h (cleanup)
  12. 03h,15mar99,c_c  Doc: updated nfsAuthUnixSet manual (SPR #20867).
  13. 03g,14mar99,jdi  doc: removed refs to config.h and/or configAll.h (SPR 25663).
  14. 03f,20nov97,gnn  fix for spr#5436, need to support FIOFSTATFSGET
  15. 03e,30may97,sgv  fix for spr#8653, Check for NULL parameter in nfsExportShow
  16. 03d,06aug96,sgv  fix for spr#6468
  17. 03c,06aug96,sgv  fix for spr #4278. Eliminated the nfsLib closing
  18.  of the UDP socket(multiple close).
  19. 03b,06aug96,sgv  fix for spr#5895
  20. 03a,23feb95,caf  cleaned up pointer reference in nfsExportShow().
  21. 02g,09oct94,jag  nfsDirReadOne() was changed to handle EOF correctly.
  22. 02f,08sep94,jmm  Changed to use the new rpc genned versions of the xdr rtns
  23. 02e,11aug93,jmm  Changed ioctl.h and socket.h to sys/ioctl.h and sys/socket.h
  24. 02d,28jul93,jmm  moved AUTH_UNIX_FIELD_LEN and MAX_GRPS definitions to nfsLib.h
  25. 02c,03feb93,jdi  documentation cleanup for 5.1.
  26. 02b,16sep92,jcf  change typedef path to nfsPath.
  27. 02a,07sep92,smb  added blksize and blocks to the stat structure initialisation.
  28. 01z,19aug92,smb  Changed systime.h to sys/times.h.
  29. 01y,18jul92,smb  Changed errno.h to errnoLib.h.
  30. 01x,26may92,rrr  the tree shuffle
  31.   -changed includes to have absolute path from h/
  32. 01w,20jan92,jmm  changed nfsDirReadOne to also set errno to OK
  33. 01w,20jan92,jmm  changed nfsThingCreate to recognize symlinks (spr 1059)
  34. 02n,19dec91,rrr  put dirent.h before nfsLib.h so it would compile
  35. 02m,13dec91,gae  ANSI fixes.
  36. 02l,19nov91,rrr  shut up some ansi warnings.
  37. 02k,04oct91,rrr  passed through the ansification filter
  38.                   -changed functions to ansi style
  39.   -changed includes to have absolute path from h/
  40.   -changed VOID to void
  41.   -changed copyright notice
  42. 02j,26apr91,shl  removed NULL entry in help_msg of nfsHelp() (spr 987).
  43. 02i,05apr91,jdi  documentation -- removed header parens and x-ref numbers;
  44.  switched nfsHelp() to first position; doc review by dnw.
  45. 02h,08mar91,elh  added nfsReXmit{Sec,USec} so re-xmit time not hardcoded.
  46. 02g,22feb91,lpf  made 'ls' command work on files mounted from HP. (SPR #0935)
  47. 02f,21feb91,jaa  documentation.
  48. 02e,02oct90,hjb  added a call to htons() where needed.
  49. 02d,19jul90,dnw  mangen fix
  50. 02c,26jun90,jcf  changed semaphores to be mutex.
  51. 02b,29may90,dnw  fixed bug in nfsInit, introduced in 01x, of testing
  52.     taskRpcStatics->nfsClientCache before rpcTaskInit is called
  53.  made nfsInit be NOMANUAL
  54. 02a,10may90,dnw  fixed nfsDeleteHook to delete the owner task's nfs stuff rather
  55.    than the exception task's (del hooks are called by exception
  56.    task).
  57.  fixed nfsDeleteHook to free nfsClientCache
  58.  fixed nfsInit to add nfsDeleteHook only once
  59.  fixed bug in authorization usage: added authCount field to
  60.    verify that cached client authorization matches current
  61.    global setting
  62.  changed name of nfsAllUnmount() to nfsMntUnmountAll()
  63.  optimized by removing some unnecessary "freeres" calls
  64.  optimized by supplying buffers in xdr calls instead of having
  65.    them malloc'd, in readres (nfsFileRead) result msgs.
  66.  optimized by adding xdr_readdirresOne hack to nfsDirReadOne
  67.    which just decodes first entry and discards the rest.
  68.  changed references to taskModuleList to taskRpcStatics
  69.  added nfsExportRead and nfsExportFree for use by nfsMountAll
  70.    in nfsDrv
  71.  extracted client cache stuff from nfsClientCall() to new
  72.    function nfsClientCacheSetUp()
  73.  added forward declarations to fix lint about void
  74.  changed MAX_FILENAME_LENGTH to POSIX definitions PATH_MAX
  75.    and NAME_MAX where appropriate
  76.  cosmetic changes to print out of nfsExportShow and
  77.    nfsMountListPrint
  78.  removed nfsDirListPrint() (no longer used)
  79.  removed some unnecessary error printing
  80.  changed documentation about nfs's large stack requirements
  81.    (no longer a pig!)
  82. 01w,01may90,llk  deleted nfsLs().
  83.  added nfsDirReadOne() and nfsFileAttrGet().
  84.  changed to check return value of taskDeleteHookAdd().
  85.  changed calls to pathBuild() and pathCat() to examine return
  86.    values.
  87. 01v,14apr90,jcf  removed tcb extension dependencies.
  88. 01u,01apr90,llk  turned the `oldhost' field of moduleStatics into an array.
  89.  substituted smaller constants MAX_FILENAME_LENGTH for the
  90.    SUN specified NFS_MAXNAMLEN and NFS_MAXPATHLEN.
  91.  added safety checks for filename lengths.
  92.  deleted calls to pathArrayFree().
  93.  changed call to pathParse().
  94.  changed to clean out the CLIENT cache if authorization
  95.    parameters are changed by calling nfsClientCacheCleanUp().
  96.  changed rpcAuthUnix to nfsAuthUnix.  Made it LOCAL.
  97. 01t,07mar90,jdi  documentation cleanup.
  98. 01s,03dec89,llk  changed nfsClientClose() to check for non-null taskModuleList
  99.    before cleaning up the nfs cache.
  100. 01r,20oct89,hjb  changed "struct timeval" to nfsTimeval to avoid conflicts
  101.  with the definition of "struct timeval" in "utime.h".
  102. 01q,28aug89,dab  modified nfsFileRemove() to delete symbolic links.
  103. 01p,23jul89,gae  added taskDeleteHook for nfsCleanup.
  104. 01o,06jul89,llk  deleted nfsNameArrayFree().  Added call to pathArrayFree().
  105.  reworked calls to pathLib.  added panic() calls.  delinted.
  106. 01n,09jun89,llk  fixed bug in nfsLookUpByName() which showed up via rmdir().
  107. 01m,23may89,dnw  lint.
  108. 01l,26mar89,llk  added nfsClientCacheCleanUp and nfsNameArrayFree to get rid
  109.    of memory eaters.
  110. 01k,09nov88,llk  rearranged error checking of nfs structures returned by server.
  111. 01j,28sep88,llk  added nfsSockBufSize, nfsTimeoutSec, nfsTimeoutUSec.
  112.  added nfsIdSet().
  113. 01i,25aug88,gae  documentation.
  114. 01h,07jul88,jcf  lint.
  115. 01g,30jun88,llk  changed to handle links.
  116.  added nfsHelp().
  117.  more name changes.
  118. 01f,16jun88,llk  changed to more v4 names.
  119.  added LOCAL and NOMANUAL where appropriate.
  120.  moved pathSplit() to pathLib.c.
  121. 01e,04jun88,llk  rewrote nfsLs and nfsDirRead so they clean up after themselves.
  122.  incorporated pathLib.
  123.  added nfsAuthUnix{Set Get Prompt Show} for unix authentication.
  124. 01d,30may88,dnw  changed to v4 names.
  125. 01c,28may88,dnw  copied promptParam...() stuff here from bootLib so that
  126.    this lib doesn't depend on bootLib.
  127. 01b,26apr88,llk  bug fix.  Internet address returned from remGetHostByName
  128.    was compared to <= NULL.  Some large addresses can be
  129.    mistaken for negative numbers.
  130. 01a,19apr88,llk  written.
  131. */
  133. /*
  134. DESCRIPTION
  135. This library provides the client side of services for NFS (Network File
  136. System) devices.  Most routines in this library should not be called by
  137. users, but rather by device drivers.  The driver is responsible for
  138. keeping track of file pointers, mounted disks, and cached buffers.  This
  139. library uses Remote Procedure Calls (RPC) to make the NFS calls.
  141. VxWorks is delivered with NFS disabled.
  142. To use this feature, include the following component:
  143. INCLUDE_NFS
  145. In the same file, NFS_USER_ID and NFS_GROUP_ID should be
  146. defined to set the default user ID and group ID at system start-up.
  147. For information about creating NFS devices, see the 
  148. * .I "WindNet TCP/IP Network Programmer's Guide"
  150. Normal use of NFS requires no more than 2000 bytes of stack. This 
  151. requirement may change depending on how the maximum file name path length 
  152. parameter, NFS_MAXPATH, is configured. As many as 4 character arrays of
  153. length NFS_MAXPATH may be allocated off the stack during client operation.
  154. Therefore any increase in the parameter can increase stack usage by a
  155. factor of four times the deviation from default NFS_MAXPATH. For example,
  156. a change from 255 to 1024 will increase peak stack usage by (1024 -255) * 4
  157. which is 3076 bytes.
  160. NFS USER IDENTIFICATION
  161. NFS is built on top of RPC and uses a type of RPC authentication known as
  162. AUTH_UNIX, which is passed on to the NFS server with every NFS request.
  163. AUTH_UNIX is a structure that contains necessary information for NFS,
  164. including the user ID number and a list of group IDs to which the user 
  165. belongs.  On UNIX systems, a user ID is specified in the file 
  166. f3/etc/passwdfP.  The list of groups to which a user belongs is 
  167. specified in the file f3/etc/groupfP.
  169. To change the default authentication parameters, use nfsAuthUnixPrompt().
  170. To change just the AUTH_UNIX ID, use nfsIdSet().  Usually, only the user
  171. ID needs to be changed to indicate a new NFS user.
  173. INCLUDE FILES: nfsLib.h
  175. SEE ALSO
  176. rpcLib, ioLib, nfsDrv
  178. INTERNAL
  179. Every routine starts with a call to nfsInit.  nfsInit initializes RPC
  180. and sets up the appropriate RPC task variables used for NFS.  It
  181. may be called more than once with the only ill effect being wasted time.
  183. The constant nfsMaxPath is used instead of NFS_MAXPATHLEN (1024) or
  184. PATH_MAX (255). nfsMaxPath is derived from the configuration parameter
  185. NFS_MAXPATH. A short length like 255 helps conserve memory but restricts 
  186. use of longer paths. The introduction of NFS_MAXPATH allows the user to
  187. decide which is more important. The constant (NAME_MAX + 1) is used instead
  188. of NFS_MAXNAMELEN (255) in order to conserve memory. All file/path names 
  189. which have come to nfsLib via the I/O system, such as filenames being passed 
  190. to nfsLookUpByName(), have already been screened for their path and name 
  191. lengths being less than PATH_MAX and NAME_MAX.
  193. xdr_nfs has been changed to use the shorter lengths as well.
  194. */
  196. /* LINTLIBRARY */
  198. #include "vxWorks.h"
  199. #include "limits.h"
  200. #include "ctype.h"
  201. #include "string.h"
  202. #include "ioLib.h"
  203. #include "taskLib.h"
  204. #include "taskHookLib.h"
  205. #include "rpc/rpc.h"
  206. #include "stdlib.h"
  207. #include "sys/socket.h"
  208. #include "netinet/in.h"
  209. #include "rpc/auth.h"
  210. #include "rpc/rpcGbl.h"
  211. #include "xdr_nfs.h"
  212. #include "sys/stat.h"
  213. #include "dirent.h"
  214. #include "nfsLib.h"
  215. #include "hostLib.h"
  216. #include "sys/times.h"
  217. #include "sockLib.h"
  218. #include "pathLib.h"
  219. #include "stdio.h"
  220. #include "unistd.h"
  221. #include "errnoLib.h"
  222. #include "rpcLib.h"
  223. #include "netLib.h"
  224. #include "fioLib.h"
  225. #include "memPartLib.h"
  227. #define READDIR_MAXLEN 512 /* increased for NFSPROC_READDIR on */
  228. /* HP server */
  230. #ifdef __GNUC__
  231. # ifndef alloca
  232. #  define alloca __builtin_alloca
  233. # endif
  234. #endif
  236. /* IMPORTS */
  238. IMPORT int   nfsMaxPath;               /* max. length of file path */
  240. /* GLOBALS */
  242. unsigned nfsMaxMsgLen = NFS_MAXDATA; /* largest read or write buffer that
  243.  * can be transfered to/from the nfs
  244.  * server
  245.  */
  246. u_int nfsTimeoutSec   = NFS_TIMEOUT_SEC;
  247. u_int nfsTimeoutUSec  = NFS_TIMEOUT_USEC;
  249. u_int nfsReXmitSec    = NFS_REXMIT_SEC;
  250. u_int nfsReXmitUSec   = NFS_REXMIT_USEC;
  252. int   nfsSockBufSize  = NFS_SOCKOPTVAL;
  254. /* LOCALS */
  256. /*
  257. Static RPC information.
  258. Set on initial NFS invocation and re-used during
  259. subsequent calls on a per task basis.
  260. */
  262. typedef struct moduleStatics
  263.     {
  264.     CLIENT *client;     /* pointer to client structure */
  265.     int socket;         /* socket associated with this client */
  266.     int oldprognum;     /* last program number used with this client */
  267.     int oldversnum;     /* last version number used with this client */
  268.     int authCount; /* auth count this client was built with */
  269.     int valid;          /* if TRUE, then this client information is valid */
  270.     char oldhost [MAXHOSTNAMELEN];
  271.      /* last host name that was used with this client */
  272.     } NFS_MODULE_STATICS;
  274. typedef struct /* NFS_AUTH_UNIX_TYPE - UNIX authentication structure */
  275.     {
  276.     char machname [AUTH_UNIX_FIELD_LEN];  /* host name where client is */
  277.     int uid; /* client's UNIX effective uid */
  278.     int gid; /* client's current group ID */
  279.     int len; /* element length of aup_gids */
  280.     int aup_gids [MAX_GRPS]; /* array of groups user is in */
  281.     } NFS_AUTH_UNIX_TYPE;
  283. /* There is a single global nfs authorization, nfsAuthUnix.
  284.  * Any time it is changed, nfsAuthCount is bumped.  This count is kept
  285.  * in the nfsClientCache to make sure that the client was built with the
  286.  * current authorization parameters.  In the future, it might be desirable
  287.  * to let different tasks have different authorizations.
  288.  */
  290. LOCAL NFS_AUTH_UNIX_TYPE nfsAuthUnix;
  291. LOCAL int  nfsAuthCount;
  293. LOCAL BOOL nfsInstalled;
  295. /* forward declarations */
  297. LOCAL STATUS nfsClientCall (char *host, u_int prognum, u_int versnum, u_int procnum, xdrproc_t inproc, char *in, xdrproc_t outproc, char *out);
  298. LOCAL STATUS nfsLinkGet (char * hostName, nfs_fh * pHandle, nfspath realPath);
  299. LOCAL STATUS nfsInit (void);
  300. LOCAL void nfsDeleteHook ();
  301. LOCAL void nfsClientCacheCleanUp ();
  302. LOCAL void nfsMountListPrint ();
  303. LOCAL void nfsGroupsPrint ();
  304. LOCAL void nfsExportPrint ();
  305. LOCAL void nfsErrnoSet ();
  306. LOCAL void printClear ();
  307. LOCAL void promptParamString ();
  308. LOCAL void promptParamNum ();
  310. /*******************************************************************************
  311. *
  312. * nfsDirMount - mount an NFS directory
  313. *
  314. * RETURNS: OK or ERROR
  315. *
  316. * NOMANUAL
  317. */
  319. STATUS nfsDirMount
  320.     (
  321.     char *hostName,
  322.     dirpath dirname,
  323.     nfs_fh *pFileHandle         /* the directory's file handle */
  324.     )
  325.     {
  326.     fhstatus fileHandleStatus;
  328.     bzero ((char *) &fileHandleStatus, sizeof (fileHandleStatus));
  330.     if (nfsClientCall (hostName, MOUNTPROG, MOUNTVERS, MOUNTPROC_MNT,
  331. xdr_dirpath, (char *) &dirname,
  332. xdr_fhstatus, (char *) &fileHandleStatus) == ERROR)
  333. {
  334. return (ERROR);
  335. }
  337.     if (fileHandleStatus.fhs_status != 0)
  338. {
  339. netErrnoSet ((int) fileHandleStatus.fhs_status); /* UNIX error */
  340. return (ERROR);
  341. }
  343.     bcopy ((char *) &fileHandleStatus.fhstatus_u.fhs_fhandle,
  344.    (char *) pFileHandle, sizeof (nfs_fh));
  346.     return (OK);
  347.     }
  348. /*******************************************************************************
  349. *
  350. * nfsDirUnmount - unmount an NFS directory
  351. *
  352. * RETURNS: OK or ERROR
  353. *
  354. * NOMANUAL
  355. */
  357. STATUS nfsDirUnmount
  358.     (
  359.     char *hostName,
  360.     dirpath dirname
  361.     )
  362.     {
  363.     return (nfsClientCall (hostName, MOUNTPROG, MOUNTVERS, MOUNTPROC_UMNT,
  364. xdr_dirpath, (char *) &dirname,
  365. xdr_void, (char *) NULL));
  366.     }
  367. /*******************************************************************************
  368. *
  369. * nfsMntUnmountAll - unmount all file systems on a particular host
  370. *
  371. * This routine removes all NFS file systems mounted on <hostName> from that
  372. * host's client list.  It does NOT actually "unmount" the file systems.
  373. *
  374. * RETURNS: OK or ERROR.
  375. *
  376. * SEE ALSO: nfsMntDump()
  377. *
  378. * NOMANUAL
  379. */
  381. STATUS nfsMntUnmountAll
  382.     (
  383.     char *hostName              /* host machine to unmount from */
  384.     )
  385.     {
  386.     return (nfsClientCall (hostName, MOUNTPROG, MOUNTVERS, MOUNTPROC_UMNTALL,
  387. xdr_void, (char *) NULL,
  388. xdr_void, (char *) NULL));
  389.     }
  390. /*******************************************************************************
  391. *
  392. * nfsMntDump - display all NFS file systems mounted on a particular host
  393. *
  394. * This routine displays all the NFS file systems mounted on a specified host
  395. * machine.
  396. *
  397. * RETURNS: OK or ERROR.
  398. *
  399. * NOMANUAL
  400. */
  402. STATUS nfsMntDump
  403.     (
  404.     char *hostName              /* host machine */
  405.     )
  406.     {
  407.     mountlist mEntries;
  409.     bzero ((char *) &mEntries, sizeof (mEntries));
  411.     if (nfsClientCall (hostName, MOUNTPROG, MOUNTVERS, MOUNTPROC_DUMP,
  412. xdr_void, (char *) NULL,
  413. xdr_mountlist, (char *) &mEntries) == ERROR)
  414. {
  415. return (ERROR);
  416. }
  418.     if (mEntries)
  419. nfsMountListPrint (mEntries);
  421.     clntudp_freeres (taskRpcStatics->nfsClientCache->client, xdr_mountlist,
  422.      (caddr_t) &mEntries);
  423.     return (OK);
  424.     }
  425. /*******************************************************************************
  426. *
  427. * nfsExportRead - get list of a host's exported file systems
  428. *
  429. * This routine gets the exported file systems of a specified host and the groups
  430. * that are allowed to mount them.
  431. *
  432. * After calling this routine, the export list must be free'd by calling
  433. * nfsExportFree.
  434. *
  435. * RETURNS: OK or ERROR.
  436. *
  437. * NOMANUAL
  438. */
  440. STATUS nfsExportRead
  441.     (
  442.     char *hostName,     /* host machine for which to show exports */
  443.     exports *pExports
  444.     )
  445.     {
  446.     bzero ((char *) pExports, sizeof (*pExports));
  448.     return (nfsClientCall (hostName, MOUNTPROG, MOUNTVERS, MOUNTPROC_EXPORT,
  449.    xdr_void, (char *) NULL,
  450.    xdr_exports, (char *) pExports));
  451.     }
  452. /*******************************************************************************
  453. *
  454. * nfsExportFree - get list of a host's exported file systems
  455. *
  456. * This routine frees the list of exported file systems returned by
  457. * nfsExportRead.  It must be called after calling nfsExportRead, if
  458. * nfsExportRead returns OK.
  459. *
  460. * RETURNS: OK
  461. *
  462. * NOMANUAL
  463. */
  465. STATUS nfsExportFree
  466.     (
  467.     exports *pExports
  468.     )
  469.     {
  470.     clntudp_freeres (taskRpcStatics->nfsClientCache->client, xdr_exports,
  471.      (caddr_t) pExports);
  472.     return (OK);
  473.     }
  474. /*******************************************************************************
  475. *
  476. * nfsHelp - display the NFS help menu
  477. *
  478. * This routine displays a summary of NFS facilities typically called from
  479. * the shell:
  480. * .CS
  481. *     nfsHelp                       Print this list
  482. *     netHelp                       Print general network help list
  483. *     nfsMount "host","filesystem"[,"devname"]  Create device with
  484. *                                     file system/directory from host
  485. *     nfsUnmount "devname"          Remove an NFS device
  486. *     nfsAuthUnixShow               Print current UNIX authentication
  487. *     nfsAuthUnixPrompt             Prompt for UNIX authentication
  488. *     nfsIdSet id     Set user ID for UNIX authentication
  489. *     nfsDevShow                    Print list of NFS devices
  490. *     nfsExportShow "host"          Print a list of NFS file systems which
  491. *                                     are exported on the specified host
  492. *     mkdir "dirname"               Create directory
  493. *     rm "file"                     Remove file
  494. *
  495. *     EXAMPLE:  -> hostAdd "wrs", "90.0.0.2"
  496. *               -> nfsMount "wrs","/disk0/path/mydir","/mydir/"
  497. *               -> cd "/mydir/"
  498. *               -> nfsAuthUnixPrompt     /@ fill in user ID, etc.     @/
  499. *               -> ls                    /@ list /disk0/path/mydir    @/
  500. *               -> copy < foo            /@ copy foo to standard out  @/
  501. *               -> ld < foo.o            /@ load object module foo.o  @/
  502. *               -> nfsUnmount "/mydir/"  /@ remove NFS device /mydir/ @/
  503. * .CE
  504. *
  505. * RETURNS: N/A
  506. */
  508. void nfsHelp (void)
  509.     {
  510.     static char *help_msg [] =
  511. {
  512. "nfsHelp                       Print this list",
  513. "netHelp                       Print general network help list",
  514. "nfsMount "host","filesystem"[,"devname"]  Create device with",
  515. "                                file system/directory from host",
  516. "nfsUnmount "devname"          Remove an NFS device",
  517. "nfsAuthUnixShow               Print current UNIX authentication",
  518. "nfsAuthUnixPrompt             Prompt for UNIX authentication",
  519. "nfsIdSet id                   Set user ID for UNIX authentication",
  520. "nfsDevShow                    Print list of NFS devices",
  521. "nfsExportShow "host"          Print a list of NFS file systems which",
  522. "                                are exported on the specified host",
  523. "mkdir "dirname"               Create directory",
  524. "rm "file"                     Remove file",
  525. "",
  526. "EXAMPLE:  -> hostAdd "wrs", "90.0.0.2"",
  527. "          -> nfsMount "wrs","/disk0/path/mydir","/mydir/"",
  528. "          -> cd "/mydir/"",
  529. "          -> nfsAuthUnixPrompt     /* fill in user ID, etc. *",
  530. "          -> ls                    /* list /disk0/path/mydir *",
  531. "          -> copy < foo            /* copy foo to standard out *",
  532. "          -> ld < foo.o            /* load object module foo.o *",
  533. "          -> nfsUnmount "/mydir/"  /* remove NFS device /mydir/ *",
  534. };
  535.     FAST int ix;
  537.     for (ix = 0; ix < NELEMENTS(help_msg); ix++)
  538. printf ("%sn", help_msg [ix]);
  539.     printf ("n");
  540.     }
  541. /*******************************************************************************
  542. *
  543. * nfsExportShow - display the exported file systems of a remote host
  544. *
  545. * This routine displays the file systems of a specified host and the groups
  546. * that are allowed to mount them.
  547. *
  548. * EXAMPLE
  549. * .CS
  550. *    -> nfsExportShow "wrs"
  551. *    /d0               staff
  552. *    /d1               staff eng
  553. *    /d2               eng
  554. *    /d3
  555. *    value = 0 = 0x0
  556. * .CE
  557. *
  558. * RETURNS: OK or ERROR.
  559. */
  561. STATUS nfsExportShow
  562.     (
  563.     char *hostName      /* host machine to show exports for */
  564.     )
  565.     {
  566.     exports nfsExports;
  568.     if (hostName == NULL)
  569.         {
  570.         errnoSet (S_hostLib_INVALID_PARAMETER);
  571.         return (ERROR);
  572.         }
  574.     if (nfsExportRead (hostName, &nfsExports) != OK)
  575. return (ERROR);
  577.     if (nfsExports)
  578. nfsExportPrint (nfsExports);
  580.     return (nfsExportFree (&nfsExports));
  581.     }
  583. /*******************************************************************************
  584. *
  585. * nfsLookUpByName - looks up a remote file
  586. *
  587. * This routine returns information on a given file.
  588. * It takes the host name, mount handle, and file name, and returns the
  589. * file handle of the file and the file's attributes in pDirOpRes, and
  590. * the file handle of the directory that the file resides in in pDirHandle.
  591. *
  592. * If the file name (directory path or filename itself) contains a symbolic
  593. * link, this routine changes the file name to incorporate the name of the link.
  594. *
  595. * RETURNS:  OK | ERROR | FOLLOW_LINK,
  596. *     if FOLLOW_LINK, then fileName contains the name of the link
  597. *
  598. * NOMANUAL
  599. */
  601. int nfsLookUpByName
  602.     (
  603.     char        *hostName,
  604.     char        *fileName,      /* name is changed if symbolic link */
  605.     nfs_fh      *pMountHandle,
  606.                                 /* these args are returned to calling routine */
  607.     FAST diropres *pDirOpRes,   /*    pointer to directory operation results */
  608.     nfs_fh      *pDirHandle     /*    pointer to file's directory file handle */
  609.     )
  610.     {
  611.     diropargs file;
  612.     int nameCount = 0;
  613.     char *nameArray  [MAX_DIRNAMES]; /* ptrs to individual dir/file names
  614.       * in path name */
  615.     char *nameBuf;                   /* buffer for individual dir/file names */
  616.     char *newLinkName;               /* new file name if file is symb link */
  617.     char *linkName;                  /* name of link file */
  618.     char *currentDir;                /* current dir for the look up's
  619.       * that have been done */
  622.     if (nfsInit () != OK)
  623. return (ERROR);
  625.     if ((nameBuf = (char *) alloca (nfsMaxPath)) == NULL)
  626. return (ERROR);
  627.     if ((newLinkName = (char *) alloca (nfsMaxPath)) == NULL)
  628. return (ERROR);
  629.     if ((linkName = (char *) alloca (nfsMaxPath)) == NULL)
  630. return (ERROR);
  631.     if ((currentDir = (char *) alloca (nfsMaxPath)) == NULL)
  632. return (ERROR);
  634.     bzero ((char *) &file, sizeof (file));
  636.     /* parse file name, enter each directory name in the path into the array */
  638.     pathParse (fileName, nameArray, nameBuf);
  640.     bcopy ((char *) pMountHandle, (char *) &file.dir, sizeof (nfs_fh));
  641.     bcopy ((char *) pMountHandle, (char *) pDirHandle, sizeof (nfs_fh));
  643.     /* start traversing file name */
  645.     while ((nameCount < MAX_DIRNAMES) && (nameArray [nameCount] != NULL))
  646. {
  647. file.name = nameArray [nameCount];
  649. if (nfsClientCall (hostName, NFS_PROGRAM, NFS_VERSION, NFSPROC_LOOKUP,
  650.     xdr_diropargs, (char *) &file,
  651.     xdr_diropres, (char *) pDirOpRes) == ERROR)
  653.     {
  654.     return (ERROR);
  655.     }
  657. if (pDirOpRes->status != NFS_OK)
  658.     {
  659.     nfsErrnoSet (pDirOpRes->status);
  660.     return (ERROR);
  661.     }
  663. if (pDirOpRes->diropres_u.diropres.attributes.type == NFDIR)
  664.     {
  665.     /* save directory information */
  667.     /* Store the directory handle of the second to last entry
  668.      * in the path name array.  This is the directory where the
  669.      * file in question (or directory in question) lives.
  670.      */
  672.     if ((nameCount < MAX_DIRNAMES - 1)
  673.         && (nameArray [nameCount + 1] != NULL))
  674.         {
  675. bcopy ((char *) &pDirOpRes->diropres_u.diropres.file,
  676.        (char *) pDirHandle, sizeof (nfs_fh));
  677.         }
  679.     /* copy directory handle for the next nfsClientCall */
  681.     bcopy ((char *) &pDirOpRes->diropres_u.diropres.file,
  682.    (char *) &file.dir, sizeof (nfs_fh));
  683.     }
  684. else if (pDirOpRes->diropres_u.diropres.attributes.type == NFLNK)
  685.     {
  686.     /* symbolic link, get real path name */
  688.     if (nfsLinkGet (hostName, &pDirOpRes->diropres_u.diropres.file,
  689.     linkName) == ERROR)
  690. {
  691. return (ERROR);
  692. }
  694.     /* Change fileName to include name of link.
  695.      * Concatenate the directory name, link name,
  696.      * and rest of the path name following the link.
  697.      */
  699.     *currentDir = EOS;
  701.     if ((pathBuild (nameArray, &(nameArray [nameCount]),
  702.     currentDir) == ERROR)
  703. || (pathCat (currentDir, linkName, newLinkName) == ERROR)
  704. || (pathBuild (&(nameArray [++nameCount]), (char **) NULL,
  705.        newLinkName) == ERROR))
  706. {
  707. return (ERROR);
  708. }
  710.     pathCondense (newLinkName);
  711.     (void) strcpy (fileName, newLinkName);
  713.     return (FOLLOW_LINK);
  714.     }
  716. nameCount++; /* look up next directory */
  717. } /* while */
  719.     return (OK);
  720.     }
  721. /*******************************************************************************
  722. *
  723. * nfsFileRemove - remove a file
  724. *
  725. * RETURNS: OK or ERROR
  726. *
  727. * NOMANUAL
  728. */
  730. STATUS nfsFileRemove
  731.     (
  732.     char *      hostName,
  733.     nfs_fh *    pMountHandle,   /* file handle of mount device */
  734.     char *      fullFileName
  735.     )
  736.     {
  737.     u_int nfsProc;
  738.     diropres dirResults;
  739.     diropargs where;
  740.     nfsstat status;
  741.     int         retVal;
  742.     char fileName [NAME_MAX + 1];
  743.     char * dirName;
  744.     nfs_fh dirHandle;
  746.     if (nfsInit () != OK)
  747. return (ERROR);
  749.     if (strlen (fullFileName) >= nfsMaxPath)
  750. return (ERROR);
  752.     if ((dirName = (char *) alloca (nfsMaxPath)) == NULL)
  753. return (ERROR);
  755.     bzero ((char *) &dirResults, sizeof (dirResults));
  756.     bzero ((char *) &status, sizeof (status));
  758.     pathSplit (fullFileName, dirName, fileName);
  760.     /*
  761.      * get info on the file to be removed, such as the handle of its directory
  762.      * and its file type (so we know whether to delete a file or directory)
  763.      *
  764.      * note:  some file servers will indeed delete a file with the
  765.      *        NFSPROC_RMDIR command
  766.      */
  768.     retVal = nfsLookUpByName (hostName, fullFileName, pMountHandle,
  769.  &dirResults, &dirHandle);
  771.     if (retVal == FOLLOW_LINK)
  772.         {
  773.         return (FOLLOW_LINK);
  774.         }
  775.     else
  776.         if (retVal == ERROR)
  777.             return (ERROR);
  780.     bcopy ((char *) &dirHandle, (char *) &where.dir, sizeof (nfs_fh));
  782.     where.name = fileName;
  784.     switch (dirResults.diropres_u.diropres.attributes.type)
  785. {
  786. case NFREG: /* remove regular file */
  787. case NFLNK: /* remove symbolic link */
  788.     nfsProc = NFSPROC_REMOVE;
  789.     break;
  791. case NFDIR: /* remove directory */
  792.     nfsProc = NFSPROC_RMDIR;
  793.     break;
  795. default:
  796.     errnoSet (S_nfsLib_NFS_INAPPLICABLE_FILE_TYPE);
  797.     return (ERROR);
  798. }
  800.     if (nfsClientCall (hostName, NFS_PROGRAM, NFS_VERSION, nfsProc,
  801.     xdr_diropargs, (char *) &where,
  802.     xdr_nfsstat, (char *) &status) == ERROR)
  803. {
  804. return (ERROR);
  805. }
  807.     if (status != NFS_OK)
  808. {
  809. nfsErrnoSet (status);
  810. return (ERROR);
  811. }
  813.     return (OK);
  814.     }
  815. /*******************************************************************************
  816. *
  817. * nfsRename - rename a file
  818. *
  819. * RETURNS: OK or ERROR
  820. *
  821. * NOMANUAL
  822. */
  824. STATUS nfsRename
  825.     (
  826.     char *      hostName,
  827.     nfs_fh *    pMountHandle,
  828.     char *      oldName,
  829.     nfs_fh *    pOldDirHandle,
  830.     char *      newName
  831.     )
  832.     {
  833.     diropres dirResults;
  834.     renameargs renameArgs;
  835.     nfsstat status;
  836.     char newFileName [NAME_MAX + 1];
  837.     char oldFileName [NAME_MAX + 1];
  838.     char * newDirName;
  839.     char * oldDirName;
  840.     nfs_fh dummyDirHandle;
  842.     if (nfsInit () != OK)
  843. return (ERROR);
  845.     if ((strlen (oldName) >= nfsMaxPath) || (strlen (newName) >= nfsMaxPath))
  846. {
  847. errnoSet (S_ioLib_NAME_TOO_LONG);
  848. return (ERROR);
  849. }
  851.     if ((newDirName = (char *) alloca (nfsMaxPath)) == NULL)
  852. return (ERROR);
  854.     if ((oldDirName = (char *) alloca (nfsMaxPath)) == NULL)
  855. return (ERROR);
  857.     bzero ((char *) &dirResults, sizeof (dirResults));
  858.     bzero ((char *) &status, sizeof (status));
  860.     pathSplit (oldName, oldDirName, oldFileName);
  861.     pathSplit (newName, newDirName, newFileName);
  863.     bcopy ((char *) pOldDirHandle, (char *) &renameArgs.from.dir,
  864.    sizeof (nfs_fh));
  865.     renameArgs.from.name = oldFileName;
  867.     if (newDirName [0] == EOS)
  868. {
  869. /* NULL directory name */
  871. bcopy ((char *) pMountHandle, (char *) &renameArgs.to.dir,
  872.        sizeof (nfs_fh));
  873. }
  874.     else
  875. {
  876. if (nfsLookUpByName (hostName, newDirName, pMountHandle,
  877.      &dirResults, &dummyDirHandle) != OK)
  878.     return (ERROR);
  880. bcopy ((char *) &dirResults.diropres_u.diropres.file,
  881.        (char *) &renameArgs.to.dir, sizeof (nfs_fh));
  882. }
  884.     renameArgs.to.name = newFileName;
  886.     if (nfsClientCall (hostName, NFS_PROGRAM, NFS_VERSION, NFSPROC_RENAME,
  887.     xdr_renameargs, (char *) &renameArgs,
  888.     xdr_nfsstat, (char *) &status) == ERROR)
  889. {
  890. return (ERROR);
  891. }
  893.     if (status != NFS_OK)
  894. {
  895. nfsErrnoSet (status);
  896. return (ERROR);
  897. }
  899.     return (OK);
  900.     }
  901. /*******************************************************************************
  902. *
  903. * nfsThingCreate - creates file or directory
  904. *
  905. * RETURNS:  OK | ERROR | FOLLOW_LINK,
  906. *     if FOLLOW_LINK, then fullFileName contains the name of the link
  907. *
  908. * NOMANUAL
  909. */
  911. int nfsThingCreate
  912.     (
  913.     char *      hostName,
  914.     char *      fullFileName,   /* name of thing being created */
  915.     nfs_fh *    pMountHandle,   /* mount device's file handle */
  916.     diropres *  pDirOpRes,      /* ptr to returned direc. operation results */
  917.     nfs_fh *    pDirHandle,     /* ptr to returned file's directory file hndl */
  918.     u_int       mode            /* mode that file or dir is created with
  919.                                  *   UNIX chmod style */
  920.     )
  921.     {
  922.     FAST int status;
  923.     char * newName;              /* new name if name contained a link */
  924.     char * dirName;              /* dir where file will be created */
  925.     char fileName[NAME_MAX + 1];    /* name of file without path */
  926.     char * tmpName;       /* temporary file name */
  928.     FAST sattr *pSattr; /* ptr to attributes */
  929.     diropres lookUpResult;
  930.     createargs createArgs;
  931.     nfs_fh dummyDirHandle;
  932.     u_int nfsProc; /* which nfs procedure to call,
  933.  * depending on whether a file or
  934.  * directory is made */
  936.     if (nfsInit () != OK)
  937. return (ERROR);
  939.     if ((newName = (char *) alloca (nfsMaxPath)) == NULL)
  940. return (ERROR);
  942.     if ((dirName = (char *) alloca (nfsMaxPath)) == NULL)
  943. return (ERROR);
  945.     /* Extra 4 characters allocated for '/../' */
  947.     if ((tmpName = (char *) alloca (nfsMaxPath + 1 + 3)) == NULL)
  948. return (ERROR);
  950.     bzero ((char *) &createArgs, sizeof (createArgs));
  951.     bzero ((char *) &lookUpResult, sizeof (lookUpResult));
  952.     bzero ((char *) pDirOpRes, sizeof (diropres));
  954.     pathSplit (fullFileName, dirName, fileName);
  956.     status = nfsLookUpByName (hostName, dirName, pMountHandle, &lookUpResult,
  957.       &dummyDirHandle);
  959.     if (status == FOLLOW_LINK)
  960. {
  961. if ((strlen (dirName) + strlen (fileName) + 1) >= nfsMaxPath)
  962.     {
  963.     errnoSet (S_ioLib_NAME_TOO_LONG);
  964.     status = ERROR;
  965.     }
  966. else
  967.     {
  968.     pathCat (dirName, fileName, newName);
  969.     (void) strcpy (fullFileName, newName);
  970.     }
  971. }
  973.     if (status != OK)
  974. return (status);
  976.     bcopy ((char *) &lookUpResult.diropres_u.diropres.file,
  977.    (char *) &createArgs.where.dir, sizeof (nfs_fh));
  979.     bcopy ((char *) &lookUpResult.diropres_u.diropres.file,
  980.    (char *) pDirHandle, sizeof (nfs_fh));
  982.     createArgs.where.name = fileName;
  984.     pSattr = &createArgs.attributes;
  986.     if (mode == 0)
  987.      /* create a file with default permissions */
  988. pSattr->mode = NFS_FSTAT_REG | DEFAULT_FILE_PERM;
  989.     else
  990. pSattr->mode = mode;
  992.     /* don't set these attributes */
  994.     pSattr->uid = pSattr->gid = pSattr->size = -1; /* user ID */
  995.     pSattr->atime.seconds = pSattr->atime.useconds = -1;
  996.     pSattr->mtime.seconds = pSattr->mtime.useconds = -1;
  998.     if (mode & NFS_FSTAT_DIR)
  999. nfsProc = NFSPROC_MKDIR;
  1000.     else
  1001.         nfsProc = NFSPROC_CREATE;
  1003.     if (nfsClientCall (hostName, NFS_PROGRAM, NFS_VERSION, nfsProc,
  1004.     xdr_createargs, (char *) &createArgs,
  1005.     xdr_diropres, (char *) pDirOpRes) == ERROR)
  1006. {
  1007. return (ERROR);
  1008. }
  1010.     /*
  1011.      * If the file created is really a symlink, then change the name and
  1012.      * return FOLLOW_LINK
  1013.      */
  1015.     if (pDirOpRes->diropres_u.diropres.attributes.type == NFLNK)
  1016.         {
  1017. strcpy (tmpName, fullFileName); /* Make a copy of fullFileName to
  1018.  * use with nfsLinkGet */
  1020. nfsLinkGet (hostName, &pDirOpRes->diropres_u.diropres.file, tmpName);
  1022.         /*
  1023.  * Need to replace last element of fullFileName with return value from
  1024.          * nfsLinkGet.  Add /../newFileName to fullFileName, call
  1025.          * pathCondense().
  1026.  */
  1028. strcpy (fullFileName, tmpName);
  1029. return (FOLLOW_LINK);
  1030. }
  1032.     if (pDirOpRes->status != NFS_OK)
  1033. {
  1034. nfsErrnoSet (pDirOpRes->status);
  1035. return (ERROR);
  1036. }
  1038.     return (OK);
  1039.     }
  1040. /*******************************************************************************
  1041. *
  1042. * nfsFileWrite - write to a file
  1043. *
  1044. * Either all characters will be written, or there is an ERROR.
  1045. *
  1046. * RETURNS:  number of characters written | ERROR
  1047. *
  1048. * NOMANUAL
  1049. */
  1051. int nfsFileWrite
  1052.     (
  1053.     char *      hostName,
  1054.     nfs_fh *    pHandle,        /* file handle of file being written to */
  1055.     unsigned    offset,         /* current byte offset in file */
  1056.     unsigned    count,          /* number of bytes to write */
  1057.     char *      data,           /* data to be written (up to NFS_MAXDATA) */
  1058.     fattr *     pNewAttr
  1059.     )
  1060.     {
  1061.     FAST unsigned nWrite = 0;       /* bytes written in one nfs write */
  1062.     FAST unsigned nTotalWrite = 0;    /* bytes written in all writes together */
  1063.     writeargs writeArgs;       /* arguments to pass to nfs server */
  1064.     attrstat writeResult;       /* info returned from nfs server */
  1066.     if (nfsInit () != OK)
  1067. return (ERROR);
  1069.     bzero ((char *) &writeArgs, sizeof (writeArgs));
  1071.     bcopy ((char *) pHandle, (char *) &writeArgs.file, sizeof (nfs_fh));
  1073.     /* set offset into file where write starts */
  1075.     writeArgs.offset = offset;
  1077.     while (nTotalWrite < count)
  1078. {
  1079. /* can only write up to NFS_MAXDATA bytes in one nfs write */
  1081. if (count - nTotalWrite > nfsMaxMsgLen)
  1082.     nWrite = nfsMaxMsgLen;
  1083. else
  1084.     nWrite = count - nTotalWrite;
  1086. writeArgs.totalcount = nWrite;
  1087. writeArgs.data.data_len = nWrite;
  1088. writeArgs.data.data_val = data + nTotalWrite;
  1089. writeArgs.offset = offset + nTotalWrite;
  1091. bzero ((char *) &writeResult, sizeof (attrstat));
  1093. if (nfsClientCall (hostName, NFS_PROGRAM, NFS_VERSION, NFSPROC_WRITE,
  1094. xdr_writeargs, (char *) &writeArgs,
  1095. xdr_attrstat, (char *) &writeResult) == ERROR)
  1096.     {
  1097.     return (ERROR);
  1099.     /* XXX if some writes have been done and there was an error,
  1100.      * nTotalWrite should be returned */
  1101.     }
  1103. if (writeResult.status != NFS_OK)
  1104.     {
  1105.     nfsErrnoSet (writeResult.status);
  1106.     return (ERROR);
  1107.     }
  1109. nTotalWrite += nWrite;
  1110. }
  1112.     bcopy ((char *) &writeResult.attrstat_u.attributes, (char *) pNewAttr,
  1113.    sizeof (fattr));
  1115.     /* if nfs write returned ok, then all bytes were written */
  1117.     return (count);
  1118.     }
  1119. /*******************************************************************************
  1120. *
  1121. * nfsFileRead - read from a file
  1122. *
  1123. * Reads as many bytes as are requested if that many bytes are left before
  1124. * the end of file.
  1125. *
  1126. * RETURNS: number of characters read or ERROR
  1127. *
  1128. * NOMANUAL
  1129. */
  1131. int nfsFileRead
  1132.     (
  1133.     char *      hostName,
  1134.     nfs_fh *    pHandle,        /* file handle of file being read */
  1135.     unsigned    offset,         /* start at offset bytes from beg. of file */
  1136.     unsigned    count,          /* number bytes to read up to */
  1137.     char *      buf,            /* buffer that data is read into */
  1138.     fattr *     pNewAttr        /* arguments returned from server */
  1139.     )
  1140.     {
  1141.     FAST unsigned nRead = 0; /* number of bytes read in one read */
  1142.     FAST unsigned nTotalRead = 0; /* bytes read in all reads together */
  1143.     readargs readArgs; /* arguments to pass to nfs server */
  1144.     readres readReply;
  1146.     if (nfsInit () != OK)
  1147. return (ERROR);
  1149.     bzero ((char *) &readArgs, sizeof (readArgs));
  1151.     bcopy ((char *) pHandle, (char *) &readArgs.file, sizeof (nfs_fh));
  1153.     while (nTotalRead < count)
  1154. {
  1155. if (count - nTotalRead > nfsMaxMsgLen)
  1156.     readArgs.count = nfsMaxMsgLen;
  1157. else
  1158.     readArgs.count = count - nTotalRead;
  1160. readArgs.offset = offset + nTotalRead;
  1162. bzero ((char *) &readReply, sizeof (readReply));
  1164. /* make xdr buffer point to caller's buffer */
  1166. readReply.readres_u.reply.data.data_val = buf + nTotalRead;
  1168. if (nfsClientCall (hostName, NFS_PROGRAM, NFS_VERSION, NFSPROC_READ,
  1169. xdr_readargs, (char *) &readArgs,
  1170. xdr_readres, (char *) &readReply) == ERROR)
  1171.     {
  1172.     return (ERROR);
  1173.     }
  1175. if (readReply.status != NFS_OK)
  1176.     {
  1177.     nfsErrnoSet (readReply.status);
  1178.     return (ERROR);
  1179.     }
  1182. /* check for end of file (data_len == 0) */
  1184. if ((nRead = readReply.readres_u.reply.data.data_len) == 0)
  1185.     break;
  1187. /* update attributes */
  1189. bcopy ((char *) &(readReply.readres_u.reply.attributes),
  1190.        (char *) pNewAttr, sizeof (fattr));
  1192. nTotalRead += nRead;
  1193. } /* while not all bytes requested have been read */
  1195.     return (nTotalRead);
  1196.     }
  1197. /*******************************************************************************
  1198. *
  1199. * nfsLinkGet - gets name of real file from a symbolic link
  1200. *
  1201. * RETURNS: OK or ERROR
  1202. */
  1204. LOCAL STATUS nfsLinkGet
  1205.     (
  1206.     char *      hostName,
  1207.     nfs_fh *    pHandle,        /* file handle of file being read */
  1208.     nfspath     realPath        /* the actual pathname gets returned here */
  1209.     )
  1210.     {
  1211.     readlinkres pathStatus;
  1213.     if (nfsInit () != OK)
  1214. return (ERROR);
  1216.     bzero ((char *) &pathStatus, sizeof (readlinkres));
  1218.     /* make xdr buffer point to caller's buffer */
  1219.     pathStatus.readlinkres_u.data = realPath;
  1221.     if (nfsClientCall (hostName, NFS_PROGRAM, NFS_VERSION, NFSPROC_READLINK,
  1222.     xdr_nfs_fh, (char *) pHandle,
  1223.     xdr_readlinkres, (char *) &pathStatus) == ERROR)
  1224. {
  1225. return (ERROR);
  1226. }
  1228.     if (pathStatus.status != NFS_OK)
  1229. {
  1230. nfsErrnoSet (pathStatus.status);
  1231. return (ERROR);
  1232. }
  1234.     return (OK);
  1235.     }
  1236. #if 0
  1237. /*******************************************************************************
  1238. *
  1239. * nfsDirRead - read entries from a directory
  1240. *
  1241. * RETURNS: OK or ERROR
  1242. */
  1244. LOCAL STATUS nfsDirRead
  1245.     (
  1246.     char *      hostName,
  1247.     nfs_fh *    pDirHandle,
  1248.     nfscookie   cookie,         /* hand this cookie to the server.  The cookie
  1249.                                  * marks a place in the directory where entries
  1250.                                  * are to be read from */
  1251.     unsigned    count,          /* number of bytes that nfs may return */
  1252.     readdirres *pReadDirRes     /* return the results of directory read here */
  1253.     )
  1254.     {
  1255.     readdirargs readDirArgs;
  1257.     if (nfsInit () != OK)
  1258. return (ERROR);
  1260.     bzero ((char *) &readDirArgs, sizeof (readdirargs));
  1261.     bcopy ((char *) pDirHandle, (char *) &readDirArgs.dir, sizeof (nfs_fh));
  1262.     bcopy (cookie, readDirArgs.cookie, sizeof (nfscookie));
  1263.     readDirArgs.count = count;
  1265.     bzero ((char *) pReadDirRes, sizeof (*pReadDirRes));
  1267.     if (nfsClientCall (hostName, NFS_PROGRAM, NFS_VERSION, NFSPROC_READDIR,
  1268.     xdr_readdirargs, (char *) &readDirArgs,
  1269.     xdr_readdirres, (char *) pReadDirRes) == ERROR)
  1270. {
  1271. return (ERROR);
  1272. }
  1274.     if (pReadDirRes->status != NFS_OK)
  1275. {
  1276. nfsErrnoSet (pReadDirRes->status);
  1277. return (ERROR);
  1278. }
  1280.     /* normally, the readdirres structure would be freed up here, but
  1281.      * the calling routine needs its information, so the calling routine
  1282.      * must call clntudp_freeres after calling nfsDirRead
  1283.      */
  1284.     return (OK);
  1285.     }
  1286. /*******************************************************************************
  1287. *
  1288. * nfsDirResFree - free the rcp readdirres result structure
  1289. *
  1290. * RETURNS: TRUE if successful, FALSE if error
  1291. */
  1293. LOCAL BOOL nfsDirResFree
  1294.     (
  1295.     readdirres *pReadDirRes
  1296.     )
  1297.     {
  1298.     return (clntudp_freeres (taskRpcStatics->nfsClientCache->client,
  1299.      xdr_readdirres, (caddr_t) pReadDirRes));
  1300.     }
  1301. #endif
  1302. /*******************************************************************************
  1303. *
  1304. * nfsDirReadOne - read one directory entry
  1305. *
  1306. * Read one directory entry on the host from the directory represented by
  1307. * the file handle *pDirHandle.  Update the DIR structure that is passed
  1308. * in and pointed to by pDir.
  1309. *
  1310. * NOTE:
  1311. * There is actually no way to tell the server we want only one entry.
  1312. * We only want one entry, but we have to provide a buffer for the maximum
  1313. * length filename, where the buffer size is specified in the "count" param
  1314. * to nfsDirRead.  The server will return as many entries as will fit in
  1315. * this buffer.  We will return the first entry to the caller and throw
  1316. * away the rest.  A subsequent call with the cookie of the previous
  1317. * entry will acquire the next entry, even though it may have been
  1318. * sent in previous call.
  1319. *
  1320. * In the future, we could cache several entries at a time and just return
  1321. * them to the caller, one at a time.
  1322. *
  1323. * RETURNS: OK, or ERROR if dir read fails,
  1324. *   returns ERROR but errno unchanged if EOF
  1325. *
  1326. * NOMANUAL
  1327. */
  1329. STATUS nfsDirReadOne
  1330.     (
  1331.     char *      hostName,       /* host name */
  1332.     nfs_fh *    pDirHandle,     /* file handle of directory */
  1333.     DIR *       pDir            /* ptr to DIR structure, return values here */
  1334.     )
  1335.     {
  1336.     readdirres   readRes;
  1337.     readdirargs  readDirArgs;
  1339.     bzero ((char *) &readRes, sizeof (readRes));
  1340.     
  1341.     if (nfsInit () != OK)
  1342. return (ERROR);
  1344.     bzero ((char *) &readDirArgs, sizeof (readdirargs));
  1345.     bcopy ((char *) pDirHandle, (char *) &readDirArgs.dir, sizeof (nfs_fh));
  1346.     bcopy ((char *) &pDir->dd_cookie, readDirArgs.cookie, sizeof (nfscookie));
  1348.     /*
  1349.     readDirArgs.count = sizeof (struct readdirres) + sizeof (struct entry) +
  1350. NAME_MAX;
  1351.     */
  1353.     /*
  1354.      For reasons yet unknown to me, the HP server expects the value of
  1355.      count to be AT LEAST 512 in order to successfully read directory files
  1356.      mounted from HP. Sun server does not have this limitation.
  1357.     */
  1358.     readDirArgs.count = READDIR_MAXLEN;
  1360.     if (nfsClientCall (hostName, NFS_PROGRAM, NFS_VERSION, NFSPROC_READDIR,
  1361. xdr_readdirargs, (char *) &readDirArgs,
  1362. xdr_readdirres, (char *) &readRes) == ERROR)
  1363. {
  1364. return (ERROR);
  1365. }
  1367.     if (readRes.status != NFS_OK)
  1368. {
  1369. nfsErrnoSet (readRes.status);
  1370. return (ERROR);
  1371. }
  1373.     if (readRes.readdirres_u.reply.entries == NULL && 
  1374. readRes.readdirres_u.reply.eof)
  1375.         {
  1376. /* No entries were returned - must be end of file.
  1377.  * (Note that xdr_readdirresOne hack discarded EOF flag.)
  1378.          * Return ERROR, but don't alter errno because there is no real error.
  1379.  * (Thank you POSIX for this lovely, clear construct.)
  1380.  */
  1382. /*
  1383.  * Need to set errno to OK, otherwise ls will print out an error
  1384.  * message at the end of every directory listing.
  1385.  */
  1387. errnoSet (OK);
  1388. return (ERROR);
  1389. }
  1392.     strcpy (pDir->dd_dirent.d_name,
  1393.     readRes.readdirres_u.reply.entries[0].name);
  1394.     
  1395.     /* update caller's cookie */
  1397.     bcopy (readRes.readdirres_u.reply.entries[0].cookie,
  1398.    (char *) &pDir->dd_cookie, sizeof (nfscookie));
  1400.     /* free the memory used by RPC */
  1402.     clnt_freeres (taskRpcStatics->nfsClientCache->client, xdr_readdirres,
  1403.   (caddr_t) &readRes);
  1405.     return (OK);
  1406.     }
  1407. /*******************************************************************************
  1408. *
  1409. * nfsFileAttrGet - get file attributes and put them in a stat structure
  1410. *
  1411. * NOMANUAL
  1412. */
  1414. void nfsFileAttrGet
  1415.     (
  1416.     FAST fattr *        pFattr, /* ptr to nfs file attributes */
  1417.     FAST struct stat *  pStat   /* ptr to stat struct, return attrs here */
  1418.     )
  1419.     {
  1420.     /*
  1421.      * INTERNAL:  block information is kept in the fattr
  1422.      * structure, but we decided not to hold it in the
  1423.      * stat structure.  It could be added later.
  1424.      */
  1426.     pStat->st_ino         = (ULONG) pFattr->fileid;
  1427.     pStat->st_mode        = pFattr->mode;
  1428.     pStat->st_nlink       = pFattr->nlink;
  1429.     pStat->st_uid         = pFattr->uid;
  1430.     pStat->st_gid         = pFattr->gid;
  1431.     pStat->st_rdev        = 0;                          /* unused */
  1432.     pStat->st_size        = pFattr->size;
  1433.     pStat->st_atime       = pFattr->atime.seconds;
  1434.     pStat->st_mtime       = pFattr->mtime.seconds;
  1435.     pStat->st_ctime       = pFattr->ctime.seconds;
  1436.     pStat->st_blksize     = 0;
  1437.     pStat->st_blocks      = 0;
  1438.     }
  1440. /******************************************************************************
  1441. *
  1442. * nfsFsAttrGet - get file system attributes across NFS
  1443. *
  1444. * This routine does an FSTATFS across NFS.
  1445. *
  1446. * NOMANUAL
  1447. */
  1449. STATUS nfsFsAttrGet
  1450.     (
  1451.     char* pHostName,                         /* host name */
  1452.     nfs_fh* pDirHandle,                      /* file handle of directory */
  1453.     struct statfs* pArg                      /* return value here */
  1454.     )
  1455.     {
  1457.     int status;
  1458.     statfsres retStat;
  1460.     status = nfsClientCall (pHostName,
  1461.                             NFS_PROGRAM, NFS_VERSION, NFSPROC_STATFS,
  1462.                             xdr_fhandle, (char *)pDirHandle,
  1463.                             xdr_statfsres, (char *)&retStat);
  1464.     
  1465.     if (retStat.status != NFS_OK)
  1466.         {
  1467.         nfsErrnoSet (retStat.status);
  1468.         return (ERROR);
  1469.         }
  1471.     pArg->f_type = 0;
  1472.     pArg->f_bsize = retStat.statfsres_u.reply.bsize;
  1473.     pArg->f_blocks = retStat.statfsres_u.reply.blocks;
  1474.     pArg->f_bfree = retStat.statfsres_u.reply.bfree;
  1475.     pArg->f_bavail = retStat.statfsres_u.reply.bavail;
  1476.     
  1477.     /* The following are undefined for NFS under vxWorks and
  1478.      * so are set to 0.
  1479.      */
  1480.     pArg->f_files = 0;    /* total file nodes in file system */
  1481.     pArg->f_ffree = 0;    /* free file nodes in fs */
  1484.     clnt_freeres (taskRpcStatics->nfsClientCache->client, xdr_statfsres,
  1485.                   (caddr_t)&retStat);
  1487.     return (OK);
  1488.     }
  1490. /*******************************************************************************
  1491. *
  1492. * nfsDeleteHook - cleanup NFS data structures
  1493. */
  1495. LOCAL void nfsDeleteHook
  1496.     (
  1497.     WIND_TCB *pTcb
  1498.     )
  1499.     {
  1500. #ifdef  _WRS_VXWORKS_5_X
  1501.     FAST RPC_STATICS *pRPCModList = pTcb->pRPCModList;
  1502. #else
  1503.     FAST RPC_STATICS *pRPCModList = pTcb->pLcb->pRPCModList;
  1504. #endif /*  _WRS_VXWORKS_5_X */
  1505.     
  1506.     if (pRPCModList != NULL)
  1507. {
  1508. nfsClientCacheCleanUp (pRPCModList->nfsClientCache);
  1509. if (pRPCModList->nfsClientCache != NULL)
  1510.     {
  1511.     KHEAP_FREE((char *) pRPCModList->nfsClientCache);
  1512.     pRPCModList->nfsClientCache = NULL;
  1513.     }
  1514. }
  1515.     }
  1516. /*******************************************************************************
  1517. *
  1518. * nfsInit - initialize NFS
  1519. *
  1520. * nfsInit must be called by a task before it uses NFS.
  1521. * It is okay to call this routine more than once.
  1522. *
  1523. * RETURNS: OK or ERROR
  1524. *
  1525. * NOMANUAL
  1526. */
  1528. LOCAL STATUS nfsInit (void)
  1529.     {
  1530.     /* make sure rpc is initialized for this task */
  1532.     if (rpcTaskInit () == ERROR)
  1533. return (ERROR);
  1535.     /* if first nfs use by this task, initialize nfs stuff for this task */
  1537.     if (taskRpcStatics->nfsClientCache == NULL)
  1538. {
  1539. /* if this the very first use of NFS in the system, add nfsDeleteHook */
  1541. if (!nfsInstalled)
  1542.     {
  1543.     if (taskDeleteHookAdd ((FUNCPTR)nfsDeleteHook) == ERROR)
  1544. return (ERROR);
  1546.     nfsInstalled = TRUE;
  1547.     }
  1550. /* allocate nfs specific stuff for this task */
  1552. taskRpcStatics->nfsClientCache =
  1553.     (NFS_MODULE_STATICS *) KHEAP_ALLOC(sizeof (NFS_MODULE_STATICS));
  1555. if (taskRpcStatics->nfsClientCache == NULL)
  1556.     return (ERROR);
  1557.         bzero ((char *)taskRpcStatics->nfsClientCache,
  1558.             sizeof (NFS_MODULE_STATICS));
  1559. }
  1561.     return (OK);
  1562.     }
  1563. /*******************************************************************************
  1564. *
  1565. * nfsClientCacheCleanUp - clean up the NFS client cache
  1566. *
  1567. * This routine is used to free up structures that are part of a valid
  1568. * NFS client cache.  The client cache is marked as invalid.
  1569. */
  1571. LOCAL void nfsClientCacheCleanUp
  1572.     (
  1573.     FAST NFS_MODULE_STATICS *pClientCache       /* pointer to client cache */
  1574.     )
  1575.     {
  1576.     if ((pClientCache != NULL) && (pClientCache->valid))
  1577. {
  1578. pClientCache->valid = FALSE;
  1580. /* close client socket */
  1582. if (pClientCache->socket > 0)
  1583.     {
  1584. #if 0
  1585.     close (pClientCache->socket);
  1586. #endif
  1587.     pClientCache->socket = NONE;
  1588.     }
  1590. pClientCache->oldhost[0] = EOS;
  1593. /* destroy authorization and client */
  1595. if (pClientCache->client != NULL)
  1596.     {
  1597.     if (pClientCache->client->cl_auth != NULL)
  1598. {
  1599. auth_destroy (pClientCache->client->cl_auth);
  1600. pClientCache->client->cl_auth = NULL;
  1601. }
  1603.     clnt_destroy (pClientCache->client);
  1604.     pClientCache->client = NULL;
  1605.     }
  1606. }
  1607.     }
  1608. /*******************************************************************************
  1609. *
  1610. * nfsClientCacheSetUp - set up the NFS client cache
  1611. *
  1612. * This routine is used to set up structures that are part of a valid
  1613. * NFS client cache.  If successful, the client cache is marked as valid.
  1614. */
  1616. LOCAL STATUS nfsClientCacheSetUp
  1617.     (
  1618.     FAST NFS_MODULE_STATICS *ms,        /* pointer to client cache */
  1619.     char *      host,                   /* server's host name */
  1620.     u_int       prognum,                /* RPC program number */
  1621.     u_int       versnum                 /* RPC version number */
  1622.     )
  1623.     {
  1624.     int hp; /* host's inet address */
  1625.     struct sockaddr_in server_addr;
  1626.     struct timeval timeout;
  1627.     int optval;
  1629.     /* check if cached client is appropriate */
  1631.     if (ms->valid && ms->oldprognum == prognum && ms->oldversnum == versnum
  1632. && strcmp (ms->oldhost, host) == 0 && ms->authCount == nfsAuthCount)
  1633. {
  1634. return (OK); /* reuse old client */
  1635.      }
  1638.     /* get rid of any old client and create new one */
  1640.     nfsClientCacheCleanUp (ms);
  1642.     if ((hp = hostGetByName (host)) == ERROR)
  1643. return (ERROR);
  1645.     timeout.tv_sec  = nfsReXmitSec;
  1646.     timeout.tv_usec = nfsReXmitUSec;
  1648.     server_addr.sin_addr.s_addr = hp;
  1649.     server_addr.sin_family = AF_INET;
  1650.     server_addr.sin_port = htons (0);
  1652.     ms->socket = RPC_ANYSOCK;
  1654.     if ((ms->client = clntudp_create(&server_addr, prognum, versnum,
  1655.      timeout, &ms->socket)) == NULL)
  1656. {
  1657. server_addr.sin_port = htons (NFS_PORT);
  1658. ms->client = clntudp_create (&server_addr, prognum, versnum,
  1659.      timeout, &ms->socket);
  1660. if (ms->client == NULL)
  1661.     return (ERROR);
  1662. }
  1664.     optval = nfsSockBufSize;
  1665.     if ((setsockopt (ms->socket, SOL_SOCKET, SO_SNDBUF, (char *)&optval,
  1666.      sizeof (optval)) == ERROR)
  1667. || (setsockopt (ms->socket, SOL_SOCKET, SO_RCVBUF, (char *)&optval,
  1668. sizeof (optval)) == ERROR))
  1669. {
  1670. nfsClientCacheCleanUp (ms);
  1671. return (ERROR);
  1672. }
  1674.     ms->client->cl_auth = authunix_create (nfsAuthUnix.machname,
  1675.    nfsAuthUnix.uid, nfsAuthUnix.gid,
  1676.    nfsAuthUnix.len,
  1677.    nfsAuthUnix.aup_gids);
  1678.     if (ms->client->cl_auth == NULL)
  1679. {
  1680. nfsClientCacheCleanUp (ms);
  1681. errnoSet (S_nfsLib_NFS_AUTH_UNIX_FAILED);
  1682. return (ERROR);
  1683. }
  1685.     ms->oldprognum = prognum;
  1686.     ms->oldversnum = versnum;
  1687.     ms->authCount  = nfsAuthCount;
  1689.     (void) strcpy (ms->oldhost, host);
  1691.     ms->valid = TRUE;
  1693.     return (OK);
  1694.     }
  1695. /*******************************************************************************
  1696. *
  1697. * nfsClientCall - make an NFS request to the server using RPC
  1698. *
  1699. * This is the routine which does the actual RPC call to the server.
  1700. * All NFS routines which communicate with the file server use this routine.
  1701. *
  1702. * RETURNS:  OK | ERROR
  1703. */
  1705. LOCAL STATUS nfsClientCall
  1706.     (
  1707.     char *      host,           /* server's host name */
  1708.     u_int       prognum,        /* RPC program number */
  1709.     u_int       versnum,        /* RPC version number */
  1710.     u_int       procnum,        /* RPC procedure number */
  1711.     xdrproc_t   inproc,         /* xdr routine for args */
  1712.     char *      in,
  1713.     xdrproc_t   outproc,        /* xdr routine for results */
  1714.     char *      out
  1715.     )
  1716.     {
  1717.     nfstime tottimeout;
  1718.     enum clnt_stat clientStat;
  1719.     FAST NFS_MODULE_STATICS *ms;
  1721.     if (nfsInit () != OK)
  1722. return (ERROR);
  1723.  
  1724.     ms = taskRpcStatics->nfsClientCache;
  1726.     /* get an appropriate client in the cache */
  1728.     if (nfsClientCacheSetUp (ms, host, prognum, versnum) != OK)
  1729. return (ERROR);
  1731.     /* set time to allow results to come back */
  1733.     tottimeout.seconds  = nfsTimeoutSec;
  1734.     tottimeout.useconds = nfsTimeoutUSec;
  1736.     clientStat = clnt_call (ms->client, procnum, inproc, in, outproc, out,
  1737.     tottimeout);
  1739.     if (clientStat != RPC_SUCCESS)
  1740. {
  1741. /* XXX this should be more gracefull */
  1743. nfsClientCacheCleanUp (ms);
  1744. rpcClntErrnoSet (clientStat);
  1745. return (ERROR);
  1746. }
  1748.     return (OK);
  1749.     }
  1750. /*******************************************************************************
  1751. *
  1752. * nfsClientClose - close the NFS client socket and associated structures
  1753. *
  1754. * NOMANUAL
  1755. */
  1757. void nfsClientClose (void)
  1758.     {
  1759.     if (taskRpcStatics != NULL)
  1760. nfsClientCacheCleanUp (taskRpcStatics->nfsClientCache);
  1761.     }
  1762. /*******************************************************************************
  1763. *
  1764. * nfsMountListPrint - prints a list of mount entries
  1765. */
  1767. LOCAL void nfsMountListPrint
  1768.     (
  1769.     FAST mountlist pMountList
  1770.     )
  1771.     {
  1772.     while (pMountList)
  1773. {
  1774. printf ("%s:%sn", pMountList->ml_hostname, pMountList->ml_directory);
  1775. pMountList = pMountList->ml_next;
  1776. }
  1777.     }
  1778. /*******************************************************************************
  1779. *
  1780. * nfsGroupsPrint - print a list of groups
  1781. */
  1783. LOCAL void nfsGroupsPrint
  1784.     (
  1785.     FAST groups pGroup
  1786.     )
  1787.     {
  1788.     while (pGroup != NULL)
  1789. {
  1790. printf ("%s ", pGroup->gr_name);
  1791. pGroup = pGroup->gr_next;
  1792. }
  1793.     }
  1794. /*******************************************************************************
  1795. *
  1796. * nfsExportPrint - prints a list of exported file systems on a host
  1797. */
  1799. LOCAL void nfsExportPrint
  1800.     (
  1801.     FAST exports pExport
  1802.     )
  1803.     {
  1804.     while (pExport != NULL)
  1805. {
  1806. printf ("%-25s ", pExport->ex_dir);
  1807. nfsGroupsPrint (pExport->ex_groups);
  1808. printf ("n");
  1809. pExport = pExport->ex_next;
  1810. }
  1811.     }
  1812. /*******************************************************************************
  1813. *
  1814. * nfsErrnoSet - set NFS status
  1815. *
  1816. * nfsErrnoSet calls errnoSet with the given "nfs stat" or'd with the
  1817. * NFS status prefix.
  1818. */
  1820. LOCAL void nfsErrnoSet
  1821.     (
  1822.     enum nfsstat status
  1823.     )
  1824.     {
  1825.     errnoSet (M_nfsStat | (int) status);
  1826.     }
  1827. /*******************************************************************************
  1828. *
  1829. * nfsAuthUnixPrompt - modify the NFS UNIX authentication parameters
  1830. *
  1831. * This routine allows
  1832. * UNIX authentication parameters to be changed from the shell.
  1833. * The user is prompted for each parameter, which can be changed
  1834. * by entering the new value next to the current one.
  1835. *
  1836. * EXAMPLE
  1837. * .CS
  1838. *    -> nfsAuthUnixPrompt
  1839. *    machine name:   yuba
  1840. *    user ID:        2001 128
  1841. *    group ID:       100
  1842. *    num of groups:  1 3
  1843. *    group #1:        100 100
  1844. *    group #2:        0 120
  1845. *    group #3:        0 200
  1846. *    value = 3 = 0x3
  1847. * .CE
  1848. *
  1849. * SEE ALSO: nfsAuthUnixShow(), nfsAuthUnixSet(), nfsAuthUnixGet(), nfsIdSet()
  1850. */
  1852. void nfsAuthUnixPrompt (void)
  1853.     {
  1854.     char machname [AUTH_UNIX_FIELD_LEN];/* host name where client is */
  1855.     int uid; /* client's UNIX effective uid */
  1856.     int gid; /* client's current group ID */
  1857.     int len; /* element length of aup_gids */
  1858.     int aup_gids [MAX_GRPS]; /* array of groups user is in */
  1859.     int ix;
  1861.     nfsAuthUnixGet (machname, &uid, &gid, &len, aup_gids);
  1863.     promptParamString ("machine name:  ", machname, sizeof (machname));
  1864.     promptParamNum ("user ID:       ", &uid, 8, "%d ");
  1865.     promptParamNum ("group ID:      ", &gid, 8, "%d ");
  1866.     promptParamNum ("num of groups: ", &len, 8, "%d ");
  1867.     for (ix = 0; ix < len; ix++)
  1868. {
  1869. printf ("group #%d:       ", ix + 1);
  1870. promptParamNum ("", &aup_gids [ix], 8, "%d ");
  1871. }
  1872.     nfsAuthUnixSet (machname, uid, gid, len, aup_gids);
  1873.     }
  1874. /*******************************************************************************
  1875. *
  1876. * nfsAuthUnixShow - display the NFS UNIX authentication parameters
  1877. *
  1878. * This routine displays the parameters set by nfsAuthUnixSet() or
  1879. * nfsAuthUnixPrompt().
  1880. *
  1881. * EXAMPLE:
  1882. * .CS
  1883. *    -> nfsAuthUnixShow
  1884. *    machine name = yuba
  1885. *    user ID      = 2001
  1886. *    group ID     = 100
  1887. *    group [0]    = 100
  1888. *    value = 1 = 0x1
  1889. * .CE
  1890. *
  1891. * RETURNS: N/A
  1892. *
  1893. * SEE ALSO: nfsAuthUnixPrompt(), nfsAuthUnixSet(), nfsAuthUnixGet(), nfsIdSet()
  1894. */
  1896. void nfsAuthUnixShow (void)
  1897.     {
  1898.     char machname [AUTH_UNIX_FIELD_LEN]; /* host name where client is */
  1899.     int uid; /* client's UNIX effective uid */
  1900.     int gid; /* client's current group ID */
  1901.     int len; /* element length of aup_gids */
  1902.     int aup_gids [MAX_GRPS]; /* array of groups user is in */
  1903.     int ix;
  1905.     nfsAuthUnixGet (machname, &uid, &gid, &len, aup_gids);
  1907.     printf ("machine name = %sn", machname);
  1908.     printf ("user ID      = %dn", uid);
  1909.     printf ("group ID     = %dn", gid);
  1910.     for (ix = 0; ix < len; ix++)
  1911. printf ("group [%d]    = %dn", ix, aup_gids [ix]);
  1912.     }
  1913. /*******************************************************************************
  1914. *
  1915. * nfsAuthUnixSet - set the NFS UNIX authentication parameters
  1916. *
  1917. * This routine sets UNIX authentication parameters.
  1918. * It is initially called by usrNetInit().
  1919. * `machname' should be set with the name of the mounted system (i.e. the target
  1920. * name itself) to distinguish hosts from hosts on a NFS network.
  1921. *
  1922. * RETURNS: N/A
  1923. *
  1924. * SEE ALSO: nfsAuthUnixPrompt(), nfsAuthUnixShow(), nfsAuthUnixGet(), 
  1925. * nfsIdSet()
  1926. * 
  1927. * 
  1928. *
  1929. */
  1931. void nfsAuthUnixSet
  1932.     (
  1933.     char *machname,     /* host machine        */
  1934.     int uid,            /* user ID             */
  1935.     int gid,            /* group ID            */
  1936.     int ngids,          /* number of group IDs */
  1937.     int *aup_gids       /* array of group IDs  */
  1938.     )
  1939.     {
  1940.     int ix;
  1942.     taskLock ();
  1944.     (void) strcpy (nfsAuthUnix.machname, machname);
  1945.     nfsAuthUnix.uid = uid;
  1946.     nfsAuthUnix.gid = gid;
  1947.     nfsAuthUnix.len = (ngids < MAX_GRPS ? ngids : MAX_GRPS);
  1948.     for (ix = 0; ix < ngids; ix++)
  1949. nfsAuthUnix.aup_gids [ix] = aup_gids [ix];
  1951.     /* Cached client authentications are out of date now.
  1952.      * Bump auth count so clients will be rebuilt with new auth,
  1953.      * next time the client transport is used.
  1954.      */
  1956.     nfsAuthCount++;
  1958.     taskUnlock ();
  1959.     }
  1960. /*******************************************************************************
  1961. *
  1962. * nfsAuthUnixGet - get the NFS UNIX authentication parameters
  1963. *
  1964. * This routine gets the previously set UNIX authentication values.
  1965. *
  1966. * RETURNS: N/A
  1967. *
  1968. * SEE ALSO: nfsAuthUnixPrompt(), nfsAuthUnixShow(), nfsAuthUnixSet(), 
  1969. * nfsIdSet()
  1970. */
  1972. void nfsAuthUnixGet
  1973.     (
  1974.     char *machname,     /* where to store host machine        */
  1975.     int *pUid,          /* where to store user ID             */
  1976.     int *pGid,          /* where to store group ID            */
  1977.     int *pNgids,        /* where to store number of group IDs */
  1978.     int *gids           /* where to store array of group IDs  */
  1979.     )
  1980.     {
  1981.     int ix;
  1983.     (void) strcpy (machname, nfsAuthUnix.machname);
  1984.     *pUid   = nfsAuthUnix.uid;
  1985.     *pGid   = nfsAuthUnix.gid;
  1986.     *pNgids = nfsAuthUnix.len;
  1988.     for (ix = 0; ix < nfsAuthUnix.len; ix++)
  1989. gids [ix] = nfsAuthUnix.aup_gids [ix];
  1990.     }
  1991. /*******************************************************************************
  1992. *
  1993. * nfsIdSet - set the ID number of the NFS UNIX authentication parameters
  1994. *
  1995. * This routine sets only the UNIX authentication user ID number.
  1996. * For most NFS permission needs, only the user ID needs to be changed.
  1997. * Set <uid> to the user ID on the NFS server.
  1998. *
  1999. * RETURNS: N/A
  2000. *
  2001. * SEE ALSO: nfsAuthUnixPrompt(), nfsAuthUnixShow(), nfsAuthUnixSet(),
  2002. * nfsAuthUnixGet()
  2003. * 
  2004. */
  2006. void nfsIdSet
  2007.     (
  2008.     int uid             /* user ID on host machine */
  2009.     )
  2010.     {
  2011.     taskLock ();
  2013.     nfsAuthUnix.uid = uid;
  2015.     /* Cached client authentications are out of date now.
  2016.      * Bump auth count so clients will be rebuilt with new auth,
  2017.      * next time the client transport is used.
  2018.      */
  2020.     nfsAuthCount++;
  2022.     taskUnlock ();
  2023.     }
  2025. /*******************************************************************************
  2026. *
  2027. * printClear - print string with '?' for unprintable characters
  2028. */
  2030. LOCAL void printClear
  2031.     (
  2032.     FAST char *param
  2033.     )
  2034.     {
  2035.     FAST char ch;
  2037.     while ((ch = *(param++)) != EOS)
  2038. printf ("%c", (isascii ((UINT)ch) && isprint ((UINT)ch)) ? ch : '?');
  2039.     }
  2040. /*******************************************************************************
  2041. *
  2042. * promptParamString - prompt the user for a string parameter
  2043. *
  2044. * - carriage return leaves the parameter unmodified;
  2045. * - "." clears the parameter (null string).
  2046. */
  2048. LOCAL void promptParamString
  2049.     (
  2050.     char *msg,
  2051.     char *param,
  2052.     int fieldWidth
  2053.     )
  2054.     {
  2055.     int ix;
  2056.     char buf [100];
  2058.     FOREVER
  2059. {
  2060. printf ("%s ", msg);
  2061. printClear (param);
  2062. printf (" ");
  2064. ix = fioRdString (STD_IN, buf, sizeof (buf));
  2065. if (ix < fieldWidth)
  2066.     break;
  2067. printf ("too big - maximum field width = %d.n", fieldWidth);
  2068. }
  2070.     if (ix == 1)
  2071. return; /* just CR; leave field unchanged */
  2073.     if (buf[0] == '.')
  2074. {
  2075. param [0] = EOS; /* just '.'; make empty field */
  2076. return;
  2077. }
  2079.     (void) strcpy (param, buf); /* update parameter */
  2080.     }
  2081. /*******************************************************************************
  2082. *
  2083. * promptParamNum - prompt the user for a parameter
  2084. *
  2085. * - carriage return leaves the parameter unmodified;
  2086. * - "." clears the parameter (0).
  2087. */
  2089. LOCAL void promptParamNum
  2090.     (
  2091.     char *msg,
  2092.     int *pParam,
  2093.     int fieldWidth,
  2094.     char *format
  2095.     )
  2096.     {
  2097.     int ix;
  2098.     char buf [100];
  2100.     FOREVER
  2101. {
  2102. (void) strcpy (buf, "%s ");
  2103. (void) strcat (buf, format);
  2105. printf (buf, msg, *pParam);
  2107. ix = fioRdString (STD_IN, buf, sizeof (buf));
  2108. if (ix < fieldWidth)
  2109.     break;
  2110. printf ("too big - maximum field width = %d.n", fieldWidth);
  2111. }
  2113.     if (ix == 1)
  2114. return; /* just CR; leave field unchanged */
  2116.     if (buf[0] == '.')
  2117. {
  2118. pParam = 0; /* just '.'; make empty field */
  2119. return;
  2120. }
  2122.     (void) sscanf (buf, format, pParam); /* scan field */
  2123.     }