home *** CD-ROM | disk | FTP | other *** search
/ Big Green CD 8 / BGCD_8_Dev.iso / NEXTSTEP / UNIX / Utilities / vmount-0.6a-I / src / nfs / nfs_prot_xdr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-11-14  |  9.4 KB  |  632 lines
  1. #include <rpc/rpc.h>
  2. #include "nfs_prot.h"
  3. /*
  4.  * Sun RPC is a product of Sun Microsystems, Inc. and is provided for
  5.  * unrestricted use provided that this legend is included on all tape
  6.  * media and as a part of the software program in whole or part.  Users
  7.  * may copy or modify Sun RPC without charge, but are not authorized
  8.  * to license or distribute it to anyone else except as part of a product or
  9.  * program developed by the user or with the express written consent of
  10.  * Sun Microsystems, Inc.
  11.  *
  12.  * SUN RPC IS PROVIDED AS IS WITH NO WARRANTIES OF ANY KIND INCLUDING THE
  13.  * WARRANTIES OF DESIGN, MERCHANTIBILITY AND FITNESS FOR A PARTICULAR
  14.  * PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE OR TRADE PRACTICE.
  15.  *
  16.  * Sun RPC is provided with no support and without any obligation on the
  17.  * part of Sun Microsystems, Inc. to assist in its use, correction,
  18.  * modification or enhancement.
  19.  *
  20.  * SUN MICROSYSTEMS, INC. SHALL HAVE NO LIABILITY WITH RESPECT TO THE
  21.  * INFRINGEMENT OF COPYRIGHTS, TRADE SECRETS OR ANY PATENTS BY SUN RPC
  22.  * OR ANY PART THEREOF.
  23.  *
  24.  * In no event will Sun Microsystems, Inc. be liable for any lost revenue
  25.  * or profits or other special, indirect and consequential damages, even if
  26.  * Sun has been advised of the possibility of such damages.
  27.  *
  28.  * Sun Microsystems, Inc.
  29.  * 2550 Garcia Avenue
  30.  * Mountain View, California  94043
  31.  */
  32. /*
  33.  * Copyright (c) 1987, 1990 by Sun Microsystems, Inc.
  34.  */
  35.  
  36. /* from @(#)nfs_prot.x    1.3 91/03/11 TIRPC 1.0 */
  37.  
  38.  
  39. bool_t
  40. xdr_nfsstat(xdrs, objp)
  41.     XDR *xdrs;
  42.     nfsstat *objp;
  43. {
  44.     if (!xdr_enum(xdrs, (enum_t *)objp)) {
  45.         return (FALSE);
  46.     }
  47.     return (TRUE);
  48. }
  49.  
  50.  
  51.  
  52.  
  53. bool_t
  54. xdr_ftype(xdrs, objp)
  55.     XDR *xdrs;
  56.     ftype *objp;
  57. {
  58.     if (!xdr_enum(xdrs, (enum_t *)objp)) {
  59.         return (FALSE);
  60.     }
  61.     return (TRUE);
  62. }
  63.  
  64.  
  65.  
  66.  
  67. bool_t
  68. xdr_nfs_fh(xdrs, objp)
  69.     XDR *xdrs;
  70.     nfs_fh *objp;
  71. {
  72.     if (!xdr_opaque(xdrs, objp->data, NFS_FHSIZE)) {
  73.         return (FALSE);
  74.     }
  75.     return (TRUE);
  76. }
  77.  
  78.  
  79.  
  80.  
  81. bool_t
  82. xdr_nfstime(xdrs, objp)
  83.     XDR *xdrs;
  84.     nfstime *objp;
  85. {
  86.     if (!xdr_u_int(xdrs, &objp->seconds)) {
  87.         return (FALSE);
  88.     }
  89.     if (!xdr_u_int(xdrs, &objp->useconds)) {
  90.         return (FALSE);
  91.     }
  92.     return (TRUE);
  93. }
  94.  
  95.  
  96.  
  97.  
  98. bool_t
  99. xdr_fattr(xdrs, objp)
  100.     XDR *xdrs;
  101.     fattr *objp;
  102. {
  103.     if (!xdr_ftype(xdrs, &objp->type)) {
  104.         return (FALSE);
  105.     }
  106.     if (!xdr_u_int(xdrs, &objp->mode)) {
  107.         return (FALSE);
  108.     }
  109.     if (!xdr_u_int(xdrs, &objp->nlink)) {
  110.         return (FALSE);
  111.     }
  112.     if (!xdr_u_int(xdrs, &objp->uid)) {
  113.         return (FALSE);
  114.     }
  115.     if (!xdr_u_int(xdrs, &objp->gid)) {
  116.         return (FALSE);
  117.     }
  118.     if (!xdr_u_int(xdrs, &objp->size)) {
  119.         return (FALSE);
  120.     }
  121.     if (!xdr_u_int(xdrs, &objp->blocksize)) {
  122.         return (FALSE);
  123.     }
  124.     if (!xdr_u_int(xdrs, &objp->rdev)) {
  125.         return (FALSE);
  126.     }
  127.     if (!xdr_u_int(xdrs, &objp->blocks)) {
  128.         return (FALSE);
  129.     }
  130.     if (!xdr_u_int(xdrs, &objp->fsid)) {
  131.         return (FALSE);
  132.     }
  133.     if (!xdr_u_int(xdrs, &objp->fileid)) {
  134.         return (FALSE);
  135.     }
  136.     if (!xdr_nfstime(xdrs, &objp->atime)) {
  137.         return (FALSE);
  138.     }
  139.     if (!xdr_nfstime(xdrs, &objp->mtime)) {
  140.         return (FALSE);
  141.     }
  142.     if (!xdr_nfstime(xdrs, &objp->ctime)) {
  143.         return (FALSE);
  144.     }
  145.     return (TRUE);
  146. }
  147.  
  148.  
  149.  
  150.  
  151. bool_t
  152. xdr_sattr(xdrs, objp)
  153.     XDR *xdrs;
  154.     sattr *objp;
  155. {
  156.     if (!xdr_u_int(xdrs, &objp->mode)) {
  157.         return (FALSE);
  158.     }
  159.     if (!xdr_u_int(xdrs, &objp->uid)) {
  160.         return (FALSE);
  161.     }
  162.     if (!xdr_u_int(xdrs, &objp->gid)) {
  163.         return (FALSE);
  164.     }
  165.     if (!xdr_u_int(xdrs, &objp->size)) {
  166.         return (FALSE);
  167.     }
  168.     if (!xdr_nfstime(xdrs, &objp->atime)) {
  169.         return (FALSE);
  170.     }
  171.     if (!xdr_nfstime(xdrs, &objp->mtime)) {
  172.         return (FALSE);
  173.     }
  174.     return (TRUE);
  175. }
  176.  
  177.  
  178.  
  179.  
  180. bool_t
  181. xdr_filename(xdrs, objp)
  182.     XDR *xdrs;
  183.     filename *objp;
  184. {
  185.     if (!xdr_string(xdrs, objp, NFS_MAXNAMLEN)) {
  186.         return (FALSE);
  187.     }
  188.     return (TRUE);
  189. }
  190.  
  191.  
  192.  
  193.  
  194. bool_t
  195. xdr_nfspath(xdrs, objp)
  196.     XDR *xdrs;
  197.     nfspath *objp;
  198. {
  199.     if (!xdr_string(xdrs, objp, NFS_MAXPATHLEN)) {
  200.         return (FALSE);
  201.     }
  202.     return (TRUE);
  203. }
  204.  
  205.  
  206.  
  207.  
  208. bool_t
  209. xdr_attrstat(xdrs, objp)
  210.     XDR *xdrs;
  211.     attrstat *objp;
  212. {
  213.     if (!xdr_nfsstat(xdrs, &objp->status)) {
  214.         return (FALSE);
  215.     }
  216.     switch (objp->status) {
  217.     case NFS_OK:
  218.         if (!xdr_fattr(xdrs, &objp->attrstat_u.attributes)) {
  219.             return (FALSE);
  220.         }
  221.         break;
  222.     default:
  223.         break;
  224.     }
  225.     return (TRUE);
  226. }
  227.  
  228.  
  229.  
  230.  
  231. bool_t
  232. xdr_sattrargs(xdrs, objp)
  233.     XDR *xdrs;
  234.     sattrargs *objp;
  235. {
  236.     if (!xdr_nfs_fh(xdrs, &objp->file)) {
  237.         return (FALSE);
  238.     }
  239.     if (!xdr_sattr(xdrs, &objp->attributes)) {
  240.         return (FALSE);
  241.     }
  242.     return (TRUE);
  243. }
  244.  
  245.  
  246.  
  247.  
  248. bool_t
  249. xdr_diropargs(xdrs, objp)
  250.     XDR *xdrs;
  251.     diropargs *objp;
  252. {
  253.     if (!xdr_nfs_fh(xdrs, &objp->dir)) {
  254.         return (FALSE);
  255.     }
  256.     if (!xdr_filename(xdrs, &objp->name)) {
  257.         return (FALSE);
  258.     }
  259.     return (TRUE);
  260. }
  261.  
  262.  
  263.  
  264.  
  265. bool_t
  266. xdr_diropokres(xdrs, objp)
  267.     XDR *xdrs;
  268.     diropokres *objp;
  269. {
  270.     if (!xdr_nfs_fh(xdrs, &objp->file)) {
  271.         return (FALSE);
  272.     }
  273.     if (!xdr_fattr(xdrs, &objp->attributes)) {
  274.         return (FALSE);
  275.     }
  276.     return (TRUE);
  277. }
  278.  
  279.  
  280.  
  281.  
  282. bool_t
  283. xdr_diropres(xdrs, objp)
  284.     XDR *xdrs;
  285.     diropres *objp;
  286. {
  287.     if (!xdr_nfsstat(xdrs, &objp->status)) {
  288.         return (FALSE);
  289.     }
  290.     switch (objp->status) {
  291.     case NFS_OK:
  292.         if (!xdr_diropokres(xdrs, &objp->diropres_u.diropres)) {
  293.             return (FALSE);
  294.         }
  295.         break;
  296.     default:
  297.         break;
  298.     }
  299.     return (TRUE);
  300. }
  301.  
  302.  
  303.  
  304.  
  305. bool_t
  306. xdr_readlinkres(xdrs, objp)
  307.     XDR *xdrs;
  308.     readlinkres *objp;
  309. {
  310.     if (!xdr_nfsstat(xdrs, &objp->status)) {
  311.         return (FALSE);
  312.     }
  313.     switch (objp->status) {
  314.     case NFS_OK:
  315.         if (!xdr_nfspath(xdrs, &objp->readlinkres_u.data)) {
  316.             return (FALSE);
  317.         }
  318.         break;
  319.     default:
  320.         break;
  321.     }
  322.     return (TRUE);
  323. }
  324.  
  325.  
  326.  
  327.  
  328. bool_t
  329. xdr_readargs(xdrs, objp)
  330.     XDR *xdrs;
  331.     readargs *objp;
  332. {
  333.     if (!xdr_nfs_fh(xdrs, &objp->file)) {
  334.         return (FALSE);
  335.     }
  336.     if (!xdr_u_int(xdrs, &objp->offset)) {
  337.         return (FALSE);
  338.     }
  339.     if (!xdr_u_int(xdrs, &objp->count)) {
  340.         return (FALSE);
  341.     }
  342.     if (!xdr_u_int(xdrs, &objp->totalcount)) {
  343.         return (FALSE);
  344.     }
  345.     return (TRUE);
  346. }
  347.  
  348.  
  349.  
  350.  
  351. bool_t
  352. xdr_readokres(xdrs, objp)
  353.     XDR *xdrs;
  354.     readokres *objp;
  355. {
  356.     if (!xdr_fattr(xdrs, &objp->attributes)) {
  357.         return (FALSE);
  358.     }
  359.     if (!xdr_bytes(xdrs, (char **)&objp->data.data_val, (u_int *)&objp->data.data_len, NFS_MAXDATA)) {
  360.         return (FALSE);
  361.     }
  362.     return (TRUE);
  363. }
  364.  
  365.  
  366.  
  367.  
  368. bool_t
  369. xdr_readres(xdrs, objp)
  370.     XDR *xdrs;
  371.     readres *objp;
  372. {
  373.     if (!xdr_nfsstat(xdrs, &objp->status)) {
  374.         return (FALSE);
  375.     }
  376.     switch (objp->status) {
  377.     case NFS_OK:
  378.         if (!xdr_readokres(xdrs, &objp->readres_u.reply)) {
  379.             return (FALSE);
  380.         }
  381.         break;
  382.     default:
  383.         break;
  384.     }
  385.     return (TRUE);
  386. }
  387.  
  388.  
  389.  
  390.  
  391. bool_t
  392. xdr_writeargs(xdrs, objp)
  393.     XDR *xdrs;
  394.     writeargs *objp;
  395. {
  396.     if (!xdr_nfs_fh(xdrs, &objp->file)) {
  397.         return (FALSE);
  398.     }
  399.     if (!xdr_u_int(xdrs, &objp->beginoffset)) {
  400.         return (FALSE);
  401.     }
  402.     if (!xdr_u_int(xdrs, &objp->offset)) {
  403.         return (FALSE);
  404.     }
  405.     if (!xdr_u_int(xdrs, &objp->totalcount)) {
  406.         return (FALSE);
  407.     }
  408.     if (!xdr_bytes(xdrs, (char **)&objp->data.data_val, (u_int *)&objp->data.data_len, NFS_MAXDATA)) {
  409.         return (FALSE);
  410.     }
  411.     return (TRUE);
  412. }
  413.  
  414.  
  415.  
  416.  
  417. bool_t
  418. xdr_createargs(xdrs, objp)
  419.     XDR *xdrs;
  420.     createargs *objp;
  421. {
  422.     if (!xdr_diropargs(xdrs, &objp->where)) {
  423.         return (FALSE);
  424.     }
  425.     if (!xdr_sattr(xdrs, &objp->attributes)) {
  426.         return (FALSE);
  427.     }
  428.     return (TRUE);
  429. }
  430.  
  431.  
  432.  
  433.  
  434. bool_t
  435. xdr_renameargs(xdrs, objp)
  436.     XDR *xdrs;
  437.     renameargs *objp;
  438. {
  439.     if (!xdr_diropargs(xdrs, &objp->from)) {
  440.         return (FALSE);
  441.     }
  442.     if (!xdr_diropargs(xdrs, &objp->to)) {
  443.         return (FALSE);
  444.     }
  445.     return (TRUE);
  446. }
  447.  
  448.  
  449.  
  450.  
  451. bool_t
  452. xdr_linkargs(xdrs, objp)
  453.     XDR *xdrs;
  454.     linkargs *objp;
  455. {
  456.     if (!xdr_nfs_fh(xdrs, &objp->from)) {
  457.         return (FALSE);
  458.     }
  459.     if (!xdr_diropargs(xdrs, &objp->to)) {
  460.         return (FALSE);
  461.     }
  462.     return (TRUE);
  463. }
  464.  
  465.  
  466.  
  467.  
  468. bool_t
  469. xdr_symlinkargs(xdrs, objp)
  470.     XDR *xdrs;
  471.     symlinkargs *objp;
  472. {
  473.     if (!xdr_diropargs(xdrs, &objp->from)) {
  474.         return (FALSE);
  475.     }
  476.     if (!xdr_nfspath(xdrs, &objp->to)) {
  477.         return (FALSE);
  478.     }
  479.     if (!xdr_sattr(xdrs, &objp->attributes)) {
  480.         return (FALSE);
  481.     }
  482.     return (TRUE);
  483. }
  484.  
  485.  
  486.  
  487.  
  488. bool_t
  489. xdr_nfscookie(xdrs, objp)
  490.     XDR *xdrs;
  491.     nfscookie objp;
  492. {
  493.     if (!xdr_opaque(xdrs, objp, NFS_COOKIESIZE)) {
  494.         return (FALSE);
  495.     }
  496.     return (TRUE);
  497. }
  498.  
  499.  
  500.  
  501.  
  502. bool_t
  503. xdr_readdirargs(xdrs, objp)
  504.     XDR *xdrs;
  505.     readdirargs *objp;
  506. {
  507.     if (!xdr_nfs_fh(xdrs, &objp->dir)) {
  508.         return (FALSE);
  509.     }
  510.     if (!xdr_nfscookie(xdrs, objp->cookie)) {
  511.         return (FALSE);
  512.     }
  513.     if (!xdr_u_int(xdrs, &objp->count)) {
  514.         return (FALSE);
  515.     }
  516.     return (TRUE);
  517. }
  518.  
  519.  
  520.  
  521.  
  522. bool_t
  523. xdr_entry(xdrs, objp)
  524.     XDR *xdrs;
  525.     entry *objp;
  526. {
  527.     if (!xdr_u_int(xdrs, &objp->fileid)) {
  528.         return (FALSE);
  529.     }
  530.     if (!xdr_filename(xdrs, &objp->name)) {
  531.         return (FALSE);
  532.     }
  533.     if (!xdr_nfscookie(xdrs, objp->cookie)) {
  534.         return (FALSE);
  535.     }
  536.     if (!xdr_pointer(xdrs, (char **)&objp->nextentry, sizeof(entry), xdr_entry)) {
  537.         return (FALSE);
  538.     }
  539.     return (TRUE);
  540. }
  541.  
  542.  
  543.  
  544.  
  545. bool_t
  546. xdr_dirlist(xdrs, objp)
  547.     XDR *xdrs;
  548.     dirlist *objp;
  549. {
  550.     if (!xdr_pointer(xdrs, (char **)&objp->entries, sizeof(entry), xdr_entry)) {
  551.         return (FALSE);
  552.     }
  553.     if (!xdr_bool(xdrs, &objp->eof)) {
  554.         return (FALSE);
  555.     }
  556.     return (TRUE);
  557. }
  558.  
  559.  
  560.  
  561.  
  562. bool_t
  563. xdr_readdirres(xdrs, objp)
  564.     XDR *xdrs;
  565.     readdirres *objp;
  566. {
  567.     if (!xdr_nfsstat(xdrs, &objp->status)) {
  568.         return (FALSE);
  569.     }
  570.     switch (objp->status) {
  571.     case NFS_OK:
  572.         if (!xdr_dirlist(xdrs, &objp->readdirres_u.reply)) {
  573.             return (FALSE);
  574.         }
  575.         break;
  576.     default:
  577.         break;
  578.     }
  579.     return (TRUE);
  580. }
  581.  
  582.  
  583.  
  584.  
  585. bool_t
  586. xdr_statfsokres(xdrs, objp)
  587.     XDR *xdrs;
  588.     statfsokres *objp;
  589. {
  590.     if (!xdr_u_int(xdrs, &objp->tsize)) {
  591.         return (FALSE);
  592.     }
  593.     if (!xdr_u_int(xdrs, &objp->bsize)) {
  594.         return (FALSE);
  595.     }
  596.     if (!xdr_u_int(xdrs, &objp->blocks)) {
  597.         return (FALSE);
  598.     }
  599.     if (!xdr_u_int(xdrs, &objp->bfree)) {
  600.         return (FALSE);
  601.     }
  602.     if (!xdr_u_int(xdrs, &objp->bavail)) {
  603.         return (FALSE);
  604.     }
  605.     return (TRUE);
  606. }
  607.  
  608.  
  609.  
  610.  
  611. bool_t
  612. xdr_statfsres(xdrs, objp)
  613.     XDR *xdrs;
  614.     statfsres *objp;
  615. {
  616.     if (!xdr_nfsstat(xdrs, &objp->status)) {
  617.         return (FALSE);
  618.     }
  619.     switch (objp->status) {
  620.     case NFS_OK:
  621.         if (!xdr_statfsokres(xdrs, &objp->statfsres_u.reply)) {
  622.             return (FALSE);
  623.         }
  624.         break;
  625.     default:
  626.         break;
  627.     }
  628.     return (TRUE);
  629. }
  630.  
  631.  
  632.