Logo Search packages:      
Sourcecode: hamlib version File versions  Download package

rpcrig_clnt.c

/*
 * Please do not edit this file.
 * It was generated using rpcgen.
 */

#include <memory.h> /* for memset */
#include "rpcrig.h"
/*
 *  Hamlib Interface - RPC definitions
 *  Copyright (c) 2000-2002 by Stephane Fillod and Frank Singleton
 *
 *    $Id: rpcrig.x,v 1.10 2005/03/28 09:37:24 fillods Exp $
 *
 *   This library is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU Library General Public License as
 *   published by the Free Software Foundation; either version 2 of
 *   the License, or (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU Library General Public License for more details.
 *
 *   You should have received a copy of the GNU Library General Public
 *   License along with this library; if not, write to the Free Software
 *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */
#if __APPLE__
static int _rpcsvcdirty;
#endif

/* Default timeout can be changed using clnt_control() */
static struct timeval TIMEOUT = { 25, 0 };

model_x *
getmodel_1(void *argp, CLIENT *clnt)
{
      static model_x clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETMODEL,
            (xdrproc_t) xdr_void, (caddr_t) argp,
            (xdrproc_t) xdr_model_x, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

rigstate_res *
getrigstate_1(void *argp, CLIENT *clnt)
{
      static rigstate_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETRIGSTATE,
            (xdrproc_t) xdr_void, (caddr_t) argp,
            (xdrproc_t) xdr_rigstate_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
setfreq_1(freq_arg *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SETFREQ,
            (xdrproc_t) xdr_freq_arg, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

freq_res *
getfreq_1(vfo_x *argp, CLIENT *clnt)
{
      static freq_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETFREQ,
            (xdrproc_t) xdr_vfo_x, (caddr_t) argp,
            (xdrproc_t) xdr_freq_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
setmode_1(mode_arg *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SETMODE,
            (xdrproc_t) xdr_mode_arg, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

mode_res *
getmode_1(vfo_x *argp, CLIENT *clnt)
{
      static mode_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETMODE,
            (xdrproc_t) xdr_vfo_x, (caddr_t) argp,
            (xdrproc_t) xdr_mode_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
setvfo_1(vfo_x *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SETVFO,
            (xdrproc_t) xdr_vfo_x, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

vfo_res *
getvfo_1(vfo_x *argp, CLIENT *clnt)
{
      static vfo_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETVFO,
            (xdrproc_t) xdr_vfo_x, (caddr_t) argp,
            (xdrproc_t) xdr_vfo_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
setsplitfreq_1(freq_arg *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SETSPLITFREQ,
            (xdrproc_t) xdr_freq_arg, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

freq_res *
getsplitfreq_1(vfo_x *argp, CLIENT *clnt)
{
      static freq_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETSPLITFREQ,
            (xdrproc_t) xdr_vfo_x, (caddr_t) argp,
            (xdrproc_t) xdr_freq_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
setsplitmode_1(mode_arg *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SETSPLITMODE,
            (xdrproc_t) xdr_mode_arg, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

mode_res *
getsplitmode_1(vfo_x *argp, CLIENT *clnt)
{
      static mode_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETSPLITMODE,
            (xdrproc_t) xdr_vfo_x, (caddr_t) argp,
            (xdrproc_t) xdr_mode_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
setsplitvfo_1(split_arg *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SETSPLITVFO,
            (xdrproc_t) xdr_split_arg, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

split_res *
getsplitvfo_1(vfo_x *argp, CLIENT *clnt)
{
      static split_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETSPLITVFO,
            (xdrproc_t) xdr_vfo_x, (caddr_t) argp,
            (xdrproc_t) xdr_split_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
setptt_1(ptt_arg *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SETPTT,
            (xdrproc_t) xdr_ptt_arg, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

ptt_res *
getptt_1(vfo_x *argp, CLIENT *clnt)
{
      static ptt_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETPTT,
            (xdrproc_t) xdr_vfo_x, (caddr_t) argp,
            (xdrproc_t) xdr_ptt_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

dcd_res *
getdcd_1(vfo_x *argp, CLIENT *clnt)
{
      static dcd_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETDCD,
            (xdrproc_t) xdr_vfo_x, (caddr_t) argp,
            (xdrproc_t) xdr_dcd_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
setfunc_1(setting_arg *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SETFUNC,
            (xdrproc_t) xdr_setting_arg, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

val_res *
getfunc_1(setting_arg *argp, CLIENT *clnt)
{
      static val_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETFUNC,
            (xdrproc_t) xdr_setting_arg, (caddr_t) argp,
            (xdrproc_t) xdr_val_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
setlevel_1(setting_arg *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SETLEVEL,
            (xdrproc_t) xdr_setting_arg, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

val_res *
getlevel_1(setting_arg *argp, CLIENT *clnt)
{
      static val_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETLEVEL,
            (xdrproc_t) xdr_setting_arg, (caddr_t) argp,
            (xdrproc_t) xdr_val_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
setparm_1(setting_arg *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SETPARM,
            (xdrproc_t) xdr_setting_arg, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

val_res *
getparm_1(setting_arg *argp, CLIENT *clnt)
{
      static val_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETPARM,
            (xdrproc_t) xdr_setting_arg, (caddr_t) argp,
            (xdrproc_t) xdr_val_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
vfoop_1(vfo_op_arg *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, VFOOP,
            (xdrproc_t) xdr_vfo_op_arg, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
setrptrshift_1(rptrshift_arg *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SETRPTRSHIFT,
            (xdrproc_t) xdr_rptrshift_arg, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

rptrshift_res *
getrptrshift_1(vfo_x *argp, CLIENT *clnt)
{
      static rptrshift_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETRPTRSHIFT,
            (xdrproc_t) xdr_vfo_x, (caddr_t) argp,
            (xdrproc_t) xdr_rptrshift_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
setrptroffs_1(shortfreq_arg *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SETRPTROFFS,
            (xdrproc_t) xdr_shortfreq_arg, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

shortfreq_res *
getrptroffs_1(vfo_x *argp, CLIENT *clnt)
{
      static shortfreq_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETRPTROFFS,
            (xdrproc_t) xdr_vfo_x, (caddr_t) argp,
            (xdrproc_t) xdr_shortfreq_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
setctcsstone_1(tone_arg *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SETCTCSSTONE,
            (xdrproc_t) xdr_tone_arg, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

tone_res *
getctcsstone_1(vfo_x *argp, CLIENT *clnt)
{
      static tone_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETCTCSSTONE,
            (xdrproc_t) xdr_vfo_x, (caddr_t) argp,
            (xdrproc_t) xdr_tone_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
setctcsssql_1(tone_arg *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SETCTCSSSQL,
            (xdrproc_t) xdr_tone_arg, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

tone_res *
getctcsssql_1(vfo_x *argp, CLIENT *clnt)
{
      static tone_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETCTCSSSQL,
            (xdrproc_t) xdr_vfo_x, (caddr_t) argp,
            (xdrproc_t) xdr_tone_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
setdcscode_1(tone_arg *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SETDCSCODE,
            (xdrproc_t) xdr_tone_arg, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

tone_res *
getdcscode_1(vfo_x *argp, CLIENT *clnt)
{
      static tone_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETDCSCODE,
            (xdrproc_t) xdr_vfo_x, (caddr_t) argp,
            (xdrproc_t) xdr_tone_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
setdcssql_1(tone_arg *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SETDCSSQL,
            (xdrproc_t) xdr_tone_arg, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

tone_res *
getdcssql_1(vfo_x *argp, CLIENT *clnt)
{
      static tone_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETDCSSQL,
            (xdrproc_t) xdr_vfo_x, (caddr_t) argp,
            (xdrproc_t) xdr_tone_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
setrit_1(shortfreq_arg *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SETRIT,
            (xdrproc_t) xdr_shortfreq_arg, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

shortfreq_res *
getrit_1(vfo_x *argp, CLIENT *clnt)
{
      static shortfreq_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETRIT,
            (xdrproc_t) xdr_vfo_x, (caddr_t) argp,
            (xdrproc_t) xdr_shortfreq_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
setxit_1(shortfreq_arg *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SETXIT,
            (xdrproc_t) xdr_shortfreq_arg, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

shortfreq_res *
getxit_1(vfo_x *argp, CLIENT *clnt)
{
      static shortfreq_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETXIT,
            (xdrproc_t) xdr_vfo_x, (caddr_t) argp,
            (xdrproc_t) xdr_shortfreq_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
setts_1(shortfreq_arg *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SETTS,
            (xdrproc_t) xdr_shortfreq_arg, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

shortfreq_res *
getts_1(vfo_x *argp, CLIENT *clnt)
{
      static shortfreq_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETTS,
            (xdrproc_t) xdr_vfo_x, (caddr_t) argp,
            (xdrproc_t) xdr_shortfreq_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
scan_1(scan_arg *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SCAN,
            (xdrproc_t) xdr_scan_arg, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
reset_1(reset_x *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, RESET,
            (xdrproc_t) xdr_reset_x, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
setmem_1(ch_arg *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SETMEM,
            (xdrproc_t) xdr_ch_arg, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

ch_res *
getmem_1(vfo_x *argp, CLIENT *clnt)
{
      static ch_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETMEM,
            (xdrproc_t) xdr_vfo_x, (caddr_t) argp,
            (xdrproc_t) xdr_ch_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
setant_1(ant_arg *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SETANT,
            (xdrproc_t) xdr_ant_arg, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

ant_res *
getant_1(vfo_x *argp, CLIENT *clnt)
{
      static ant_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETANT,
            (xdrproc_t) xdr_vfo_x, (caddr_t) argp,
            (xdrproc_t) xdr_ant_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
setbank_1(ch_arg *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SETBANK,
            (xdrproc_t) xdr_ch_arg, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

int *
setpowerstat_1(powerstat_x *argp, CLIENT *clnt)
{
      static int clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, SETPOWERSTAT,
            (xdrproc_t) xdr_powerstat_x, (caddr_t) argp,
            (xdrproc_t) xdr_int, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

powerstat_res *
getpowerstat_1(void *argp, CLIENT *clnt)
{
      static powerstat_res clnt_res;

      memset((char *)&clnt_res, 0, sizeof(clnt_res));
      if (clnt_call (clnt, GETPOWERSTAT,
            (xdrproc_t) xdr_void, (caddr_t) argp,
            (xdrproc_t) xdr_powerstat_res, (caddr_t) &clnt_res,
            TIMEOUT) != RPC_SUCCESS) {
            return (NULL);
      }
      return (&clnt_res);
}

Generated by  Doxygen 1.6.0   Back to index