support/export/mount_clnt.c

   1 /*
   2  * Please do not edit this file.
   3  * It was generated using rpcgen.
   4  */
   5
   6 #include <memory.h> /* for memset */
   7 #include "mount.h"
   8 /*
   9  * Copyright (c) 2009, Sun Microsystems, Inc.
  10  * All rights reserved.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions are met:
  14  * - Redistributions of source code must retain the above copyright notice,
  15  *   this list of conditions and the following disclaimer.
  16  * - Redistributions in binary form must reproduce the above copyright notice,
  17  *   this list of conditions and the following disclaimer in the documentation
  18  *   and/or other materials provided with the distribution.
  19  * - Neither the name of Sun Microsystems, Inc. nor the names of its
  20  *   contributors may be used to endorse or promote products derived
  21  *   from this software without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  24  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  26  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  27  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  28  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  29  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  30  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  31  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  32  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  33  * POSSIBILITY OF SUCH DAMAGE.
  34  */
  35 /*
  36  * Copyright (c) 1985, 1990 by Sun Microsystems, Inc.
  37  */
  38
  39 /* from @(#)mount.x     1.3 91/03/11 TIRPC 1.0 */
  40
  41 /* Default timeout can be changed using clnt_control() */
  42 static struct timeval TIMEOUT = { 25, 0 };
  43
  44 void *
  45 mountproc_null_1(void *argp, CLIENT *clnt)
  46 {
  47         static char clnt_res;
  48
  49         memset((char *)&clnt_res, 0, sizeof(clnt_res));
  50         if (clnt_call (clnt, MOUNTPROC_NULL,
  51                 (xdrproc_t) xdr_void, (caddr_t) argp,
  52                 (xdrproc_t) xdr_void, (caddr_t) &clnt_res,
  53                 TIMEOUT) != RPC_SUCCESS) {
  54                 return (NULL);
  55         }
  56         return ((void *)&clnt_res);
  57 }
  58
  59 fhstatus *
  60 mountproc_mnt_1(dirpath *argp, CLIENT *clnt)
  61 {
  62         static fhstatus clnt_res;
  63
  64         memset((char *)&clnt_res, 0, sizeof(clnt_res));
  65         if (clnt_call (clnt, MOUNTPROC_MNT,
  66                 (xdrproc_t) xdr_dirpath, (caddr_t) argp,
  67                 (xdrproc_t) xdr_fhstatus, (caddr_t) &clnt_res,
  68                 TIMEOUT) != RPC_SUCCESS) {
  69                 return (NULL);
  70         }
  71         return (&clnt_res);
  72 }
  73
  74 mountlist *
  75 mountproc_dump_1(void *argp, CLIENT *clnt)
  76 {
  77         static mountlist clnt_res;
  78
  79         memset((char *)&clnt_res, 0, sizeof(clnt_res));
  80         if (clnt_call (clnt, MOUNTPROC_DUMP,
  81                 (xdrproc_t) xdr_void, (caddr_t) argp,
  82                 (xdrproc_t) xdr_mountlist, (caddr_t) &clnt_res,
  83                 TIMEOUT) != RPC_SUCCESS) {
  84                 return (NULL);
  85         }
  86         return (&clnt_res);
  87 }
  88
  89 void *
  90 mountproc_umnt_1(dirpath *argp, CLIENT *clnt)
  91 {
  92         static char clnt_res;
  93
  94         memset((char *)&clnt_res, 0, sizeof(clnt_res));
  95         if (clnt_call (clnt, MOUNTPROC_UMNT,
  96                 (xdrproc_t) xdr_dirpath, (caddr_t) argp,
  97                 (xdrproc_t) xdr_void, (caddr_t) &clnt_res,
  98                 TIMEOUT) != RPC_SUCCESS) {
  99                 return (NULL);
 100         }
 101         return ((void *)&clnt_res);
 102 }
 103
 104 void *
 105 mountproc_umntall_1(void *argp, CLIENT *clnt)
 106 {
 107         static char clnt_res;
 108
 109         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 110         if (clnt_call (clnt, MOUNTPROC_UMNTALL,
 111                 (xdrproc_t) xdr_void, (caddr_t) argp,
 112                 (xdrproc_t) xdr_void, (caddr_t) &clnt_res,
 113                 TIMEOUT) != RPC_SUCCESS) {
 114                 return (NULL);
 115         }
 116         return ((void *)&clnt_res);
 117 }
 118
 119 exports *
 120 mountproc_export_1(void *argp, CLIENT *clnt)
 121 {
 122         static exports clnt_res;
 123
 124         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 125         if (clnt_call (clnt, MOUNTPROC_EXPORT,
 126                 (xdrproc_t) xdr_void, (caddr_t) argp,
 127                 (xdrproc_t) xdr_exports, (caddr_t) &clnt_res,
 128                 TIMEOUT) != RPC_SUCCESS) {
 129                 return (NULL);
 130         }
 131         return (&clnt_res);
 132 }
 133
 134 exports *
 135 mountproc_exportall_1(void *argp, CLIENT *clnt)
 136 {
 137         static exports clnt_res;
 138
 139         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 140         if (clnt_call (clnt, MOUNTPROC_EXPORTALL,
 141                 (xdrproc_t) xdr_void, (caddr_t) argp,
 142                 (xdrproc_t) xdr_exports, (caddr_t) &clnt_res,
 143                 TIMEOUT) != RPC_SUCCESS) {
 144                 return (NULL);
 145         }
 146         return (&clnt_res);
 147 }
 148
 149 void *
 150 mountproc_null_2(void *argp, CLIENT *clnt)
 151 {
 152         static char clnt_res;
 153
 154         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 155         if (clnt_call (clnt, MOUNTPROC_NULL,
 156                 (xdrproc_t) xdr_void, (caddr_t) argp,
 157                 (xdrproc_t) xdr_void, (caddr_t) &clnt_res,
 158                 TIMEOUT) != RPC_SUCCESS) {
 159                 return (NULL);
 160         }
 161         return ((void *)&clnt_res);
 162 }
 163
 164 fhstatus *
 165 mountproc_mnt_2(dirpath *argp, CLIENT *clnt)
 166 {
 167         static fhstatus clnt_res;
 168
 169         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 170         if (clnt_call (clnt, MOUNTPROC_MNT,
 171                 (xdrproc_t) xdr_dirpath, (caddr_t) argp,
 172                 (xdrproc_t) xdr_fhstatus, (caddr_t) &clnt_res,
 173                 TIMEOUT) != RPC_SUCCESS) {
 174                 return (NULL);
 175         }
 176         return (&clnt_res);
 177 }
 178
 179 mountlist *
 180 mountproc_dump_2(void *argp, CLIENT *clnt)
 181 {
 182         static mountlist clnt_res;
 183
 184         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 185         if (clnt_call (clnt, MOUNTPROC_DUMP,
 186                 (xdrproc_t) xdr_void, (caddr_t) argp,
 187                 (xdrproc_t) xdr_mountlist, (caddr_t) &clnt_res,
 188                 TIMEOUT) != RPC_SUCCESS) {
 189                 return (NULL);
 190         }
 191         return (&clnt_res);
 192 }
 193
 194 void *
 195 mountproc_umnt_2(dirpath *argp, CLIENT *clnt)
 196 {
 197         static char clnt_res;
 198
 199         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 200         if (clnt_call (clnt, MOUNTPROC_UMNT,
 201                 (xdrproc_t) xdr_dirpath, (caddr_t) argp,
 202                 (xdrproc_t) xdr_void, (caddr_t) &clnt_res,
 203                 TIMEOUT) != RPC_SUCCESS) {
 204                 return (NULL);
 205         }
 206         return ((void *)&clnt_res);
 207 }
 208
 209 void *
 210 mountproc_umntall_2(void *argp, CLIENT *clnt)
 211 {
 212         static char clnt_res;
 213
 214         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 215         if (clnt_call (clnt, MOUNTPROC_UMNTALL,
 216                 (xdrproc_t) xdr_void, (caddr_t) argp,
 217                 (xdrproc_t) xdr_void, (caddr_t) &clnt_res,
 218                 TIMEOUT) != RPC_SUCCESS) {
 219                 return (NULL);
 220         }
 221         return ((void *)&clnt_res);
 222 }
 223
 224 exports *
 225 mountproc_export_2(void *argp, CLIENT *clnt)
 226 {
 227         static exports clnt_res;
 228
 229         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 230         if (clnt_call (clnt, MOUNTPROC_EXPORT,
 231                 (xdrproc_t) xdr_void, (caddr_t) argp,
 232                 (xdrproc_t) xdr_exports, (caddr_t) &clnt_res,
 233                 TIMEOUT) != RPC_SUCCESS) {
 234                 return (NULL);
 235         }
 236         return (&clnt_res);
 237 }
 238
 239 exports *
 240 mountproc_exportall_2(void *argp, CLIENT *clnt)
 241 {
 242         static exports clnt_res;
 243
 244         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 245         if (clnt_call (clnt, MOUNTPROC_EXPORTALL,
 246                 (xdrproc_t) xdr_void, (caddr_t) argp,
 247                 (xdrproc_t) xdr_exports, (caddr_t) &clnt_res,
 248                 TIMEOUT) != RPC_SUCCESS) {
 249                 return (NULL);
 250         }
 251         return (&clnt_res);
 252 }
 253
 254 ppathcnf *
 255 mountproc_pathconf_2(dirpath *argp, CLIENT *clnt)
 256 {
 257         static ppathcnf clnt_res;
 258
 259         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 260         if (clnt_call (clnt, MOUNTPROC_PATHCONF,
 261                 (xdrproc_t) xdr_dirpath, (caddr_t) argp,
 262                 (xdrproc_t) xdr_ppathcnf, (caddr_t) &clnt_res,
 263                 TIMEOUT) != RPC_SUCCESS) {
 264                 return (NULL);
 265         }
 266         return (&clnt_res);
 267 }
 268
 269 void *
 270 mountproc3_null_3(void *argp, CLIENT *clnt)
 271 {
 272         static char clnt_res;
 273
 274         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 275         if (clnt_call (clnt, MOUNTPROC3_NULL,
 276                 (xdrproc_t) xdr_void, (caddr_t) argp,
 277                 (xdrproc_t) xdr_void, (caddr_t) &clnt_res,
 278                 TIMEOUT) != RPC_SUCCESS) {
 279                 return (NULL);
 280         }
 281         return ((void *)&clnt_res);
 282 }
 283
 284 mountres3 *
 285 mountproc3_mnt_3(dirpath *argp, CLIENT *clnt)
 286 {
 287         static mountres3 clnt_res;
 288
 289         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 290         if (clnt_call (clnt, MOUNTPROC3_MNT,
 291                 (xdrproc_t) xdr_dirpath, (caddr_t) argp,
 292                 (xdrproc_t) xdr_mountres3, (caddr_t) &clnt_res,
 293                 TIMEOUT) != RPC_SUCCESS) {
 294                 return (NULL);
 295         }
 296         return (&clnt_res);
 297 }
 298
 299 mountlist *
 300 mountproc3_dump_3(void *argp, CLIENT *clnt)
 301 {
 302         static mountlist clnt_res;
 303
 304         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 305         if (clnt_call (clnt, MOUNTPROC3_DUMP,
 306                 (xdrproc_t) xdr_void, (caddr_t) argp,
 307                 (xdrproc_t) xdr_mountlist, (caddr_t) &clnt_res,
 308                 TIMEOUT) != RPC_SUCCESS) {
 309                 return (NULL);
 310         }
 311         return (&clnt_res);
 312 }
 313
 314 void *
 315 mountproc3_umnt_3(dirpath *argp, CLIENT *clnt)
 316 {
 317         static char clnt_res;
 318
 319         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 320         if (clnt_call (clnt, MOUNTPROC3_UMNT,
 321                 (xdrproc_t) xdr_dirpath, (caddr_t) argp,
 322                 (xdrproc_t) xdr_void, (caddr_t) &clnt_res,
 323                 TIMEOUT) != RPC_SUCCESS) {
 324                 return (NULL);
 325         }
 326         return ((void *)&clnt_res);
 327 }
 328
 329 void *
 330 mountproc3_umntall_3(void *argp, CLIENT *clnt)
 331 {
 332         static char clnt_res;
 333
 334         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 335         if (clnt_call (clnt, MOUNTPROC3_UMNTALL,
 336                 (xdrproc_t) xdr_void, (caddr_t) argp,
 337                 (xdrproc_t) xdr_void, (caddr_t) &clnt_res,
 338                 TIMEOUT) != RPC_SUCCESS) {
 339                 return (NULL);
 340         }
 341         return ((void *)&clnt_res);
 342 }
 343
 344 exports *
 345 mountproc3_export_3(void *argp, CLIENT *clnt)
 346 {
 347         static exports clnt_res;
 348
 349         memset((char *)&clnt_res, 0, sizeof(clnt_res));
 350         if (clnt_call (clnt, MOUNTPROC3_EXPORT,
 351                 (xdrproc_t) xdr_void, (caddr_t) argp,
 352                 (xdrproc_t) xdr_exports, (caddr_t) &clnt_res,
 353                 TIMEOUT) != RPC_SUCCESS) {
 354                 return (NULL);
 355         }
 356         return (&clnt_res);
 357 }