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

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

VxWorks

开发平台：

C/C++

xdr_nfs.c：源码内容
  1. /* xdr_nfs.c  - xdr routines for nfs */
  3. /* Copyright 1984-1997 Wind River Systems, Inc. */
  4. #include "copyright_wrs.h"
  6. /*
  7. modification history
  8. --------------------
  9. 01i,26aug97,spm  removed compiler warnings (SPR #7866)
  10. 01h,08sep94,jmm  replaced all routines with routines from rpcgen
  11. 01g,15sep92,jcf  changed "struct name" to "struct nfsName".
  12. 01f,26may92,rrr  the tree shuffle
  13. 01e,19nov91,rrr  shut up some ansi warnings.
  14. 01d,04oct91,rrr  passed through the ansification filter
  15.                   -changed functions to ansi style
  16.   -changed includes to have absolute path from h/
  17.   -changed copyright notice
  18. 01c,15may90,dnw  fixed bug in xdr_{pathstat,attrstat,diropres,readreply,
  19.    readdirres} of returning FALSE if returned NFS status
  20.    was not NFS_OK, and xdr_{mountentries,exportbody} returning
  21.    FALSE if more_entries was FALSE.  This had the effect of
  22.    invalidating the entire RPC reply (hence RPC_CANTDECODERES).
  23.    This was due to a mistake in the original xdr_nfs.x file
  24.    that had no "default" case specifed for these unions
  25.    (should be "default: void;").
  26.  changed to use POSIX NAME_MAX from dirent.h:
  27.    - xdr_filename to take NAME_MAX instead of NFS_MAXNAMLEN
  28.    - xdr_path to take PATH_MAX instead of NFS_MAXPATHLEN
  29.  recoded xdr_mountlist and xdr_mountentries to not be recursive.
  30.    This is patterned after the discussion in the "Advanced
  31.    Topics" chapter of the "XDR: Sun Technical Notes" document
  32.    (xdr.nts.ms distributed with rpc 4.0), except that I
  33.    believe the example in the document is wrong.  The example
  34.    references memory that may have been freed, even though
  35.    the narrative says they are avoiding exactly that.
  36.    Note that xdr_readdirres and xdr_exportbody remain
  37.    recursive, although they could be coded in the same way
  38.    as xdr_mountentries.
  39.  added xdr_readdirresOne which reads only one entry from
  40.    a directory read request, and discards the rest.
  41.    This is used by nfsDirReadOne() in nfsLib and is strictly
  42.    a hack to avoid unnecessary malloc/frees for the unwanted
  43.    additional entries.
  44. 01b,20oct89,hjb  changed "struct timeval" to nfsTimeval to avoid conflicts
  45.  with the definition of "struct timeval" in "utime.h".
  46. 01a,19apr88,llk  created.
  47. */
  49. /*
  50. DESCRIPTION
  51. This module contains the eXternal Data Representation (XDR) routines for NFS.
  53. This module could (and should) be generated from a .x, but there have
  54. been tweaks as noted in the mod history above.
  56. As of 8 Sep 1994, the routines in this file are exactly as generated from
  57. rpcgen.  All of the old modified routines have been removed.
  58. */
  60. /*
  61.  * Please do not edit this file.
  62.  * It was generated using rpcgen.
  63.  */
  65. #include <rpc/rpc.h>
  66. #include "xdr_nfs.h"
  68. bool_t
  69. xdr_nfsstat(xdrs, objp)
  70. XDR *xdrs;
  71. nfsstat *objp;
  72. {
  73. if (!xdr_enum(xdrs, (enum_t *)objp)) {
  74. return (FALSE);
  75. }
  76. return (TRUE);
  77. }
  79. bool_t
  80. xdr_ftype(xdrs, objp)
  81. XDR *xdrs;
  82. ftype *objp;
  83. {
  84. if (!xdr_enum(xdrs, (enum_t *)objp)) {
  85. return (FALSE);
  86. }
  87. return (TRUE);
  88. }
  90. bool_t
  91. xdr_nfs_fh(xdrs, objp)
  92. XDR *xdrs;
  93. nfs_fh *objp;
  94. {
  95. if (!xdr_opaque(xdrs, objp->data, NFS_FHSIZE)) {
  96. return (FALSE);
  97. }
  98. return (TRUE);
  99. }
  101. bool_t
  102. xdr_nfstime(xdrs, objp)
  103. XDR *xdrs;
  104. nfstime *objp;
  105. {
  106. if (!xdr_u_int(xdrs, &objp->seconds)) {
  107. return (FALSE);
  108. }
  109. if (!xdr_u_int(xdrs, &objp->useconds)) {
  110. return (FALSE);
  111. }
  112. return (TRUE);
  113. }
  115. bool_t
  116. xdr_fattr(xdrs, objp)
  117. XDR *xdrs;
  118. fattr *objp;
  119. {
  120. if (!xdr_ftype(xdrs, &objp->type)) {
  121. return (FALSE);
  122. }
  123. if (!xdr_u_int(xdrs, &objp->mode)) {
  124. return (FALSE);
  125. }
  126. if (!xdr_u_int(xdrs, &objp->nlink)) {
  127. return (FALSE);
  128. }
  129. if (!xdr_u_int(xdrs, &objp->uid)) {
  130. return (FALSE);
  131. }
  132. if (!xdr_u_int(xdrs, &objp->gid)) {
  133. return (FALSE);
  134. }
  135. if (!xdr_u_int(xdrs, &objp->size)) {
  136. return (FALSE);
  137. }
  138. if (!xdr_u_int(xdrs, &objp->blocksize)) {
  139. return (FALSE);
  140. }
  141. if (!xdr_u_int(xdrs, &objp->rdev)) {
  142. return (FALSE);
  143. }
  144. if (!xdr_u_int(xdrs, &objp->blocks)) {
  145. return (FALSE);
  146. }
  147. if (!xdr_u_int(xdrs, &objp->fsid)) {
  148. return (FALSE);
  149. }
  150. if (!xdr_u_int(xdrs, &objp->fileid)) {
  151. return (FALSE);
  152. }
  153. if (!xdr_nfstime(xdrs, &objp->atime)) {
  154. return (FALSE);
  155. }
  156. if (!xdr_nfstime(xdrs, &objp->mtime)) {
  157. return (FALSE);
  158. }
  159. if (!xdr_nfstime(xdrs, &objp->ctime)) {
  160. return (FALSE);
  161. }
  162. return (TRUE);
  163. }
  165. bool_t
  166. xdr_sattr(xdrs, objp)
  167. XDR *xdrs;
  168. sattr *objp;
  169. {
  170. if (!xdr_u_int(xdrs, &objp->mode)) {
  171. return (FALSE);
  172. }
  173. if (!xdr_u_int(xdrs, &objp->uid)) {
  174. return (FALSE);
  175. }
  176. if (!xdr_u_int(xdrs, &objp->gid)) {
  177. return (FALSE);
  178. }
  179. if (!xdr_u_int(xdrs, &objp->size)) {
  180. return (FALSE);
  181. }
  182. if (!xdr_nfstime(xdrs, &objp->atime)) {
  183. return (FALSE);
  184. }
  185. if (!xdr_nfstime(xdrs, &objp->mtime)) {
  186. return (FALSE);
  187. }
  188. return (TRUE);
  189. }
  191. bool_t
  192. xdr_filename(xdrs, objp)
  193. XDR *xdrs;
  194. filename *objp;
  195. {
  196. if (!xdr_string(xdrs, objp, NFS_MAXNAMLEN)) {
  197. return (FALSE);
  198. }
  199. return (TRUE);
  200. }
  202. bool_t
  203. xdr_nfspath(xdrs, objp)
  204. XDR *xdrs;
  205. nfspath *objp;
  206. {
  207. if (!xdr_string(xdrs, objp, NFS_MAXPATHLEN)) {
  208. return (FALSE);
  209. }
  210. return (TRUE);
  211. }
  213. bool_t xdr_attrstat
  214.     (
  215.     XDR *xdrs,
  216.     attrstat *objp
  217.     )
  218.     {
  219.     if (!xdr_nfsstat (xdrs, &objp->status)) 
  220.         {
  221.         return (FALSE);
  222.         }
  223.     switch (objp->status) 
  224.         {
  225.         case NFS_OK:
  226.             if (!xdr_fattr (xdrs, &objp->attrstat_u.attributes)) 
  227.                 {
  228.                 return (FALSE);
  229.                 }
  230.             break;
  232.         default:    /* Eliminates warnings for other enumeration values. */
  233.             break;
  234.         }
  235.     return (TRUE);
  236.     }
  238. bool_t
  239. xdr_sattrargs(xdrs, objp)
  240. XDR *xdrs;
  241. sattrargs *objp;
  242. {
  243. if (!xdr_nfs_fh(xdrs, &objp->file)) {
  244. return (FALSE);
  245. }
  246. if (!xdr_sattr(xdrs, &objp->attributes)) {
  247. return (FALSE);
  248. }
  249. return (TRUE);
  250. }
  252. bool_t
  253. xdr_diropargs(xdrs, objp)
  254. XDR *xdrs;
  255. diropargs *objp;
  256. {
  257. if (!xdr_nfs_fh(xdrs, &objp->dir)) {
  258. return (FALSE);
  259. }
  260. if (!xdr_filename(xdrs, &objp->name)) {
  261. return (FALSE);
  262. }
  263. return (TRUE);
  264. }
  266. bool_t
  267. xdr_diropokres(xdrs, objp)
  268. XDR *xdrs;
  269. diropokres *objp;
  270. {
  271. if (!xdr_nfs_fh(xdrs, &objp->file)) {
  272. return (FALSE);
  273. }
  274. if (!xdr_fattr(xdrs, &objp->attributes)) {
  275. return (FALSE);
  276. }
  277. return (TRUE);
  278. }
  280. bool_t xdr_diropres
  281.     (
  282.     XDR *xdrs,
  283.     diropres *objp
  284.     )
  285.     {
  286.     if (!xdr_nfsstat (xdrs, &objp->status)) 
  287.         {
  288.         return (FALSE);
  289.         }
  290.     switch (objp->status) 
  291.         {
  292. case NFS_OK:
  293.             if (!xdr_diropokres (xdrs, &objp->diropres_u.diropres)) 
  294.                 {
  295.                 return (FALSE);
  296.                 }
  297.         break;
  299.         default:    /* Eliminates warnings for other enumeration values. */
  300.             break;
  301.         }
  302.     return (TRUE);
  303.     }
  305. bool_t xdr_readlinkres
  306.     (
  307.     XDR *xdrs,
  308.     readlinkres *objp
  309.     )
  310.     {
  311.     if (!xdr_nfsstat (xdrs, &objp->status)) 
  312.         {
  313.         return (FALSE);
  314.         }
  315.     switch (objp->status) 
  316.         {
  317.         case NFS_OK:
  318.             if (!xdr_nfspath (xdrs, &objp->readlinkres_u.data)) 
  319.                 {
  320.                 return (FALSE);
  321.                 }
  322.             break;
  324.         default:    /* Eliminates warnings for other enumeration values. */
  325.             break;
  326.         }
  327.     return (TRUE);
  328.     }
  330. bool_t
  331. xdr_readargs(xdrs, objp)
  332. XDR *xdrs;
  333. readargs *objp;
  334. {
  335. if (!xdr_nfs_fh(xdrs, &objp->file)) {
  336. return (FALSE);
  337. }
  338. if (!xdr_u_int(xdrs, &objp->offset)) {
  339. return (FALSE);
  340. }
  341. if (!xdr_u_int(xdrs, &objp->count)) {
  342. return (FALSE);
  343. }
  344. if (!xdr_u_int(xdrs, &objp->totalcount)) {
  345. return (FALSE);
  346. }
  347. return (TRUE);
  348. }
  350. bool_t
  351. xdr_readokres(xdrs, objp)
  352. XDR *xdrs;
  353. readokres *objp;
  354. {
  355. if (!xdr_fattr(xdrs, &objp->attributes)) {
  356. return (FALSE);
  357. }
  358. if (!xdr_bytes(xdrs, (char **)&objp->data.data_val, (u_int *)&objp->data.data_len, NFS_MAXDATA)) {
  359. return (FALSE);
  360. }
  361. return (TRUE);
  362. }
  364. bool_t xdr_readres
  365.     (
  366.     XDR *xdrs,
  367.     readres *objp
  368.     )
  369.     {
  370.     if (!xdr_nfsstat (xdrs, &objp->status)) 
  371.         {
  372.         return (FALSE);
  373.         }
  374.     switch (objp->status) 
  375.         {
  376.         case NFS_OK:
  377.             if (!xdr_readokres(xdrs, &objp->readres_u.reply)) 
  378.                 {
  379.                 return (FALSE);
  380.                 }
  381.             break;
  383.         default:    /* Eliminates warnings for other enumeration values. */
  384.             break;
  385.         }
  386.     return (TRUE);
  387.     }
  389. bool_t
  390. xdr_writeargs(xdrs, objp)
  391. XDR *xdrs;
  392. writeargs *objp;
  393. {
  394. if (!xdr_nfs_fh(xdrs, &objp->file)) {
  395. return (FALSE);
  396. }
  397. if (!xdr_u_int(xdrs, &objp->beginoffset)) {
  398. return (FALSE);
  399. }
  400. if (!xdr_u_int(xdrs, &objp->offset)) {
  401. return (FALSE);
  402. }
  403. if (!xdr_u_int(xdrs, &objp->totalcount)) {
  404. return (FALSE);
  405. }
  406. if (!xdr_bytes(xdrs, (char **)&objp->data.data_val, (u_int *)&objp->data.data_len, NFS_MAXDATA)) {
  407. return (FALSE);
  408. }
  409. return (TRUE);
  410. }
  412. bool_t
  413. xdr_createargs(xdrs, objp)
  414. XDR *xdrs;
  415. createargs *objp;
  416. {
  417. if (!xdr_diropargs(xdrs, &objp->where)) {
  418. return (FALSE);
  419. }
  420. if (!xdr_sattr(xdrs, &objp->attributes)) {
  421. return (FALSE);
  422. }
  423. return (TRUE);
  424. }
  426. bool_t
  427. xdr_renameargs(xdrs, objp)
  428. XDR *xdrs;
  429. renameargs *objp;
  430. {
  431. if (!xdr_diropargs(xdrs, &objp->from)) {
  432. return (FALSE);
  433. }
  434. if (!xdr_diropargs(xdrs, &objp->to)) {
  435. return (FALSE);
  436. }
  437. return (TRUE);
  438. }
  440. bool_t
  441. xdr_linkargs(xdrs, objp)
  442. XDR *xdrs;
  443. linkargs *objp;
  444. {
  445. if (!xdr_nfs_fh(xdrs, &objp->from)) {
  446. return (FALSE);
  447. }
  448. if (!xdr_diropargs(xdrs, &objp->to)) {
  449. return (FALSE);
  450. }
  451. return (TRUE);
  452. }
  454. bool_t
  455. xdr_symlinkargs(xdrs, objp)
  456. XDR *xdrs;
  457. symlinkargs *objp;
  458. {
  459. if (!xdr_diropargs(xdrs, &objp->from)) {
  460. return (FALSE);
  461. }
  462. if (!xdr_nfspath(xdrs, &objp->to)) {
  463. return (FALSE);
  464. }
  465. if (!xdr_sattr(xdrs, &objp->attributes)) {
  466. return (FALSE);
  467. }
  468. return (TRUE);
  469. }
  471. bool_t
  472. xdr_nfscookie(xdrs, objp)
  473. XDR *xdrs;
  474. nfscookie objp;
  475. {
  476. if (!xdr_opaque(xdrs, objp, NFS_COOKIESIZE)) {
  477. return (FALSE);
  478. }
  479. return (TRUE);
  480. }
  482. bool_t
  483. xdr_readdirargs(xdrs, objp)
  484. XDR *xdrs;
  485. readdirargs *objp;
  486. {
  487. if (!xdr_nfs_fh(xdrs, &objp->dir)) {
  488. return (FALSE);
  489. }
  490. if (!xdr_nfscookie(xdrs, objp->cookie)) {
  491. return (FALSE);
  492. }
  493. if (!xdr_u_int(xdrs, &objp->count)) {
  494. return (FALSE);
  495. }
  496. return (TRUE);
  497. }
  499. bool_t
  500. xdr_entry(xdrs, objp)
  501. XDR *xdrs;
  502. entry *objp;
  503. {
  504. if (!xdr_u_int(xdrs, &objp->fileid)) {
  505. return (FALSE);
  506. }
  507. if (!xdr_filename(xdrs, &objp->name)) {
  508. return (FALSE);
  509. }
  510. if (!xdr_nfscookie(xdrs, objp->cookie)) {
  511. return (FALSE);
  512. }
  513. if (!xdr_pointer(xdrs, (char **)&objp->nextentry, sizeof(entry), xdr_entry)) {
  514. return (FALSE);
  515. }
  516. return (TRUE);
  517. }
  519. bool_t
  520. xdr_dirlist(xdrs, objp)
  521. XDR *xdrs;
  522. dirlist *objp;
  523. {
  524. if (!xdr_pointer(xdrs, (char **)&objp->entries, sizeof(entry), xdr_entry)) {
  525. return (FALSE);
  526. }
  527. if (!xdr_bool(xdrs, &objp->eof)) {
  528. return (FALSE);
  529. }
  530. return (TRUE);
  531. }
  533. bool_t xdr_readdirres
  534.     (
  535.     XDR *xdrs,
  536.     readdirres *objp
  537.     )
  538.     {
  539.     if (!xdr_nfsstat (xdrs, &objp->status)) 
  540.         {
  541.         return (FALSE);
  542.         }
  543.     switch (objp->status) 
  544.         {
  545.         case NFS_OK:
  546.             if (!xdr_dirlist (xdrs, &objp->readdirres_u.reply)) 
  547.                 {
  548.                 return (FALSE);
  549.                 }
  550.             break;
  552.         default:    /* Eliminates warnings for other enumeration values. */
  553.             break;
  554. }
  555.     return (TRUE);
  556.     }
  558. bool_t
  559. xdr_statfsokres(xdrs, objp)
  560. XDR *xdrs;
  561. statfsokres *objp;
  562. {
  563. if (!xdr_u_int(xdrs, &objp->tsize)) {
  564. return (FALSE);
  565. }
  566. if (!xdr_u_int(xdrs, &objp->bsize)) {
  567. return (FALSE);
  568. }
  569. if (!xdr_u_int(xdrs, &objp->blocks)) {
  570. return (FALSE);
  571. }
  572. if (!xdr_u_int(xdrs, &objp->bfree)) {
  573. return (FALSE);
  574. }
  575. if (!xdr_u_int(xdrs, &objp->bavail)) {
  576. return (FALSE);
  577. }
  578. return (TRUE);
  579. }
  581. bool_t xdr_statfsres
  582.     (
  583.     XDR *xdrs,
  584.     statfsres *objp
  585.     )
  586.     {
  587.     if (!xdr_nfsstat(xdrs, &objp->status)) 
  588.         {
  589.         return (FALSE);
  590.         }
  591.     switch (objp->status) 
  592.         {
  593.         case NFS_OK:
  594.             if (!xdr_statfsokres(xdrs, &objp->statfsres_u.reply)) 
  595.                 {
  596.                 return (FALSE);
  597.                 }
  598.             break;
  600.         default:    /* Eliminates warnings for other enumeration values. */
  601.             break;
  602.         }
  603.     return (TRUE);
  604.     }