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

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

VxWorks

开发平台：

C/C++

nfsdLib.c：源码内容
  1. /* nfsdLib.c - Network File System (NFS) server library */
  3. /* Copyright 1994 - 2001 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01s,07may02,kbw  man page edits
  10. 01r,06nov01,vvv  made max path length configurable (SPR #63551)
  11. 01q,15oct01,rae  merge from truestack ver 01r, base 01o (cleanup)
  12. 01p,21jun00,rsh  upgrade to dosFs 2.0
  13. 01o,05apr00,zl   fixed the fix in 01m (use retVal)
  14. 01m,15nov98,rjc  modifications for dosfs2 compatibility.
  15. 01o,03dec00,ijm  increased nfsdStackSize (SPR# 22650).  Corrected return
  16.  value if file exists (SPR# 31536)
  17. 01n,16mar99,spm  recovered orphaned code from tor1_0_1.sens1_1 (SPR #25770)
  18. 01m,06oct98,sgv  fixed nfsproc_create_2 to return NFSERR_EXIST when the file
  19.                  exists
  20. 01m,14mar99,jdi  doc: removed refs to config.h and/or configAll.h (SPR 25663).
  21. 01l,11mar97,dvs  added test for udp in nfsd (SPR #8183).
  22. 01k,10feb97,dbt  close file descriptors before leaving in nfsproc_setattr_2 () 
  23.  routine before leaving (SPR #6615).
  24. 01j,05jul96,ms   fixed SPR 6579 - only NFSPROC_CREATE if file doen't exist.
  25. 01i,27feb95,jdi  doc: changed dosFsMode to dosFsFileMode (doc only) (SPR 4085).
  26. 01h,11feb95,jdi  doc format repair.
  27. 01g,24jan95,jdi  doc cleanup.
  28. 01f,08sep94,jmm  final changes
  29. 01e,11may94,jmm  integrated Roland's doc changes
  30. 01d,25apr94,jmm  added nfsdFsReadOnly(), all routines that write now call it 1st
  31.                  added module documentation
  32. 01c,21apr94,jmm  reordered routines, documentation cleanup
  33. 01b,20apr94,jmm  formatting cleanup, nfsdFhNtoh and Hton calls fixed
  34. 01a,07mar94,jmm  written
  35. */
  37. /*
  38. DESCRIPTION
  39. This library is an implementation of version 2 of the Network File
  40. System Protocol Specification as defined in RFC 1094.  It is
  41. closely connected with version 1 of the mount protocol, also defined
  42. in RFC 1094 and implemented in turn by mountLib.
  44. The NFS server is initialized by calling nfsdInit().  
  45. This is done automatically at boot time if INCLUDE_NFS_SERVER is defined.
  47. Currently, only the dosFsLib file system is supported.
  48. File systems are exported with the nfsExport() call.
  50. To create and export a file system, define INCLUDE_NFS_SERVER and rebuild
  51. VxWorks.
  53. To export VxWorks file systems via NFS, you need facilities from both
  54. this library and from mountLib.  To include both, define
  55. INCLUDE_NFS_SERVER and rebuild VxWorks.
  57. Use the mountLib routine nfsExport() to export file systems.  For an
  58. example, see the manual page for mountLib.
  60. VxWorks does not normally provide authentication services for NFS
  61. requests, and the DOS file system does not provide file permissions.
  62. If you need to authenticate incoming requests, see the documentation
  63. for nfsdInit() and mountdInit() for information about authorization
  64. hooks.
  66. The following requests are accepted from clients.  For details of
  67. their use, see RFC 1094, "NFS: Network File System Protocol
  68. Specification."
  70. .TS
  71. center,tab(|);
  72. lf3 lf3
  73. l n.
  74. Procedure Name        |  Procedure Number
  75. _
  76.  NFSPROC_NULL         |  0
  77.  NFSPROC_GETATTR      |  1
  78.  NFSPROC_SETATTR      |  2
  79.  NFSPROC_ROOT         |  3
  80.  NFSPROC_LOOKUP       |  4
  81.  NFSPROC_READLINK     |  5
  82.  NFSPROC_READ         |  6
  83.  NFSPROC_WRITE        |  8
  84.  NFSPROC_CREATE       |  9
  85.  NFSPROC_REMOVE       |  10
  86.  NFSPROC_RENAME       |  11
  87.  NFSPROC_LINK         |  12
  88.  NFSPROC_SYMLINK      |  13
  89.  NFSPROC_MKDIR        |  14
  90.  NFSPROC_RMDIR        |  15
  91.  NFSPROC_READDIR      |  16
  92.  NFSPROC_STATFS       |  17
  93. .TE
  95. AUTHENTICATION AND PERMISSIONS
  96. Currently, no authentication is done on NFS requests.  nfsdInit()
  97. describes the authentication hooks that can be added should
  98. authentication be necessary.
  100. Note that the DOS file system does not provide information about ownership
  101. or permissions on individual files.  Before initializing a dosFs file
  102. system, three global variables--`dosFsUserId', `dosFsGroupId', and
  103. `dosFsFileMode'--can be set to define the user ID, group ID, and permissions
  104. byte for all files in all dosFs volumes initialized after setting these
  105. variables.  To arrange for different dosFs volumes to use different user
  106. and group ID numbers, reset these variables before each volume is
  107. initialized.  See the manual entry for dosFsLib for more information.
  109. TASKS
  110. Several NFS tasks are created by nfsdInit().  They are:
  111. .iP tMountd 11 3
  112. The mount daemon, which handles all incoming mount requests.
  113. This daemon is created by mountdInit(), which is automatically
  114. called from nfsdInit().
  115. .iP tNfsd
  116. The NFS daemon, which queues all incoming NFS requests.
  117. .iP tNfsdX
  118. The NFS request handlers, which dequeues and processes all incoming
  119. NFS requests.
  120. .LP
  122. Performance of the NFS file system can be improved by increasing the
  123. number of servers specified in the nfsdInit() call, if there are
  124. several different dosFs volumes exported from the same target system.
  125. The spy() utility can be called to determine whether this is useful for
  126. a particular configuration.
  128. INTERNAL:
  129. All of the nfsproc_*_2 routines follow the RPC naming convention
  130. rather than the WRS naming convention.  They return a pointer to
  131. malloced space, which is freed by nfsdRequestProcess().
  133. */
  135. #include "vxWorks.h"
  136. #include "dirent.h"
  137. #include "dosFsLib.h"
  138. #include "errno.h"
  139. #include "fcntl.h"
  140. #include "ioLib.h"
  141. #include "limits.h"
  142. #include "mountLib.h"
  143. #include "msgQLib.h"
  144. #include "netinet/in.h"
  145. #include "nfsdLib.h"
  146. #include "pathLib.h"
  147. #include "rpcLib.h"
  148. #include "rpc/pmap_clnt.h"
  149. #include "rpc/rpc.h"
  150. #include "semLib.h"
  151. #include "sockLib.h"
  152. #include "stdio.h"
  153. #include "stdio.h"
  154. #include "stdlib.h"
  155. #include "string.h"
  156. #include "sys/socket.h"
  157. #include "sys/stat.h"
  158. #include "sys/types.h"
  159. #include "taskLib.h"
  160. #include "tickLib.h"
  161. #include "utime.h"
  162. #include "xdr_nfs.h"
  163. #include "iosLib.h"
  164. #include "private/nfsHashP.h"
  165. #include "memPartLib.h"
  167. /* defines */
  168. #define NAME_LEN               40
  169. #if !defined(S_dosFsLib_FILE_EXISTS)
  170. #define S_dosFsLib_FILE_EXISTS  (S_dosFsLib_FILE_ALREADY_EXISTS)
  171. #endif
  172. #define QLEN_PER_SRVR           10
  174. #ifdef __GNUC__
  175. # ifndef alloca
  176. #  define alloca __builtin_alloca
  177. # endif
  178. #endif
  180. /* DATA STRUCTURES */
  182. /* svcudp_data is copied directly from svc_udp.c - DO NOT MODIFY */
  184. struct svcudp_data {
  185. u_int   su_iosz; /* byte size of send.recv buffer */
  186. u_long su_xid; /* transaction id */
  187. XDR su_xdrs; /* XDR handle */
  188. char su_verfbody[MAX_AUTH_BYTES]; /* verifier body */
  189. char   *su_cache; /* cached data, NULL if no cache - 4.0 */
  190. };
  192. typedef struct
  193.     {
  194.     FUNCPTR            routine;   /* nfsproc_*_2 routine to call */
  195.     int                procNum;   /* NFS procedure number */
  196.     NFSD_ARGUMENT *    argument;  /* argument to pass to nfsproc_*_2 */
  197.     FUNCPTR            xdrArg;   /* XDR function pointer to convert argument */
  198.     FUNCPTR            xdrResult; /* XDR function pointer to convert result */
  199.     struct sockaddr_in sockAddr;  /* Address of the client socket */
  200.     int                xid;   /* RPC XID of client request */
  201.     int                socket;   /* Socket to use to send reply */
  202.     } NFS_Q_REQUEST;
  204. /* IMPORTS */
  206. IMPORT int nfsMaxPath;           /* Max. file path length */
  208. /* GLOBALS */
  210. int nfsdStackSize = 14000;   /* Default stack size for NFS processes */
  211. int nfsdNServers = 4;   /* Default number of NFS servers */
  212. int nfsdPriorityDefault = 55;   /* Default priority of the NFS server */
  213. int nfsdNFilesystemsDefault = 10; /* Default max. num. filesystems */
  215. /* LOCALS */
  217. LOCAL NFS_SERVER_STATUS nfsdServerStatus;    /* Status of the NFS server */
  218. LOCAL FUNCPTR           nfsdAuthHook = NULL; /* Authentication hook */
  219. MSG_Q_ID                nfsRequestQ;         /* Message Q for NFS requests */
  221. /* forward LOCAL functions */
  223. LOCAL void nfsdRequestEnqueue (struct svc_req * rqstp, SVCXPRT * transp);
  224. LOCAL int nfsdFsReadOnly (NFS_FILE_HANDLE * fh);
  226. /******************************************************************************
  227. *
  228. * nfsdInit - initialize the NFS server
  229. * 
  230. * This routine initializes the NFS server.  <nServers>  specifies the number of
  231. * tasks to be spawned to handle NFS requests.  <priority> is the priority that
  232. * those tasks will run at.  <authHook> is a pointer to an authorization
  233. * routine.  <mountAuthHook> is a pointer to a similar routine, passed to
  234. * mountdInit().  <options> is provided for future expansion.
  235. * 
  236. * Normally, no authorization is performed by either mountd or nfsd.
  237. * If you want to add authorization, set <authHook> to a
  238. * function pointer to a routine declared as follows:
  239. * .CS
  240. * nfsstat routine
  241. *     (
  242. *     int                progNum, /@ RPC program number @/
  243. *     int                versNum, /@ RPC program version number @/
  244. *     int                procNum, /@ RPC procedure number @/
  245. *     struct sockaddr_in clientAddr,    /@ address of the client @/
  246. *     NFSD_ARGUMENT *    nfsdArg    /@ argument of the call @/
  247. *     )
  248. * .CE
  249. * 
  250. * The <authHook> routine should return NFS_OK if the request is authorized,
  251. * and NFSERR_ACCES if not.  (NFSERR_ACCES is not required; any legitimate
  252. * NFS error code can be returned.)
  253. * 
  254. * See mountdInit() for documentation on <mountAuthHook>.  Note that
  255. * <mountAuthHook> and <authHook> can point to the same routine.
  256. * Simply use the <progNum>, <versNum>, and <procNum> fields to decide
  257. * whether the request is an NFS request or a mountd request.
  258. * 
  259. * VXWORKS AE PROTECTION DOMAINS
  260. * Under VxWorks AE, you can call this function from within the kernel 
  261. * protection domain only.  In addition, all arguments to this function can  
  262. * reference only that data which is valid in the kernel protection domain. 
  263. * This restriction does not apply under non-AE versions of VxWorks.  
  264. *
  265. * RETURNS: OK, or ERROR if the NFS server cannot be started.
  266. *
  267. * SEE ALSO: nfsExport(), mountdInit()
  268. */
  270. STATUS nfsdInit
  271.     (
  272.     int nServers, /* the number of NFS servers to create */
  273.     int nExportedFs, /* maximum number of exported file systems */
  274.     int priority, /* the priority for the NFS servers */
  275.     FUNCPTR authHook, /* authentication hook */
  276.     FUNCPTR mountAuthHook, /* authentication hook for mount daemon */
  277.     int options /* currently unused */
  278.     )
  279.     {
  280.     char serverName [50]; /* Synthetic name for NFS servers */
  281.     int  mountTask; /* taskId of the mountd task */
  282.     int  queuingTask; /* taskId of the task that queues NFS calls */
  284.     /*
  285.      * Scaling stack with change in NFS_MAXPATH since multiple arrays of size 
  286.      * NFS_MAXPATH are allocated from stack. Difference is computed from 
  287.      * default max. path of 255.
  288.      */
  290.     nfsdStackSize += 4 * (nfsMaxPath - 255);
  292.     /* Set up call statistics */
  293.     memset (&nfsdServerStatus, 0, sizeof (nfsdServerStatus));
  295.     /* Set up authorization hook */
  296.     nfsdAuthHook = authHook;
  297.     
  298.     /* If number and priority of servers isn't specified, set it to default */
  299.     
  300.     if (nServers == 0)
  301.         nServers = nfsdNServers;
  303.     if (priority == 0)
  304.         priority = nfsdPriorityDefault;
  306.     if (nExportedFs == 0)
  307.         nExportedFs = nfsdNFilesystemsDefault;
  309.     /* Create the request queue */
  310.     if ((nfsRequestQ = msgQCreate (nServers * QLEN_PER_SRVR, sizeof (NFS_Q_REQUEST),
  311.       MSG_Q_FIFO)) == NULL)
  312. return (ERROR);
  314.     /* Spawn the mount task */
  316.     if ((mountTask = mountdInit (0, 0, mountAuthHook, 0, 0)) == ERROR)
  317. {
  318. msgQDelete (nfsRequestQ);
  319. return (ERROR);
  320. }
  322.     /* spawn the queuing task */
  323.     
  324.     if ((queuingTask = taskSpawn ("tNfsd", priority, VX_FP_TASK, nfsdStackSize,
  325.     (FUNCPTR) nfsd, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0))
  326. == ERROR)
  327. {
  328. taskDelete (mountTask);
  329. msgQDelete (nfsRequestQ);
  330. return (ERROR);
  331. }
  333.     /* spawn the call processing tasks */
  334.     
  335.     while (nServers-- > 0)
  336. {
  337. /* Create names of the form tNfsdX */
  338. sprintf (serverName, "tNfsd%d", nServers);
  340. if ((taskSpawn (serverName, priority + 5, VX_FP_TASK, nfsdStackSize,
  341. (FUNCPTR) nfsdRequestProcess, 0, 0, 0, 0, 0, 0, 0, 0,
  342. 0, 0)) == ERROR)
  343.     {
  344.     taskDelete (mountTask);
  345.     taskDelete (queuingTask);
  347.     msgQDelete (nfsRequestQ);
  348.     return (ERROR);
  349.     }
  350. }
  352.     return (OK);
  353.     }
  355. /******************************************************************************
  356. *
  357. * nfsdRequestEnqueue - queue up NFS requests from clients
  358. *
  359. * Called only via svc_run(), via nfsd().  Puts an incoming NFS request
  360. * into the message queue for processing by nfsdRequestProcess().
  361. *
  362. * Some of this routine was generated by rpcgen.
  363. * 
  364. * RETURNS:  N/A
  365. * 
  366. * NOMANUAL
  367. */
  369. LOCAL void nfsdRequestEnqueue
  370.     (
  371.     struct svc_req * rqstp, /* Request */
  372.     SVCXPRT *        transp /* Transport */
  373.     )
  374.     {
  375.     NFSD_ARGUMENT *     argument;     /* Client call argument */
  376.     FUNCPTR             xdr_result;   /* XDR result conversion routine */
  377.     FUNCPTR             xdr_argument; /* XDR argument conversion routine */
  378.     char *              (*local)();   /* Local routine to call */
  379.     NFS_Q_REQUEST       request;      /* Request to queue up */
  381.     /* Allocate space for the argument */
  382.     argument = KHEAP_ALLOC((NFS_MAXDATA + sizeof (argument) + nfsMaxPath));
  384.     if (NULL != argument)
  385. {
  386. bzero((char *) argument,(NFS_MAXDATA + sizeof (argument) + nfsMaxPath));
  387. }
  389.     /* Beginning of code generated by rpcgen */
  391.     switch (rqstp->rq_proc) {
  392.     case NFSPROC_NULL:
  393.     xdr_argument = xdr_void;
  394.     xdr_result = xdr_void;
  395.     local = (char *(*)()) nfsproc_null_2;
  396.     break;
  398.     case NFSPROC_GETATTR:
  399.     xdr_argument = xdr_nfs_fh;
  400.     xdr_result = xdr_attrstat;
  401.     local = (char *(*)()) nfsproc_getattr_2;
  402.     break;
  404.     case NFSPROC_SETATTR:
  405.     xdr_argument = xdr_sattrargs;
  406.     xdr_result = xdr_attrstat;
  407.     local = (char *(*)()) nfsproc_setattr_2;
  408.     break;
  410.     case NFSPROC_ROOT:
  411.     xdr_argument = xdr_void;
  412.     xdr_result = xdr_void;
  413.     local = (char *(*)()) nfsproc_root_2;
  414.     break;
  416.     case NFSPROC_LOOKUP:
  417.     xdr_argument = xdr_diropargs;
  418.     xdr_result = xdr_diropres;
  419.     local = (char *(*)()) nfsproc_lookup_2;
  420.     break;
  422.     case NFSPROC_READLINK:
  423.     xdr_argument = xdr_nfs_fh;
  424.     xdr_result = xdr_readlinkres;
  425.     local = (char *(*)()) nfsproc_readlink_2;
  426.     break;
  428.     case NFSPROC_READ:
  429.     xdr_argument = xdr_readargs;
  430.     xdr_result = xdr_readres;
  431.     local = (char *(*)()) nfsproc_read_2;
  432.     break;
  434.     case NFSPROC_WRITECACHE:
  435.     xdr_argument = xdr_void;
  436.     xdr_result = xdr_void;
  437.     local = (char *(*)()) nfsproc_writecache_2;
  438.     break;
  440.     case NFSPROC_WRITE:
  441.     xdr_argument = xdr_writeargs;
  442.     xdr_result = xdr_attrstat;
  443.     local = (char *(*)()) nfsproc_write_2;
  444.     break;
  446.     case NFSPROC_CREATE:
  447.     xdr_argument = xdr_createargs;
  448.     xdr_result = xdr_diropres;
  449.     local = (char *(*)()) nfsproc_create_2;
  450.     break;
  452.     case NFSPROC_REMOVE:
  453.     xdr_argument = xdr_diropargs;
  454.     xdr_result = xdr_nfsstat;
  455.     local = (char *(*)()) nfsproc_remove_2;
  456.     break;
  458.     case NFSPROC_RENAME:
  459.     xdr_argument = xdr_renameargs;
  460.     xdr_result = xdr_nfsstat;
  461.     local = (char *(*)()) nfsproc_rename_2;
  462.     break;
  464.     case NFSPROC_LINK:
  465.     xdr_argument = xdr_linkargs;
  466.     xdr_result = xdr_nfsstat;
  467.     local = (char *(*)()) nfsproc_link_2;
  468.     break;
  470.     case NFSPROC_SYMLINK:
  471.     xdr_argument = xdr_symlinkargs;
  472.     xdr_result = xdr_nfsstat;
  473.     local = (char *(*)()) nfsproc_symlink_2;
  474.     break;
  476.     case NFSPROC_MKDIR:
  477.     xdr_argument = xdr_createargs;
  478.     xdr_result = xdr_diropres;
  479.     local = (char *(*)()) nfsproc_mkdir_2;
  480.     break;
  482.     case NFSPROC_RMDIR:
  483.     xdr_argument = xdr_diropargs;
  484.     xdr_result = xdr_nfsstat;
  485.     local = (char *(*)()) nfsproc_rmdir_2;
  486.     break;
  488.     case NFSPROC_READDIR:
  489.     xdr_argument = xdr_readdirargs;
  490.     xdr_result = xdr_readdirres;
  491.     local = (char *(*)()) nfsproc_readdir_2;
  492.     break;
  494.     case NFSPROC_STATFS:
  495.     xdr_argument = xdr_nfs_fh;
  496.     xdr_result = xdr_statfsres;
  497.     local = (char *(*)()) nfsproc_statfs_2;
  498.     break;
  500.     default:
  501.             KHEAP_FREE((char *)argument);
  502.     svcerr_noproc(transp);
  503.     return;
  504.     }
  506.     if (!svc_getargs(transp, xdr_argument, argument)) {
  507. svcerr_decode(transp);
  508. return;
  509.     }
  510.     
  511.     /* end of code generated by rpcgen */
  512.     
  513.     /* Build the request and put it into the message queue */
  514.     
  515.     request.routine   = (FUNCPTR) local;
  516.     request.procNum   = rqstp->rq_proc;
  517.     request.argument  = argument;
  518.     request.xdrArg    = xdr_argument;
  519.     request.xdrResult = xdr_result;
  520.     request.sockAddr  = transp->xp_raddr;
  522.     /* only use xp_p2 for udp requests */
  523.     if (transp->xp_p2 != NULL)
  524. request.xid       = ((struct svcudp_data *) transp->xp_p2)->su_xid;
  527.     request.socket    = transp->xp_sock;
  528.     
  529.     if (msgQSend (nfsRequestQ, (char *) &request, sizeof (request),
  530.   WAIT_FOREVER, MSG_PRI_NORMAL) != OK)
  531. {
  532. KHEAP_FREE((char *)argument);
  533. perror ("nfsd aborted");
  534. return;
  535. }
  537.     }
  539. /******************************************************************************
  540. *
  541. * nfsdRequestProcess - process client NFS requests
  542. * 
  543. * nfsdRequestProcess is started as a task by nfsdInit().  It sits in a loop
  544. * reading nfsdRequestQ and responding to all requests that are put into this
  545. * queue.
  546. * 
  547. * Multiple processes can be spawned with this entry point.  Normally,
  548. * nfsdNServers are started when nfsdInit() is called.
  549. * 
  550. * RETURNS:  N/A
  551. *
  552. * NOMANUAL
  553. */
  555. void nfsdRequestProcess
  556.     (
  557.     void
  558.     )
  559.     {
  560.     SVCXPRT *     transp; /* Dummy transport for RPC */
  561.     int           sock; /* Transmission socket for reply */
  562.     NFS_Q_REQUEST request; /* Client request */
  563.     NFSD_ARGUMENT * argument; /* Argument from client request */
  564.     char *        result; /* Result of NFS call */
  565.     FUNCPTR       xdr_argument; /* XDR argument conversion routine */
  566.     FUNCPTR       xdr_result; /* XDR result conversion routine */
  567.     FUNCPTR       local; /* Local NFS routine to call */
  568.     struct sockaddr_in * addr; /* Address of client socket */
  569.     int           xid; /* XID from client request */
  570.     nfsstat       authorized; /* request is authorized if == NFS_OK*/
  571.     
  572.     /* Initialize task for VxWorks RPC work */
  573.     
  574.     rpcTaskInit ();
  576.     transp = svcudp_create(-1);
  578.     /* Work loop is repeated until catastrophic error encountered */
  579.     
  580.     FOREVER
  581. {
  582. /* Get the next message */
  584. if (msgQReceive (nfsRequestQ, (char *) &request, sizeof(request),
  585.  WAIT_FOREVER) == ERROR)
  586.     {
  587.     perror ("NFS server aborted abnormally");
  588.     return;
  589.     }
  591. /* Break down the incoming message */
  593. local        = request.routine;
  594. argument     = request.argument;
  595. xdr_argument = request.xdrArg;  
  596. xdr_result   = request.xdrResult;
  597. addr         = &request.sockAddr;
  598. xid          = request.xid;
  599. sock         = request.socket;
  601. /* Create a new RPC transport to reply.  Need to do this as
  602.  * next incoming client request will alter xid field of old
  603.  * transport, and replies won't match the correct request.
  604.  */
  606. transp->xp_sock = sock;
  607. ((struct svcudp_data *) transp->xp_p2)->su_xid = xid;
  608. transp->xp_raddr = *addr;
  609. memset (&transp->xp_verf, 0, sizeof(transp->xp_verf));
  610. transp->xp_addrlen = sizeof (transp->xp_raddr);
  612. /* Authenticate the request, then call the correct NFS routine */
  614. if (nfsdAuthHook)
  615.     {
  616.     authorized = (*nfsdAuthHook) (NFS_PROGRAM, NFS_VERSION,
  617.   request.procNum, request.sockAddr,
  618.   argument);
  619.     }
  620. else
  621.     authorized = NFS_OK;
  623. if (authorized  != NFS_OK)
  624.     {
  625.     result = KHEAP_ALLOC(sizeof (nfsstat));
  627.     if (NULL != result)
  628. {
  629. bzero ((char *)result, sizeof (nfsstat));
  630. }
  632.     *((nfsstat *) result) = authorized;
  633.     }
  634. else
  635.     result = (char *) (*local)(argument);
  637. /* Send the result */
  639. if (result != NULL && !svc_sendreply(transp, xdr_result, result))
  640.     {
  641.     svcerr_systemerr(transp);
  642.     }
  644. /* Free any space used by RPC/XDR */
  646. if (!svc_freeargs(transp, xdr_argument, argument))
  647.     {
  648.     perror ("unable to free arguments for NFS server");
  649.     return;
  650.     }
  652. /* Free space allocated when request was queued up */
  654. KHEAP_FREE((char *)result);
  655. KHEAP_FREE((char *)argument);
  657. /* Unfortunately, there's no way to tell svc_destroy() to not close
  658.  * the socket.  So, set the socket to -1. svc_destroy() doesn't
  659.  * check the value of the close() anyway.  If errno is set to
  660.  * S_iosLib_INVALID_FILE_DESCRIPTOR due to the close (-1), reset it
  661.  * to OK.  (svc_destroy() returns NULL, so there's no way to check
  662.  * its return value.)
  663.  */
  665. }
  666.     transp->xp_sock = -1;
  667.     svc_destroy (transp);
  668.     if (errno == S_iosLib_INVALID_FILE_DESCRIPTOR)
  669.         errno = OK;
  670.     }
  672. /******************************************************************************
  673. *
  674. * nfsd - NFS daemon process
  675. *
  676. * Used as the entrypoint to a task spawned from nfsdInit().  This task
  677. * sets up the NFS RPC service, and calls svc_run(), which should never return.
  678. * nfsdRequestEnqueue() is called from the svc_run() call.
  679. *
  680. * This routine is not declared LOCAL only because the symbol for its entry
  681. * point should be displayed by i().
  682. * 
  683. * NOTE:  Some of this routine was generated by rpcgen.
  684. * 
  685. * RETURNS:  Never returns unless an error is encountered.
  686. * 
  687. * SEE ALSO: nfsdRequestEnqueue().
  688. * 
  689. * NOMANUAL
  690. */
  692. void nfsd
  693.     (
  694.     void
  695.     )
  696.     {
  697.     register SVCXPRT * transp; /* RPC transport */
  698.     int                sock; /* NFS socket */
  699.     struct sockaddr_in addr; /* Address of NFS (port 2049 */
  700.     int                optVal = NFS_MAXDATA * 2 + sizeof (struct rpc_msg) * 2;
  701.                                 /* XXX - too much space is wasted here */
  702.     
  703.     /* Initialize the task to use VxWorks RPC code */
  704.     
  705.     rpcTaskInit();
  707.     /* Create NFS socket and bind it to correct address */
  708.     
  709.     sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
  711.     /* Set up the socket address */
  712.     
  713.     addr.sin_family             = AF_INET;
  714.     addr.sin_addr.s_addr        = INADDR_ANY;
  715.     addr.sin_port               = htons (NFS_PORT);
  717.     bzero (addr.sin_zero, sizeof (addr.sin_zero));
  718.     if (bind (sock, (struct sockaddr *) &addr, sizeof (addr)) == ERROR)
  719. {
  720. perror ("Could not bind to NFS port address");
  721. return;
  722. }
  724.     /* Unset any previous NFS services */
  725.     pmap_unset(NFS_PROGRAM, NFS_VERSION);
  727.     /* Set socket buffer large enough to accommodate max NFS message */
  728.     if ((setsockopt (sock, SOL_SOCKET, SO_SNDBUF, (char *)&optVal,
  729.      sizeof (optVal)) == ERROR)
  730. || (setsockopt (sock, SOL_SOCKET, SO_RCVBUF, (char *)&optVal,
  731. sizeof (optVal)) == ERROR))
  732.         return;
  734.     /* Create RPC transport */
  735.     transp = svcudp_create(sock);
  736.     if (transp == NULL)
  737. {
  738. fprintf(stderr, "cannot create udp service.");
  739. exit(1);
  740. }
  742.     /* Register NFS */
  743.     if (!svc_register(transp, NFS_PROGRAM, NFS_VERSION, nfsdRequestEnqueue,
  744.       IPPROTO_UDP))
  745. {
  746. perror ("unable to register (NFS_PROGRAM, NFS_VERSION, udp).n");
  747. return;
  748. }
  750.     /* Start the RPC service, and never come back */
  751.     svc_run();
  753.     /* Should never get to this point */
  754.     
  755.     perror ("NFS svc_run returned");
  756.     }
  758. /******************************************************************************
  759. *
  760. * nfsproc_null_2 - do nothing
  761. *
  762. * RETURNS: A pointer to malloced spaced that contains no information.
  763. *
  764. * NOMANUAL
  765. */
  767. void * nfsproc_null_2
  768.     (
  769.     void
  770.     )
  771.     {
  772.     nfsdServerStatus.nullCalls++;
  773.     
  774.     return ((void *) KHEAP_ALLOC(0));
  775.     }
  777. /******************************************************************************
  778. *
  779. * nfsproc_getattr_2 - get file attributes
  780. *
  781. * If the reply status is NFS_OK, then the reply attributes contains the
  782. * attributes for the file given by the input fhandle.
  783. * 
  784. * RETURNS: A pointer to an attrstat struct.
  785. *
  786. * NOMANUAL
  787. */
  789. attrstat * nfsproc_getattr_2
  790.     (
  791.     nfs_fh *   fh /* File handle to get attributes of */
  792.     )
  793.     {
  794.     attrstat * retVal = KHEAP_ALLOC(sizeof (attrstat)); /* Struct to fill in */
  796.     nfsdServerStatus.getattrCalls++;
  798.     nfsdFhNtoh ((NFS_FILE_HANDLE *) fh);
  799.     
  800.     if (retVal == NULL)
  801.         return (NULL);
  803.     /* Get the attributes for the file */
  804.     
  805.     if (nfsdFattrGet ((NFS_FILE_HANDLE *) fh,
  806.  &retVal->attrstat_u.attributes) == ERROR)
  807. {
  808. retVal->status = nfsdErrToNfs (errno);
  809. return (retVal);
  810. }
  811.     else
  812.         retVal->status = NFS_OK;
  813.     
  814.     return (retVal);
  815.     }
  817. /******************************************************************************
  818. *
  819. * nfsproc_setattr_2 - set the attributes for a file
  820. * 
  821. * The "attr" argument contains fields which are either -1 or are
  822. * the new value for the attributes of "file".  If the reply status is
  823. * NFS_OK, then the reply attributes have the attributes of the file
  824. * after the "SETATTR" operation has completed.
  825. * 
  826. * Notes:  The use of -1 to indicate an unused field in "attributes" is
  827. * changed in the next version of the protocol.
  828. *
  829. * NOMANUAL
  830. */
  832. attrstat * nfsproc_setattr_2
  833.     (
  834.     sattrargs *    attr /* Attributes to change */
  835.     )
  836.     {
  837.     attrstat *     retVal = KHEAP_ALLOC(sizeof (attrstat));/* Return info */
  838.     char *         fileName;    /* Name of the file being changed */
  839.     int     fd; /* File descriptor for file being changed */
  840.     struct utimbuf timeBuf; /* New time settings for file */
  842.     if (retVal == NULL)
  843.         return (NULL);
  844.      
  845.     if ((fileName = (char *) alloca (nfsMaxPath)) == NULL)
  846. return (NULL);
  848.     nfsdServerStatus.setattrCalls++;
  850.     nfsdFhNtoh ((NFS_FILE_HANDLE *) &attr->file);
  852.     /* Make sure the file system is writeable */
  854.     if (nfsdFsReadOnly((NFS_FILE_HANDLE *) &attr->file))
  855. {
  856. retVal->status = NFSERR_ACCES;
  857. return (retVal);
  858. }
  860.     if (nfsdFhToName ((NFS_FILE_HANDLE *) &attr->file, fileName) == ERROR)
  861. {
  862. retVal->status = nfsdErrToNfs (errno);
  863. return (retVal);
  864. }
  866.     if (attr->attributes.mode != -1)
  867.         /* Currently don't have any way to set the mode */
  868.         ;
  869.         
  870.     if (attr->attributes.uid != -1)
  871.         /* Currently don't have any way to set the uid */
  872.         ;
  873.         
  874.     if (attr->attributes.gid != -1)
  875.         /* Currently don't have any way to set the gid */
  876.         ;
  877.         
  878.     if (attr->attributes.size != -1)
  879. {
  880. /* Set the size of the file using FIOTRUNC ioctl, as VxWorks
  881.  * doesn't have ftruncate() */
  883.         fd = open (fileName, O_RDWR, 0666);
  884. if (fd != ERROR)
  885.     {
  886.     if (ioctl (fd, FIOTRUNC, attr->attributes.size) == ERROR)
  887. {
  888. retVal->status = nfsdErrToNfs (errno);
  889. close (fd);
  890. return (retVal);
  891. }
  892.     else
  893.         close (fd);
  894.     }
  895. else
  896.     {
  897.     retVal->status = nfsdErrToNfs (errno);
  898.     close (fd);
  899.     return (retVal);
  900.     }
  901. }
  903.     /* Set file time.
  904.      *
  905.      * As there's no way to set only one of these fields, if only one
  906.      * is set, set the other one to the same value.
  907.      */
  908.     
  909.     if (attr->attributes.atime.seconds != -1)
  910. timeBuf.modtime = timeBuf.actime = attr->attributes.atime.seconds;
  911.     
  912.     if (attr->attributes.mtime.seconds != -1)
  913. {
  914. timeBuf.modtime = attr->attributes.mtime.seconds;
  915. if (attr->attributes.atime.seconds == -1)
  916.     timeBuf.actime = timeBuf.modtime;
  917. }
  919.     if ((attr->attributes.atime.seconds != -1) ||
  920. (attr->attributes.mtime.seconds != -1))
  921.         if (utime (fileName, &timeBuf) == ERROR)
  922.     {
  923.     retVal->status = nfsdErrToNfs (errno);
  924.     return (retVal);
  925.     }
  926.     
  927.     /* Get the status information for the file to return */
  928.     
  929.     if (nfsdFattrGet ((NFS_FILE_HANDLE *) &attr->file,
  930.  &retVal->attrstat_u.attributes) != OK)
  931. {
  932. retVal->status = nfsdErrToNfs (errno);
  933. return (retVal);
  934. }
  936.     retVal->status = NFS_OK;
  938.     return (retVal);
  939.     }
  941. /******************************************************************************
  942. *
  943. * nfsproc_root_2 - obsolete
  944. * 
  945. * Obsolete.  This procedure is no longer used because finding the root
  946. * file handle of a filesystem requires moving pathnames between client
  947. * and server.  To do this right, we would have to define a network
  948. * standard representation of pathnames.  Instead, the function of
  949. * looking up the root file handle is done by the MNTPROC_MNT procedure.
  950. * 
  951. * RETURNS:  A pointer to no information.
  952. *
  953. * NOMANUAL
  954. */
  956. void * nfsproc_root_2
  957.     (
  958.     void
  959.     )
  960.     {
  961.     nfsdServerStatus.setattrCalls++;
  962.     return ((void *) KHEAP_ALLOC(0));
  963.     }
  965. /******************************************************************************
  966. *
  967. * nfsproc_lookup_2 -
  968. * 
  969. * If the reply "status" is NFS_OK, then the reply "file" and reply
  970. * "attributes" are the file handle and attributes for the file "name"
  971. * in the directory given by "dir" in the argument.
  972. * 
  973. * RETURNS:  A pointer to a diropres struct, or NULL.
  974. *
  975. * NOMANUAL
  976. */
  978. diropres * nfsproc_lookup_2
  979.     (
  980.     diropargs * dir /* The direcory and file to look up */
  981.     )
  982.     {
  983.     diropres *  retVal = KHEAP_ALLOC(sizeof (diropres)); /* return status */
  985.     if (retVal == NULL)
  986.         return (NULL);
  987.     
  988.     nfsdServerStatus.lookupCalls++;
  990.     nfsdFhNtoh ((NFS_FILE_HANDLE *) &dir->dir);
  991.     
  992.     /* Build file handle for new file */
  994.     if (nfsdFhCreate ((NFS_FILE_HANDLE *) &dir->dir, dir->name,
  995.  (NFS_FILE_HANDLE *) &retVal->diropres_u.diropres.file)
  996. == ERROR)
  997. {
  998. retVal->status = nfsdErrToNfs (errno);
  999. return (retVal);
  1000. }
  1002.     /* Get the attributes for the newly created file handle */
  1003.     if (nfsdFattrGet ((NFS_FILE_HANDLE *) &retVal->diropres_u.diropres.file,
  1004.  &retVal->diropres_u.diropres.attributes) == ERROR)
  1005. {
  1006. retVal->status = nfsdErrToNfs (errno);
  1007. return (retVal);
  1008. }
  1009.     retVal->status = NFS_OK;
  1010.     nfsdFhHton ((NFS_FILE_HANDLE *) &retVal->diropres_u.diropres.file);
  1011.     
  1012.     return (retVal);
  1013.     }
  1015. /******************************************************************************
  1016. *
  1017. * nfsproc_readlink_2 - read from a symbolic link
  1018. * 
  1019. * VxWorks does not support symbolic links.
  1020. * 
  1021. * RETURNS:  A pointer to an EOPNOTSUPP error.
  1022. *
  1023. * NOMANUAL
  1024. */
  1026. readlinkres * nfsproc_readlink_2
  1027.     (
  1028.     nfs_fh * fh /* File handle to read */
  1029.     )
  1030.     {
  1031.     readlinkres * retVal = KHEAP_ALLOC(sizeof (retVal->status));
  1033.     if (retVal == NULL)
  1034.         return (NULL);
  1036.     /* Increment statistics */
  1037.     nfsdServerStatus.readlinkCalls++;
  1039.     /* symbolic links not supported */
  1040.     retVal->status = EOPNOTSUPP;
  1041.     return (retVal);
  1042.     }
  1044. /******************************************************************************
  1045. *
  1046. * nfsproc_read_2 - read data from a file
  1047. * 
  1048. * Returns up to "count" bytes of "data" from the file given by "file",
  1049. * starting at "offset" bytes from the beginning of the file.  The first
  1050. * byte of the file is at offset zero.  The file attributes after the
  1051. * read takes place are returned in "attributes".
  1052. * 
  1053. * Notes:  The argument "totalcount" is unused, and is removed in the
  1054. * next protocol revision.
  1055. *
  1056. * NOMANUAL
  1057. */
  1059. readres * nfsproc_read_2
  1060.     (
  1061.     readargs * readFile /* File, offset, and count information */
  1062.     )
  1063.     {
  1064.     char *     fileName;        /* Name of the file being read */
  1065.     readres *  retVal = KHEAP_ALLOC(sizeof (readres) + readFile->count);
  1066. /* Return information, including read data */
  1067.     char *     readData; /* Address of read data in retVal */
  1068.     int        fd; /* File descriptor for file being read */
  1069.     int        nBytes; /* Number of bytes actually read */
  1071.     if (retVal == NULL)
  1072.         return (NULL);
  1074.     if ((fileName = (char *) alloca (nfsMaxPath)) == NULL)
  1075. return (NULL);
  1077.     /* Increment statistics */
  1078.     nfsdServerStatus.readCalls++;
  1080.     /* set readData to point to the correct position in the return value */
  1081.     readData = (char *) retVal + sizeof (readres);
  1082.     
  1083.     nfsdFhNtoh ((NFS_FILE_HANDLE *) &readFile->file);
  1084.     
  1085.     if (nfsdFhToName ((NFS_FILE_HANDLE *) &readFile->file, fileName)
  1086. == ERROR)
  1087. {
  1088. retVal->status = nfsdErrToNfs (errno);
  1089. return (retVal);
  1090. }
  1092.     if ((fd = open (fileName, O_RDONLY, 0)) == ERROR)
  1093. {
  1094. retVal->status = nfsdErrToNfs (errno);
  1095. return (retVal);
  1096. }
  1098.     if (lseek (fd, readFile->offset, SEEK_SET) == ERROR)
  1099. {
  1100. retVal->status = nfsdErrToNfs (errno);
  1101. close (fd);
  1102. return (retVal);
  1103. }
  1105.     if ((nBytes = read (fd, readData, readFile->count)) == ERROR)
  1106.      {
  1107. retVal->status = nfsdErrToNfs (errno);
  1108. close (fd);
  1109. return (retVal);
  1110. }
  1111.     else
  1112. {
  1113.         retVal->readres_u.reply.data.data_val = readData;
  1114. retVal->readres_u.reply.data.data_len = nBytes;
  1115. }
  1117.     if (close (fd) == ERROR)
  1118. {
  1119. retVal->status = nfsdErrToNfs (errno);
  1120. return (retVal);
  1121. }
  1123.     if (nfsdFattrGet ((NFS_FILE_HANDLE *) &readFile->file,
  1124.  &retVal->readres_u.reply.attributes) == ERROR)
  1125.      {
  1126. retVal->status = nfsdErrToNfs (errno);
  1127. return (retVal);
  1128. }
  1130.     retVal->status = NFS_OK;
  1132.     return (retVal);
  1133.     }
  1135. /******************************************************************************
  1136. *
  1137. * nfsproc_writecache_2 - unused
  1138. *
  1139. * NOMANUAL
  1140. */
  1142. void * nfsproc_writecache_2
  1143.     (
  1144.     void
  1145.     )
  1146.     {
  1147.     /* Increment statistics */
  1148.     nfsdServerStatus.writecacheCalls++;
  1150.     return ((void *) KHEAP_ALLOC(0));
  1151.     }
  1153. /******************************************************************************
  1154. *
  1155. * nfsproc_write_2 -
  1156. * 
  1157. * Writes "data" beginning "offset" bytes from the beginning of "file".
  1158. * The first byte of the file is at offset zero.  If the reply "status"
  1159. * is NFS_OK, then the reply "attributes" contains the attributes of the
  1160. * file after the write has completed.  The write operation is atomic.
  1161. * Data from this "WRITE" will not be mixed with data from another
  1162. * client's "WRITE".
  1163. * 
  1164. * Notes:  The arguments "beginoffset" and "totalcount" are ignored and
  1165. * are removed in the next protocol revision.
  1166. *
  1167. * NOMANUAL
  1168. */
  1170. attrstat * nfsproc_write_2
  1171.     (
  1172.     writeargs * wrArgs /* File, write data, and offset information */
  1173.     )
  1174.     {
  1175.     char *      fileName;       /* Name of the file to write */
  1176.     attrstat *  retVal; /* Return value */
  1177.     int         fd; /* File descriptor for file to write */
  1178.     int nBytes; /* Number of bytes actually written */
  1179.     int         writeCount;     /* Number of bytes to write */
  1180.     BOOL        writeError = FALSE;
  1181.     
  1182.     if ((retVal = KHEAP_ALLOC(sizeof (*retVal))) == NULL)
  1183. return (NULL);
  1184.     
  1185.     if ((fileName = (char *) alloca (nfsMaxPath)) == NULL)
  1186. return (NULL);
  1188.     /* Increment statistics */
  1189.     nfsdServerStatus.writeCalls++;
  1191.     nfsdFhNtoh ((NFS_FILE_HANDLE *) &wrArgs->file);
  1192.     
  1193.     /* Make sure the file system is writeable */
  1195.     if (nfsdFsReadOnly((NFS_FILE_HANDLE *) &wrArgs->file))
  1196. {
  1197. retVal->status = NFSERR_ACCES;
  1198. return (retVal);
  1199. }
  1201.     if (nfsdFhToName ((NFS_FILE_HANDLE *) &wrArgs->file, fileName) == ERROR)
  1202. {
  1203. retVal->status = nfsdErrToNfs (errno);
  1204. return (retVal);
  1205. }
  1207.     if ((fd = open (fileName, O_WRONLY, 0)) == ERROR)
  1208. {
  1209. retVal->status = nfsdErrToNfs (errno);
  1210. return (retVal);
  1211. }
  1212.     
  1213.     if (lseek (fd, wrArgs->offset, SEEK_SET) != wrArgs->offset)
  1214.      {
  1215. retVal->status = nfsdErrToNfs (errno);
  1216. close (fd);
  1217. return (retVal);
  1218. }
  1220.     errno = OK;
  1221.     writeCount = wrArgs->data.data_len;
  1222.     if ((nBytes = write (fd, wrArgs->data.data_val, writeCount)) != writeCount)
  1223. {
  1224. if (errno == OK)
  1225.     {
  1226.     /* Try this twice to get around a dosFs bug */
  1227.     writeCount -= nBytes;
  1228.     if (write (fd, wrArgs->data.data_val, writeCount) != writeCount)
  1229. writeError = TRUE;
  1230.     }
  1231. else
  1232.     writeError = TRUE;
  1234. if (writeError)
  1235.     {
  1236.     retVal->status = nfsdErrToNfs (errno);
  1237.     close (fd);
  1238.     return (retVal);
  1239.     }
  1240. }
  1241.     
  1242.     if (close (fd) == ERROR)
  1243.      {
  1244. retVal->status = nfsdErrToNfs (errno);
  1245. return (retVal);
  1246. }
  1248.     if (nfsdFattrGet ((NFS_FILE_HANDLE *) &wrArgs->file,
  1249.  &retVal->attrstat_u.attributes) == ERROR)
  1250. {
  1251. retVal->status = nfsdErrToNfs (errno);
  1252. return (retVal);
  1253. }
  1255.     retVal->status = NFS_OK;
  1256.     return (retVal);
  1257.     }
  1259. /******************************************************************************
  1260. *
  1261. * nfsproc_create_2 - create a file
  1262. * 
  1263. * The file "name" is created in the directory given by "dir".  The
  1264. * initial attributes of the new file are given by "attributes".  A
  1265. * reply "status" of NFS_OK indicates that the file was created, and
  1266. * reply "file" and reply "attributes" are its file handle and
  1267. * attributes.  Any other reply "status" means that the operation failed
  1268. * and no file was created.
  1269. * 
  1270. * Notes:  This routine should pass an exclusive create flag, meaning
  1271. * "create the file only if it is not already there".
  1272. * 
  1273. * NOMANUAL
  1274. */
  1276. diropres * nfsproc_create_2
  1277.     (
  1278.     createargs * newFile  /* File to create */
  1279.     )
  1280.     {
  1281.     diropres *   retVal = KHEAP_ALLOC(sizeof (diropres)); /* Return value */
  1282.     char *       newName;       /* Name of file to create */
  1283.     int          fd; /* File descriptor for file to create */
  1285.     if (retVal == NULL)
  1286.         return (NULL);
  1287.     
  1288.     if ((newName = (char *) alloca (nfsMaxPath)) == NULL)
  1289. return (NULL);
  1291.     /* Increment statistics */
  1292.     nfsdServerStatus.createCalls++;
  1294.     /* Create the name for the new file by getting the name of the directory,
  1295.      * followed by "/" and the name of the new file
  1296.      */
  1297.     
  1298.     nfsdFhNtoh ((NFS_FILE_HANDLE *) &newFile->where.dir);
  1299.     
  1300.     /* Make sure the file system is writeable */
  1302.     if (nfsdFsReadOnly((NFS_FILE_HANDLE *) &newFile->where.dir))
  1303. {
  1304. retVal->status = NFSERR_ACCES;
  1305. return (retVal);
  1306. }
  1308.     if (nfsdFhToName ((NFS_FILE_HANDLE *) &newFile->where.dir, newName)
  1309. == ERROR)
  1310. {
  1311. retVal->status = nfsdErrToNfs (errno);
  1312. return (retVal);
  1313. }
  1315.     strcat (newName, "/");
  1316.     strcat (newName, newFile->where.name);
  1318.     /* Check if the file has been created already */
  1320.     if ((fd = open (newName, O_RDWR, 0)) != ERROR)
  1321. {
  1322. retVal->status = NFSERR_EXIST;
  1323. close(fd);
  1324. return (retVal);
  1325. }
  1327.     /* Create the file */
  1328.     
  1329.     if ((fd = open (newName, O_RDWR | O_CREAT, 0)) == ERROR)
  1330.      {
  1331. retVal->status = nfsdErrToNfs (errno);
  1332. return (retVal);
  1333. }
  1334.     
  1335.     if (close (fd) == ERROR)
  1336. {
  1337. retVal->status = nfsdErrToNfs (errno);
  1338. return (retVal);
  1339. }
  1341.     /* Create its file handle */
  1342.     if (nfsdFhCreate ((NFS_FILE_HANDLE *) &newFile->where.dir,
  1343.  newFile->where.name,
  1344.  (NFS_FILE_HANDLE *) &retVal->diropres_u.diropres.file)
  1345. == ERROR)
  1346.      {
  1347. retVal->status = nfsdErrToNfs (errno);
  1348. return (retVal);
  1349. }
  1351.     /* Get its attributes */
  1352.     if (nfsdFattrGet ((NFS_FILE_HANDLE *) &retVal->diropres_u.diropres.file,
  1353.      &retVal->diropres_u.diropres.attributes) == ERROR)
  1354.      {
  1355. retVal->status = nfsdErrToNfs (errno);
  1356. return (retVal);
  1357. }
  1359.     retVal->status = NFS_OK;
  1360.     nfsdFhHton ((NFS_FILE_HANDLE *) &retVal->diropres_u.diropres.file);
  1361.     
  1362.     return (retVal);
  1363.     }
  1365. /******************************************************************************
  1366. *
  1367. * nfsproc_remove_2 - remove a file
  1368. * 
  1369. * The file "name" is removed from the directory given by "dir".  A
  1370. * reply of NFS_OK means the directory entry was removed.
  1371. * 
  1372. * Notes:  possibly non-idempotent operation.
  1373. * 
  1374. * NOMANUAL
  1375. */
  1377. nfsstat * nfsproc_remove_2
  1378.     (
  1379.     diropargs * removeFile /* File to be removed */
  1380.     )
  1381.     {
  1382.     nfsstat * retVal = KHEAP_ALLOC(sizeof (nfsstat)); /* Return value */
  1383.     char *    newName;          /* Name of the file to be removed */
  1385.     if (retVal == NULL)
  1386.         return NULL;
  1388.     if ((newName = (char *) alloca (nfsMaxPath)) == NULL)
  1389. return (NULL);
  1391.     /* Increment statistics */
  1392.     nfsdServerStatus.removeCalls++;
  1394.     /* Create the name for removed file by getting the name of the directory,
  1395.      * followed by "/" and the name of the new file
  1396.      */
  1397.     nfsdFhNtoh ((NFS_FILE_HANDLE *) &removeFile->dir);
  1398.     
  1399.     /* Make sure the file system is writeable */
  1401.     if (nfsdFsReadOnly((NFS_FILE_HANDLE *) &removeFile->dir))
  1402. {
  1403. *retVal = NFSERR_ACCES;
  1404. return (retVal);
  1405. }
  1407.     if (nfsdFhToName ((NFS_FILE_HANDLE *) &removeFile->dir, newName)
  1408. == ERROR)
  1409. {
  1410. *retVal = nfsdErrToNfs (errno);
  1411. return (retVal);
  1412. }
  1414.     strcat (newName, "/");
  1415.     strcat (newName, removeFile->name);
  1417.     /* Do the removal */
  1418.     if (unlink (newName) == ERROR)
  1419. *retVal = nfsdErrToNfs (errno);
  1420.     else
  1421. *retVal = NFS_OK;
  1423.     return (retVal);
  1424.     }
  1426. /******************************************************************************
  1427. *
  1428. * nfsproc_rename_2 - rename a file
  1429. * 
  1430. * The existing file "from.name" in the directory given by "from.dir" is
  1431. * renamed to "to.name" in the directory given by "to.dir".  If the
  1432. * reply is NFS_OK, the file was renamed.  The RENAME operation is
  1433. * atomic on the server; it cannot be interrupted in the middle.
  1434. * 
  1435. * Notes:  possibly non-idempotent operation.
  1436. * 
  1437. * NOMANUAL
  1438. */
  1440. nfsstat * nfsproc_rename_2
  1441.     (
  1442.     renameargs * names /* New and old file names */
  1443.     )
  1444.     {
  1445.     nfsstat * retVal = KHEAP_ALLOC(sizeof (nfsstat)); /* Return value */
  1446.     char *    oldName;                                /* Old file name */
  1447.     char *    newName;                                /* New file name */
  1449.     /* Increment statistics */
  1450.     nfsdServerStatus.renameCalls++;
  1452.     if (retVal == NULL)
  1453.         return (NULL);
  1454.     
  1455.     if ((oldName = (char *) alloca (nfsMaxPath)) == NULL)
  1456. return (NULL);
  1458.     if ((newName = (char *) alloca (nfsMaxPath)) == NULL)
  1459. return (NULL);
  1461.     /* Create strings for the old and new file names */
  1462.     
  1463.     nfsdFhNtoh ((NFS_FILE_HANDLE *)  &names->from.dir);
  1464.     nfsdFhNtoh ((NFS_FILE_HANDLE *)  &names->to.dir);
  1465.     
  1466.     /* Make sure the file system is writeable */
  1468.     if (nfsdFsReadOnly((NFS_FILE_HANDLE *) &names->from.dir))
  1469. {
  1470. *retVal = NFSERR_ACCES;
  1471. return (retVal);
  1472. }
  1474.     if (nfsdFhToName ((NFS_FILE_HANDLE *) &names->from.dir, oldName)
  1475. == ERROR)
  1476. {
  1477. *retVal = nfsdErrToNfs (errno);
  1478. return (retVal);
  1479. }
  1481.     strcat (oldName, "/");
  1482.     strcat (oldName, names->from.name);
  1484.     if (nfsdFhToName ((NFS_FILE_HANDLE *) &names->to.dir, newName)
  1485. == ERROR)
  1486. {
  1487. *retVal = nfsdErrToNfs (errno);
  1488. return (retVal);
  1489. }
  1491.     strcat (newName, "/");
  1492.     strcat (newName, names->to.name);
  1494.     /* Do the rename() */
  1495.     if (rename (oldName, newName) == ERROR)
  1496. {
  1497. *retVal = nfsdErrToNfs (errno);
  1498. return (retVal);
  1499. }
  1500.     else
  1501.         *retVal = NFS_OK;
  1502.     
  1503.     return (retVal);
  1504.     }
  1506. /******************************************************************************
  1507. *
  1508. * nfsproc_link_2 - create a link - not supported by VxWorks
  1509. *
  1510. * NOMANUAL
  1511. */
  1513. nfsstat * nfsproc_link_2
  1514.     (
  1515.     void
  1516.     )
  1517.     {
  1518.     nfsstat * notSupported = KHEAP_ALLOC(sizeof (nfsstat));
  1519.     *notSupported = EOPNOTSUPP;
  1520.     return ((nfsstat *) notSupported);
  1521.     }
  1523. /******************************************************************************
  1524. *
  1525. * nfsproc_symlink_2 - create a symbolic link - not supported by VxWorks
  1526. *
  1527. * NOMANUAL
  1528. */
  1530. nfsstat * nfsproc_symlink_2
  1531.     (
  1532.     void
  1533.     )
  1534.     {
  1535.     nfsstat * notSupported = KHEAP_ALLOC(sizeof (nfsstat));
  1536.     /* Increment statistics */
  1537.     nfsdServerStatus.symlinkCalls++;
  1539.     *notSupported = EOPNOTSUPP;
  1540.     return ((nfsstat *) notSupported);
  1541.     }
  1543. /******************************************************************************
  1544. *
  1545. * nfsproc_mkdir_2 - create a directory
  1546. * 
  1547. * The new directory "where.name" is created in the directory given by
  1548. * "where.dir".  The initial attributes of the new directory are given
  1549. * by "attributes".  A reply "status" of NFS_OK indicates that the new
  1550. * directory was created, and reply "file" and reply "attributes" are
  1551. * its file handle and attributes.  Any other reply "status" means that
  1552. * the operation failed and no directory was created.
  1553. * 
  1554. * Notes:  possibly non-idempotent operation.
  1555. *
  1556. * NOMANUAL
  1557. */
  1559. diropres * nfsproc_mkdir_2
  1560.     (
  1561.     createargs * crArgs
  1562.     )
  1563.     {
  1564.     diropres *      retVal = KHEAP_ALLOC(sizeof (diropres));
  1565.     char *          newName;
  1567.     if (retVal == NULL)
  1568.         return (NULL);
  1569.     
  1570.     if ((newName = (char *) alloca (nfsMaxPath)) == NULL)
  1571. return (NULL);
  1573.     /* Increment statistics */
  1574.     nfsdServerStatus.mkdirCalls++;
  1576.     retVal->status = NFS_OK;
  1578.     /* Create the string for the name of the directory to make */
  1579.     
  1580.     nfsdFhNtoh ((NFS_FILE_HANDLE *) &crArgs->where.dir);
  1581.     
  1582.     /* Make sure the file system is writeable */
  1584.     if (nfsdFsReadOnly((NFS_FILE_HANDLE *) &crArgs->where.dir))
  1585. {
  1586. retVal->status = NFSERR_ACCES;
  1587. return (retVal);
  1588. }
  1590.     if (nfsdFhToName ((NFS_FILE_HANDLE *) &crArgs->where.dir, newName)
  1591. == ERROR)
  1592. {
  1593. retVal->status = nfsdErrToNfs (errno);
  1594. return (retVal);
  1595. }
  1597.     strcat (newName, "/");
  1598.     strcat (newName, crArgs->where.name);
  1600.     /* make the directory */
  1601.     if (mkdir (newName) == ERROR)
  1602.      {
  1603. retVal->status = nfsdErrToNfs (errno);
  1604. return (retVal);
  1605. }
  1607.     /* Create a file handle for the new directory */
  1608.     if (nfsdFhCreate ((NFS_FILE_HANDLE *) &crArgs->where.dir,
  1609.  crArgs->where.name,
  1610.  (NFS_FILE_HANDLE *) &retVal->diropres_u.diropres.file)
  1611. == ERROR)
  1612.      {
  1613. retVal->status = nfsdErrToNfs (errno);
  1614. return (retVal);
  1615. }
  1617.     /* Get the file attributes for the new directory */
  1618.     if (nfsdFattrGet ((NFS_FILE_HANDLE *) &retVal->diropres_u.diropres.file,
  1619.      &retVal->diropres_u.diropres.attributes) == ERROR)
  1620.      {
  1621. retVal->status = nfsdErrToNfs (errno);
  1622. return (retVal);
  1623. }
  1625.     nfsdFhHton ((NFS_FILE_HANDLE *) &retVal->diropres_u.diropres.file);
  1626.     return (retVal);
  1627.     }
  1629. /******************************************************************************
  1630. *
  1631. * nfsproc_rmdir_2 - remove a directory
  1632. * 
  1633. * The existing empty directory "name" in the directory given by "dir"
  1634. * is removed.  If the reply is NFS_OK, the directory was removed.
  1635. * 
  1636. * Notes:  possibly non-idempotent operation.
  1637. *
  1638. * NOMANUAL
  1639. */
  1641. nfsstat * nfsproc_rmdir_2
  1642.     (
  1643.     diropargs * removeDir /* Directory to remove */
  1644.     )
  1645.     {
  1646.     nfsstat * retVal = KHEAP_ALLOC(sizeof (nfsstat)); /* Return value */
  1647.     char *    newName;          /* Path name of directory to remove */
  1649.     if (retVal == NULL)
  1650.         return NULL;
  1652.     if ((newName = (char *) alloca (nfsMaxPath)) == NULL)
  1653. return (NULL);
  1655.     /* Increment statistics */
  1656.     nfsdServerStatus.rmdirCalls++;
  1658.     nfsdFhNtoh ((NFS_FILE_HANDLE *) &removeDir->dir);
  1659.     
  1660.     /* Make sure the file system is writeable */
  1662.     if (nfsdFsReadOnly((NFS_FILE_HANDLE *) &removeDir->dir))
  1663. {
  1664. *retVal = NFSERR_ACCES;
  1665. return (retVal);
  1666. }
  1668.     /* Create the name of the doomed directory */
  1669.     if (nfsdFhToName ((NFS_FILE_HANDLE *) &removeDir->dir, newName) == ERROR)
  1670. {
  1671. *retVal = nfsdErrToNfs (errno);
  1672. return (retVal);
  1673. }
  1675.     strcat (newName, "/");
  1676.     strcat (newName, removeDir->name);
  1678.     /* Remove it */
  1679.     if (rmdir (newName) == ERROR)
  1680. *retVal = nfsdErrToNfs (errno);
  1681.     else
  1682. *retVal = NFS_OK;
  1684.     return (retVal);
  1685.     }
  1687. /******************************************************************************
  1688. *
  1689. * nfsproc_readdir_2 - read from a directory
  1690. * 
  1691. * Returns a variable number of directory entries, with a total size of
  1692. * up to "count" bytes, from the directory given by "dir".  If the
  1693. * returned value of "status" is NFS_OK, then it is followed by a
  1694. * variable number of "entry"s.  Each "entry" contains a "fileid" which
  1695. * consists of a unique number to identify the file within a filesystem,
  1696. * the "name" of the file, and a "cookie" which is an opaque pointer to
  1697. * the next entry in the directory.  The cookie is used in the next
  1698. * READDIR call to get more entries starting at a given point in the
  1699. * directory.  The special cookie zero (all bits zero) can be used to
  1700. * get the entries starting at the beginning of the directory.  The
  1701. * "fileid" field should be the same number as the "fileid" in the the
  1702. * attributes of the file.  (See section "2.3.5. fattr" under "Basic
  1703. * Data Types".)  The "eof" flag has a value of TRUE if there are no
  1704. * more entries in the directory.
  1705. * 
  1706. * NOMANUAL
  1707. */
  1709. readdirres * nfsproc_readdir_2
  1710.     (
  1711.     readdirargs * readDir /* Directory to read */
  1712.     )
  1713.     {
  1714.     struct entry *  dirEntries;
  1715.     filename *      fileNames;
  1716.     int             fileNameSize;
  1717.     int             entrySpace;
  1718.     char *          currentName;
  1719.     char *          dirName;
  1720.     DIR *     theDir = NULL;
  1721.     struct dirent * localEntry;
  1722.     readdirres *    retVal;
  1723.     int     dirCount = 0;
  1724.     char *          newFile;
  1725.     int             numEntries;
  1726.     int             entryCurrent;
  1728.     if ((dirName = (char *) alloca (nfsMaxPath)) == NULL)
  1729. return (NULL);
  1731.     if ((newFile = (char *) alloca (nfsMaxPath)) == NULL)
  1732. return (NULL);
  1734.     /* Increment statistics */
  1735.     nfsdServerStatus.readdirCalls++;
  1737.     /* Compute the amount of space needed for each directory entry */
  1739.     fileNameSize = MEM_ROUND_UP (NAME_LEN + 1);
  1740.     entrySpace = MEM_ROUND_UP (sizeof (readdirres)) +
  1741.          MEM_ROUND_UP (sizeof (entry)) +
  1742.          fileNameSize;
  1743.     
  1744.     /* Compute the number of possible entries to return */
  1745.     
  1746.     numEntries = readDir->count / entrySpace;
  1748.     /* Allocate space for the entries */
  1749.     
  1750.     if ((retVal = KHEAP_ALLOC(numEntries * entrySpace)) == NULL)
  1751. {
  1752.         return (NULL);
  1753. }
  1754.     else
  1755. {
  1756. bzero ((char *) retVal, numEntries * entrySpace);
  1757. dirEntries = ((struct entry *) retVal) + 1;
  1758. fileNames = (filename *) (dirEntries + numEntries);
  1759. }
  1761.     nfsdFhNtoh ((NFS_FILE_HANDLE *) &readDir->dir);
  1762.     
  1763.     /* Create the directory name */
  1764.     if (nfsdFhToName ((NFS_FILE_HANDLE *) &readDir->dir, dirName) == ERROR)
  1765.      {
  1766. retVal->status = nfsdErrToNfs (errno);
  1767. return (retVal);
  1768. }
  1770.     /* Open the directory and set the cookie field to what was
  1771.      * passed in readDir
  1772.      */
  1773.     if ((theDir = opendir (dirName)) == NULL)
  1774.      {
  1775. retVal->status = nfsdErrToNfs (errno);
  1776. return (retVal);
  1777. }
  1778.     else
  1779.         theDir->dd_cookie = *((int *) &readDir->cookie);
  1781.     retVal->readdirres_u.reply.eof = FALSE;
  1782.     
  1783.     /* Read through all the files in the directory */
  1784.     for (entryCurrent = 0; entryCurrent < numEntries; entryCurrent++)
  1785. {
  1786. errno = OK;
  1787. localEntry = readdir (theDir);
  1788. if (localEntry == NULL)
  1789.     {
  1790.     if (errno != OK)
  1791. {
  1792. retVal->status = nfsdErrToNfs (errno);
  1793. closedir (theDir);
  1794. return (retVal);
  1795. }
  1796.     else
  1797. {
  1798. retVal->readdirres_u.reply.eof = TRUE;
  1799. if (entryCurrent != 0)
  1800.     dirEntries[entryCurrent - 1].nextentry = NULL;
  1801. else
  1802.     retVal->readdirres_u.reply.entries = NULL;
  1803.         break;
  1804. }
  1805.     }
  1807. strcpy (newFile, dirName);
  1808. strcat (newFile, "/");
  1809. strcat (newFile, localEntry->d_name);
  1810. dirEntries[entryCurrent].fileid = 
  1811.    nameToInode (((NFS_FILE_HANDLE *) &readDir->dir)->volumeId, newFile);
  1812. if (dirEntries[entryCurrent].fileid == ERROR)
  1813.     {
  1814.     retVal->status = nfsdErrToNfs (errno);
  1815.     closedir (theDir);
  1816.     return (retVal);
  1817.     }
  1818. currentName = ((char *) fileNames) + entryCurrent * fileNameSize;
  1819. strcpy(currentName, localEntry->d_name);
  1820. dirEntries[entryCurrent].name = currentName;
  1821. *((int *) dirEntries[entryCurrent].cookie) = theDir->dd_cookie;
  1823. if (entryCurrent == numEntries - 1)
  1824.     dirEntries[entryCurrent].nextentry = NULL;
  1825. else
  1826.     dirEntries[entryCurrent].nextentry = &dirEntries[entryCurrent + 1];
  1827.     
  1828. dirCount++;
  1829. }
  1831.     retVal->status = NFS_OK;
  1833.     if (dirCount != 0)
  1834. retVal->readdirres_u.reply.entries = dirEntries;
  1835.     else
  1836. retVal->readdirres_u.reply.entries = NULL;
  1838.     closedir (theDir);
  1840.     return (retVal);
  1841.     }
  1843. /******************************************************************************
  1844. *
  1845. * nfsproc_statfs_2 - Get filesystem attributes
  1846. * 
  1847. * Return information about the filesystem.  The NFS equivalent of statfs().
  1848. *
  1849. * NOMANUAL
  1850. */
  1852. statfsres * nfsproc_statfs_2
  1853.     (
  1854.     nfs_fh * fh
  1855.     )
  1856.     {
  1857.     char *        fileName;
  1858.     struct statfs statInfo;
  1859.     statfsres *   retVal = KHEAP_ALLOC(sizeof (statfsres));
  1861.     if (retVal == NULL)
  1862.         return (NULL);
  1864.     if ((fileName = (char *) alloca (nfsMaxPath)) == NULL)
  1865. return (NULL);
  1867.     /* Increment statistics */
  1868.     nfsdServerStatus.statfsCalls++;
  1870.     nfsdFhNtoh ((NFS_FILE_HANDLE *) fh);
  1872.     if (nfsdFhToName ((NFS_FILE_HANDLE *) fh, fileName) == ERROR)
  1873.      {
  1874. retVal->status = nfsdErrToNfs (errno);
  1875. return (retVal);
  1876. }
  1878.     if (statfs (fileName, &statInfo) == ERROR)
  1879.      {
  1880. retVal->status = nfsdErrToNfs (errno);
  1881. return (retVal);
  1882. }
  1884.     retVal->status = NFS_OK;
  1885.     retVal->statfsres_u.reply.tsize  = 8 * 1024;
  1886.     retVal->statfsres_u.reply.bsize  = statInfo.f_bsize;
  1887.     retVal->statfsres_u.reply.blocks = statInfo.f_blocks;
  1888.     retVal->statfsres_u.reply.bfree  = statInfo.f_bfree;
  1889.     retVal->statfsres_u.reply.bavail = statInfo.f_bavail;
  1890.     return (retVal);
  1891.     }
  1893. /******************************************************************************
  1894. *
  1895. * nfsdStatusGet - get the status of the NFS server
  1896. * 
  1897. * This routine gets status information about the NFS server.
  1898. * 
  1899. * RETURNS: OK, or ERROR if the information cannot be obtained.
  1900. */
  1902. STATUS nfsdStatusGet
  1903.     (
  1904.     NFS_SERVER_STATUS * serverStats /* pointer to status structure */
  1905.     )
  1906.     {
  1907.     memcpy (serverStats, &nfsdServerStatus, sizeof (nfsdServerStatus));
  1908.     return (OK);
  1909.     }
  1911. /******************************************************************************
  1912. *
  1913. * nfsdStatusShow - show the status of the NFS server
  1914. * 
  1915. * This routine shows status information about the NFS server.
  1916. * 
  1917. * RETURNS: OK, or ERROR if the information cannot be obtained.
  1918. */
  1920. STATUS nfsdStatusShow
  1921.     (
  1922.     int options /* unused */
  1923.     )
  1924.     {
  1925.     NFS_SERVER_STATUS serverStat;
  1926.     char*             outputFormat = "%15s %8dn";
  1928.     if (nfsdStatusGet (&serverStat) == ERROR)
  1929.         return (ERROR);
  1931.     printf ("%15s    %8sn", "Service", "Number of Calls");
  1932.     printf ("%15s    %8sn", "-------", "---------------");
  1933.     printf (outputFormat, "null", serverStat.nullCalls);
  1934.     printf (outputFormat, "getattr", serverStat.getattrCalls);
  1935.     printf (outputFormat, "setattr", serverStat.setattrCalls);
  1936.     printf (outputFormat, "root", serverStat.rootCalls);
  1937.     printf (outputFormat, "lookup", serverStat.lookupCalls);
  1938.     printf (outputFormat, "readlink", serverStat.readlinkCalls);
  1939.     printf (outputFormat, "read", serverStat.readCalls);
  1940.     printf (outputFormat, "writecache", serverStat.writecacheCalls);
  1941.     printf (outputFormat, "write", serverStat.writeCalls);
  1942.     printf (outputFormat, "create", serverStat.createCalls);
  1943.     printf (outputFormat, "remove", serverStat.removeCalls);
  1944.     printf (outputFormat, "rename", serverStat.renameCalls);
  1945.     printf (outputFormat, "link", serverStat.linkCalls);
  1946.     printf (outputFormat, "symlink", serverStat.symlinkCalls);
  1947.     printf (outputFormat, "mkdir", serverStat.mkdirCalls);
  1948.     printf (outputFormat, "rmdir", serverStat.rmdirCalls);
  1949.     printf (outputFormat, "readdir", serverStat.readdirCalls);
  1950.     printf (outputFormat, "statfs", serverStat.statfsCalls);
  1952.     return (OK);
  1953.     }
  1956. /******************************************************************************
  1957. *
  1958. * nfsdFhCreate - Create an NFS file handle
  1959. *
  1960. * Given a handle to the parent directory, and the name of a file inside that
  1961. * directory, create a new file handle that specifies the file.
  1962. * 
  1963. * RETURNS:  OK, or ERROR if a file handle for the specified file could not be
  1964. * created.
  1965. *
  1966. * NOMANUAL
  1967. */
  1969. STATUS nfsdFhCreate
  1970.     (
  1971.     NFS_FILE_HANDLE * parentDir,
  1972.     char *            fileName,
  1973.     NFS_FILE_HANDLE * fh
  1974.     )
  1975.     {
  1976.     struct stat       str;
  1977.     char *            fullName;
  1978.     char              *p;       /* to remove slash from end of fileName */
  1980.     if ((fullName = (char *) alloca (nfsMaxPath)) == NULL)
  1981. return (ERROR);
  1983.     memset (fh, 0, NFS_FHSIZE);
  1984.     
  1985.     if (nfsdFhToName (parentDir, fullName) == ERROR)
  1986.         return (ERROR);
  1987.     
  1988.     /* build fullname, but remove slash from the end of fileName */
  1989.     /* in order to lkup correspond name from nfsHash             */
  1990.  
  1991.     strcat (fullName, "/");
  1992.     strcat (fullName, fileName);
  1993.     pathCondense (fullName);
  1994.     for (p = strchr (fullName, EOS); p != fullName && *--p == '/'; )
  1995.          *p = EOS;
  1996.     if (stat (fullName, &str) == ERROR)
  1997.         return (ERROR);
  1998.     fh->volumeId = parentDir->volumeId;
  1999.     fh->fsId     = parentDir->fsId;
  2000.     fh->inode    = nfsNmLkupIns (parentDir->volumeId, fullName);
  2001.     if (fh->inode == ERROR)
  2002. return (ERROR);
  2003.     return (OK);
  2004.     }
  2006. /******************************************************************************
  2007. *
  2008. * nfsdFhToName - Convert a file handle to a complete file name
  2009. * 
  2010. * Given a file handle, fill in the variable fileName with a string specifying
  2011. * that file.
  2012. * 
  2013. * RETURNS:  OK, or ERROR if the file name could not be created.
  2014. *
  2015. * NOMANUAL
  2016. */
  2018. STATUS nfsdFhToName
  2019.     (
  2020.     NFS_FILE_HANDLE * fh,
  2021.     char *            fileName
  2022.     )
  2023.     {
  2024.     NFS_EXPORT_ENTRY *  fileSys;
  2026.     if ((fileSys = nfsExportFindById (fh->volumeId)) == NULL)
  2027.         return (ERROR);
  2029.     if (nfsFhLkup (fh, fileName) == ERROR)
  2030.         {
  2031. errno = NFSERR_STALE;
  2032.         return (ERROR);
  2033. }
  2034.     return (OK);
  2035.     }
  2037. /******************************************************************************
  2038. *
  2039. * nfsdFattrGet - Get the file attributes for a file specified by a file handle
  2040. * 
  2041. * Given a file handle, fill in the file attribute structure pointed to by
  2042. * fileAttributes.
  2043. * 
  2044. * RETURNS:  OK, or ERROR if the file attributes could not be obtained.
  2045. *
  2046. * NOMANUAL
  2047. */
  2049. STATUS nfsdFattrGet
  2050.     (
  2051.     NFS_FILE_HANDLE * fh,
  2052.     struct fattr *    fileAttributes
  2053.     )
  2054.     {
  2055.     char *         fileName;
  2056.     struct stat    str;
  2057.     
  2058.     if ((fileName = (char *) alloca (nfsMaxPath)) == NULL)
  2059. return (ERROR);
  2061.     if (nfsdFhToName (fh, fileName) == ERROR)
  2062.         return (ERROR);
  2063.     
  2064.     if (stat (fileName, &str) == ERROR)
  2065.         return (ERROR);
  2067.     /* set the type */
  2069.     switch (str.st_mode & S_IFMT)
  2070. {
  2071. case S_IFIFO:
  2072.     fileAttributes->type = NFFIFO;
  2073.     break;
  2074. case S_IFCHR:
  2075.     fileAttributes->type = NFCHR;
  2076.     break;
  2077. case S_IFDIR:
  2078.     fileAttributes->type = NFDIR;
  2079.     break;
  2080. case S_IFBLK:
  2081.     fileAttributes->type = NFBLK;
  2082.     break;
  2083. case S_IFREG:
  2084.     fileAttributes->type = NFREG;
  2085.     break;
  2086. case S_IFLNK:
  2087.     fileAttributes->type = NFLNK;
  2088.     break;
  2089. case S_IFSOCK:
  2090.     fileAttributes->type = NFSOCK;
  2091.     break;
  2092. }
  2094.     fileAttributes->mode      = str.st_mode;
  2095.     fileAttributes->nlink     = str.st_nlink;
  2096.     fileAttributes->uid       = str.st_uid;
  2097.     fileAttributes->gid       = str.st_gid;
  2098.     fileAttributes->size      = str.st_size;
  2099.     fileAttributes->blocksize = str.st_blksize;
  2100.     fileAttributes->rdev      = str.st_rdev;
  2101.     fileAttributes->blocks    = str.st_blocks + 1;
  2102.     fileAttributes->fileid    = fh->inode;
  2103.     fileAttributes->fsid      = str.st_dev;
  2104.     fileAttributes->rdev      = str.st_rdev;
  2106.     fileAttributes->atime.seconds = str.st_atime;
  2107.     fileAttributes->mtime.seconds = str.st_mtime;
  2108.     fileAttributes->ctime.seconds = str.st_ctime;
  2110.     fileAttributes->atime.useconds = 0;
  2111.     fileAttributes->mtime.useconds = 0;
  2112.     fileAttributes->ctime.useconds = 0;
  2114.     return (OK);
  2115.     }
  2117. /******************************************************************************
  2118. *
  2119. * nfsdErrToNfs - Convert a VxWorks error number to an NFS error number
  2120. * 
  2121. * Given a VxWorks error number, find the equivalent NFS error number.
  2122. * If an exact match is not found, return NFSERR_IO.
  2123. * 
  2124. * RETURNS:  The NFS error number.
  2125. *
  2126. * NOMANUAL
  2127. */
  2129. nfsstat nfsdErrToNfs
  2130.     (
  2131.     int theErr /* The error number to convert  */
  2132.     )
  2133.     {
  2134.     switch (theErr)
  2135. {
  2136. case EPERM:
  2137. case S_dosFsLib_READ_ONLY:
  2138. case S_dosFsLib_WRITE_ONLY:
  2139.     return (NFSERR_PERM);
  2140.     break;
  2141.     
  2142. case ENOENT:
  2143. case S_dosFsLib_FILE_NOT_FOUND:
  2144.     return (NFSERR_NOENT);
  2145.     break;
  2147. case EIO:
  2148.     return (NFSERR_IO);
  2149.     break;
  2150.     
  2151. case ENXIO:
  2152. case S_dosFsLib_VOLUME_NOT_AVAILABLE:
  2153.     return (NFSERR_NXIO);
  2154.     break;
  2155.     
  2156. case EACCES:
  2157.     return (NFSERR_ACCES);
  2158.     break;
  2159.     
  2160. case EEXIST:
  2161. case S_dosFsLib_FILE_EXISTS:
  2162.     return (NFSERR_EXIST);
  2163.     break;
  2165. case ENODEV:
  2166.     return (NFSERR_NODEV);
  2167.     break;
  2168.     
  2169. case ENOTDIR:
  2170. case S_dosFsLib_NOT_DIRECTORY:
  2171.     return (NFSERR_NOTDIR);
  2172.     break;
  2173.     
  2174. case EISDIR:
  2175.     return (NFSERR_ISDIR);
  2176.     break;
  2177.     
  2178. case EFBIG:
  2179.     return (NFSERR_FBIG);
  2180.     break;
  2181.     
  2182. case ENOSPC:
  2183. case S_dosFsLib_DISK_FULL:
  2184.     return (NFSERR_NOSPC);
  2185.     break;
  2186.     
  2187. case EROFS:
  2188.     return (NFSERR_ROFS);
  2189.     break;
  2190.     
  2191. case ENAMETOOLONG:
  2192. case S_dosFsLib_ILLEGAL_NAME:
  2193.     return (NFSERR_NAMETOOLONG);
  2194.     break;
  2195.     
  2196. case S_dosFsLib_DIR_NOT_EMPTY:
  2197. case ENOTEMPTY:
  2198.     return (NFSERR_NOTEMPTY);
  2199.     break;
  2200.     
  2201.         default:
  2202.     /* If the error number is less than 100, just return it.
  2203.      * NFS client implementations should understand anything
  2204.      * that looks like a UNIX error number.  If it's greater than
  2205.      * 100, return NFSERR_IO.
  2206.      */
  2208.     if (theErr < 100)
  2209. return theErr;
  2210.     else
  2211. return (NFSERR_IO);
  2213.     break;
  2214. }
  2215.     }
  2218. /******************************************************************************
  2219. *
  2220. * nfsdFhHton - convert a file handle from host to network byte order
  2221. *
  2222. * NOMANUAL
  2223. */
  2225. void nfsdFhHton
  2226.     (
  2227.     NFS_FILE_HANDLE * fh
  2228.     )
  2229.     {
  2230.     fh->volumeId = htonl (fh->volumeId);
  2231.     fh->fsId = htonl (fh->fsId);
  2232.     fh->inode = htonl (fh->inode);
  2233.     }
  2235. /******************************************************************************
  2236. *
  2237. * nfsdFhNtoh - convert a file handle from host to network byte order
  2238. *
  2239. * NOMANUAL
  2240. */
  2242. void nfsdFhNtoh
  2243.     (
  2244.     NFS_FILE_HANDLE * fh
  2245.     )
  2246.     {
  2247.     fh->volumeId = ntohl (fh->volumeId);
  2248.     fh->fsId = ntohl (fh->fsId);
  2249.     fh->inode = ntohl (fh->inode);
  2250.     }
  2252. /******************************************************************************
  2253. *
  2254. * nfsdFsReadOnly - get the mode of the NFS file system
  2255. * 
  2256. * This routine returns TRUE if the filesystem that contains the file
  2257. * pointed to by <fh> is exported read-only.
  2258. * 
  2259. * RETURNS: TRUE, or FALSE if the filesystem is exported read-write.
  2260. * 
  2261. * NOMANUAL
  2262. */
  2264. LOCAL BOOL nfsdFsReadOnly
  2265.     (
  2266.     NFS_FILE_HANDLE * fh
  2267.     )
  2268.     {
  2269.     NFS_EXPORT_ENTRY *  fileSys;
  2271.     if ((fileSys = nfsExportFindById (fh->volumeId)) == NULL)
  2272.         return (ERROR);
  2273.     else
  2274. return (fileSys->readOnly);
  2275.     }