home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / N / TCPIP / LINUX_PC.TAR / pcnfsd_linux2 / pcnfsd_clnt.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-06  |  6.9 KB  |  293 lines
  1. /* RE_SID: @(%)/tmp_mnt/vol/dosnfs/shades_SCCS/unix/pcnfsd/v2/src/SCCS/s.pcnfsd_clnt.c 1.4 93/02/08 19:20:18 SMI */
  2. /*
  3.  * Please do not edit this file.
  4.  * It was generated using rpcgen.
  5.  * Note: The (caddr_t) casts were added throughout
  6.  * to remove SVR4/ANSI C warnings.
  7.  */
  8.  
  9. #include "common.h"
  10.  
  11. #ifdef ULTRIX
  12. # include <sys/time.h>
  13. #endif
  14.  
  15. #include <rpc/rpc.h>
  16. #include <memory.h>
  17. #include "pcnfsd.h"
  18. #if RPC_SVC
  19.  void msg_out(msg) char *msg; {_msgout(msg);}
  20. #endif
  21. #if RPC_HDR
  22.  extern void msg_out();
  23. #endif
  24.  
  25. /* Default timeout can be changed using clnt_control() */
  26. static struct timeval TIMEOUT = { 25, 0 };
  27.  
  28. void *
  29. pcnfsd_null_1(argp, clnt)
  30.     void *argp;
  31.     CLIENT *clnt;
  32. {
  33.     static char res;
  34.  
  35.     (void)memset((char *)&res, 0, sizeof(res));
  36.     if (clnt_call(clnt, PCNFSD_NULL, xdr_void, (caddr_t)argp, xdr_void, (caddr_t)&res, TIMEOUT) != RPC_SUCCESS) {
  37.         return (NULL);
  38.     }
  39.     return ((void *)&res);
  40. }
  41.  
  42. auth_results *
  43. pcnfsd_auth_1(argp, clnt)
  44.     auth_args *argp;
  45.     CLIENT *clnt;
  46. {
  47.     static auth_results res;
  48.  
  49.     (void)memset((char *)&res, 0, sizeof(res));
  50.     if (clnt_call(clnt, PCNFSD_AUTH, xdr_auth_args, (caddr_t)argp, xdr_auth_results, (caddr_t)&res, TIMEOUT) != RPC_SUCCESS) {
  51.         return (NULL);
  52.     }
  53.     return (&res);
  54. }
  55.  
  56. pr_init_results *
  57. pcnfsd_pr_init_1(argp, clnt)
  58.     pr_init_args *argp;
  59.     CLIENT *clnt;
  60. {
  61.     static pr_init_results res;
  62.  
  63.      (void)memset((char *)&res, 0, sizeof(res));
  64.     if (clnt_call(clnt, PCNFSD_PR_INIT, xdr_pr_init_args, (caddr_t)argp, xdr_pr_init_results, (caddr_t)&res, TIMEOUT) != RPC_SUCCESS) {
  65.         return (NULL);
  66.     }
  67.     return (&res);
  68. }
  69.  
  70. pr_start_results *
  71. pcnfsd_pr_start_1(argp, clnt)
  72.     pr_start_args *argp;
  73.     CLIENT *clnt;
  74. {
  75.     static pr_start_results res;
  76.  
  77.      (void)memset((char *)&res, 0, sizeof(res));
  78.     if (clnt_call(clnt, PCNFSD_PR_START, xdr_pr_start_args, (caddr_t)argp, xdr_pr_start_results, (caddr_t)&res, TIMEOUT) != RPC_SUCCESS) {
  79.         return (NULL);
  80.     }
  81.     return (&res);
  82. }
  83.  
  84. void *
  85. pcnfsd2_null_2(argp, clnt)
  86.     void *argp;
  87.     CLIENT *clnt;
  88. {
  89.     static char res;
  90.  
  91.      (void)memset((char *)&res, 0, sizeof(res));
  92.     if (clnt_call(clnt, PCNFSD2_NULL, xdr_void, argp, xdr_void, &res, TIMEOUT) != RPC_SUCCESS) {
  93.         return (NULL);
  94.     }
  95.     return ((void *)&res);
  96. }
  97.  
  98. v2_info_results *
  99. pcnfsd2_info_2(argp, clnt)
  100.     v2_info_args *argp;
  101.     CLIENT *clnt;
  102. {
  103.     static v2_info_results res;
  104.  
  105.      (void)memset((char *)&res, 0, sizeof(res));
  106.     if (clnt_call(clnt, PCNFSD2_INFO, xdr_v2_info_args, (caddr_t)argp, xdr_v2_info_results, (caddr_t)&res, TIMEOUT) != RPC_SUCCESS) {
  107.         return (NULL);
  108.     }
  109.     return (&res);
  110. }
  111.  
  112. v2_pr_init_results *
  113. pcnfsd2_pr_init_2(argp, clnt)
  114.     v2_pr_init_args *argp;
  115.     CLIENT *clnt;
  116. {
  117.     static v2_pr_init_results res;
  118.  
  119.      (void)memset((char *)&res, 0, sizeof(res));
  120.     if (clnt_call(clnt, PCNFSD2_PR_INIT, xdr_v2_pr_init_args, (caddr_t)argp, xdr_v2_pr_init_results, (caddr_t)&res, TIMEOUT) != RPC_SUCCESS) {
  121.         return (NULL);
  122.     }
  123.     return (&res);
  124. }
  125.  
  126. v2_pr_start_results *
  127. pcnfsd2_pr_start_2(argp, clnt)
  128.     v2_pr_start_args *argp;
  129.     CLIENT *clnt;
  130. {
  131.     static v2_pr_start_results res;
  132.  
  133.      (void)memset((char *)&res, 0, sizeof(res));
  134.     if (clnt_call(clnt, PCNFSD2_PR_START, xdr_v2_pr_start_args, (caddr_t)argp, xdr_v2_pr_start_results, (caddr_t)&res, TIMEOUT) != RPC_SUCCESS) {
  135.         return (NULL);
  136.     }
  137.     return (&res);
  138. }
  139.  
  140. v2_pr_list_results *
  141. pcnfsd2_pr_list_2(argp, clnt)
  142.     void *argp;
  143.     CLIENT *clnt;
  144. {
  145.     static v2_pr_list_results res;
  146.  
  147.      (void)memset((char *)&res, 0, sizeof(res));
  148.     if (clnt_call(clnt, PCNFSD2_PR_LIST, xdr_void, (caddr_t)argp, xdr_v2_pr_list_results, (caddr_t)&res, TIMEOUT) != RPC_SUCCESS) {
  149.         return (NULL);
  150.     }
  151.     return (&res);
  152. }
  153.  
  154. v2_pr_queue_results *
  155. pcnfsd2_pr_queue_2(argp, clnt)
  156.     v2_pr_queue_args *argp;
  157.     CLIENT *clnt;
  158. {
  159.     static v2_pr_queue_results res;
  160.  
  161.      (void)memset((char *)&res, 0, sizeof(res));
  162.     if (clnt_call(clnt, PCNFSD2_PR_QUEUE, xdr_v2_pr_queue_args, (caddr_t)argp, xdr_v2_pr_queue_results, (caddr_t)&res, TIMEOUT) != RPC_SUCCESS) {
  163.         return (NULL);
  164.     }
  165.     return (&res);
  166. }
  167.  
  168. v2_pr_status_results *
  169. pcnfsd2_pr_status_2(argp, clnt)
  170.     v2_pr_status_args *argp;
  171.     CLIENT *clnt;
  172. {
  173.     static v2_pr_status_results res;
  174.  
  175.      (void)memset((char *)&res, 0, sizeof(res));
  176.     if (clnt_call(clnt, PCNFSD2_PR_STATUS, xdr_v2_pr_status_args, (caddr_t)argp, xdr_v2_pr_status_results, (caddr_t)&res, TIMEOUT) != RPC_SUCCESS) {
  177.         return (NULL);
  178.     }
  179.     return (&res);
  180. }
  181.  
  182. v2_pr_cancel_results *
  183. pcnfsd2_pr_cancel_2(argp, clnt)
  184.     v2_pr_cancel_args *argp;
  185.     CLIENT *clnt;
  186. {
  187.     static v2_pr_cancel_results res;
  188.  
  189.      (void)memset((char *)&res, 0, sizeof(res));
  190.     if (clnt_call(clnt, PCNFSD2_PR_CANCEL, xdr_v2_pr_cancel_args, (caddr_t)argp, xdr_v2_pr_cancel_results, (caddr_t)&res, TIMEOUT) != RPC_SUCCESS) {
  191.         return (NULL);
  192.     }
  193.     return (&res);
  194. }
  195.  
  196. v2_pr_admin_results *
  197. pcnfsd2_pr_admin_2(argp, clnt)
  198.     v2_pr_admin_args *argp;
  199.     CLIENT *clnt;
  200. {
  201.     static v2_pr_admin_results res;
  202.  
  203.      (void)memset((char *)&res, 0, sizeof(res));
  204.     if (clnt_call(clnt, PCNFSD2_PR_ADMIN, xdr_v2_pr_admin_args, (caddr_t)argp, xdr_v2_pr_admin_results, (caddr_t)&res, TIMEOUT) != RPC_SUCCESS) {
  205.         return (NULL);
  206.     }
  207.     return (&res);
  208. }
  209.  
  210. v2_pr_requeue_results *
  211. pcnfsd2_pr_requeue_2(argp, clnt)
  212.     v2_pr_requeue_args *argp;
  213.     CLIENT *clnt;
  214. {
  215.     static v2_pr_requeue_results res;
  216.  
  217.      (void)memset((char *)&res, 0, sizeof(res));
  218.     if (clnt_call(clnt, PCNFSD2_PR_REQUEUE, xdr_v2_pr_requeue_args, (caddr_t)argp, xdr_v2_pr_requeue_results, (caddr_t)&res, TIMEOUT) != RPC_SUCCESS) {
  219.         return (NULL);
  220.     }
  221.     return (&res);
  222. }
  223.  
  224. v2_pr_hold_results *
  225. pcnfsd2_pr_hold_2(argp, clnt)
  226.     v2_pr_hold_args *argp;
  227.     CLIENT *clnt;
  228. {
  229.     static v2_pr_hold_results res;
  230.  
  231.      (void)memset((char *)&res, 0, sizeof(res));
  232.     if (clnt_call(clnt, PCNFSD2_PR_HOLD, xdr_v2_pr_hold_args, (caddr_t)argp, xdr_v2_pr_hold_results, (caddr_t)&res, TIMEOUT) != RPC_SUCCESS) {
  233.         return (NULL);
  234.     }
  235.     return (&res);
  236. }
  237.  
  238. v2_pr_release_results *
  239. pcnfsd2_pr_release_2(argp, clnt)
  240.     v2_pr_release_args *argp;
  241.     CLIENT *clnt;
  242. {
  243.     static v2_pr_release_results res;
  244.  
  245.      (void)memset((char *)&res, 0, sizeof(res));
  246.     if (clnt_call(clnt, PCNFSD2_PR_RELEASE, xdr_v2_pr_release_args, (caddr_t)argp, xdr_v2_pr_release_results, (caddr_t)&res, TIMEOUT) != RPC_SUCCESS) {
  247.         return (NULL);
  248.     }
  249.     return (&res);
  250. }
  251.  
  252. v2_mapid_results *
  253. pcnfsd2_mapid_2(argp, clnt)
  254.     v2_mapid_args *argp;
  255.     CLIENT *clnt;
  256. {
  257.     static v2_mapid_results res;
  258.  
  259.      (void)memset((char *)&res, 0, sizeof(res));
  260.     if (clnt_call(clnt, PCNFSD2_MAPID, xdr_v2_mapid_args, (caddr_t)argp, xdr_v2_mapid_results, (caddr_t)&res, TIMEOUT) != RPC_SUCCESS) {
  261.         return (NULL);
  262.     }
  263.     return (&res);
  264. }
  265.  
  266. v2_auth_results *
  267. pcnfsd2_auth_2(argp, clnt)
  268.     v2_auth_args *argp;
  269.     CLIENT *clnt;
  270. {
  271.     static v2_auth_results res;
  272.  
  273.      (void)memset((char *)&res, 0, sizeof(res));
  274.     if (clnt_call(clnt, PCNFSD2_AUTH, xdr_v2_auth_args, (caddr_t)argp, xdr_v2_auth_results, (caddr_t)&res, TIMEOUT) != RPC_SUCCESS) {
  275.         return (NULL);
  276.     }
  277.     return (&res);
  278. }
  279.  
  280. v2_alert_results *
  281. pcnfsd2_alert_2(argp, clnt)
  282.     v2_alert_args *argp;
  283.     CLIENT *clnt;
  284. {
  285.     static v2_alert_results res;
  286.  
  287.      (void)memset((char *)&res, 0, sizeof(res));
  288.     if (clnt_call(clnt, PCNFSD2_ALERT, xdr_v2_alert_args, (caddr_t)argp, xdr_v2_alert_results, (caddr_t)&res, TIMEOUT) != RPC_SUCCESS) {
  289.         return (NULL);
  290.     }
  291.     return (&res);
  292. }
  293.