void
F77_FUNC(xdrfchar,XDRFCHAR)(int *xdrid, char *cp, int *ret)
{
xdr_fortran_lock();
*ret = xdr_char(xdridptr[*xdrid], cp);
cnt += sizeof(char);
xdr_fortran_unlock();
}
bool_t
xdr_ip_addr_t(XDR *xdrs, ip_addr_t *objp)
{
if (!xdr_char(xdrs, &objp->net)) {
return (FALSE);
}
if (!xdr_char(xdrs, &objp->host)) {
return (FALSE);
}
if (!xdr_char(xdrs, &objp->lh)) {
return (FALSE);
}
if (!xdr_char(xdrs, &objp->impno)) {
return (FALSE);
}
return (TRUE);
}
bool_t
xdr_data_req (XDR *xdrs, data_req *objp)
{
register int32_t *buf;
if (!xdr_char (xdrs, &objp->c))
return FALSE;
if (!xdr_u_int (xdrs, &objp->len))
return FALSE;
return TRUE;
}
int xdr_send_data(XDR * xdrs, struct data *buffer)
{
int i, rc;
char *p;
rc = xdr_long(xdrs, &buffer->address);
rc = rc && xdr_long(xdrs, &buffer->request_id);
rc = rc && xdr_long(xdrs, &buffer->data_length);
for (i = 0, p = buffer->data; rc && i < buffer->data_length; i++, p++)
rc = xdr_char(xdrs, p);
return (rc);
}
bool_t
xdr_inputs (XDR *xdrs, inputs *objp)
{
register int32_t *buf;
if (!xdr_float (xdrs, &objp->num1))
return FALSE;
if (!xdr_float (xdrs, &objp->num2))
return FALSE;
if (!xdr_char (xdrs, &objp->operator))
return FALSE;
return TRUE;
}
/*
* XDR enumerations
*
* This function is a modified version of xdr_enum. It depends
* on enum_t being defined as size long, short, or char. All
* callers of xdr_enum_t must be sure that their enums are
* type enum_t. BM
*/
bool_t
xdr_enum_t(XDR *xdrs,
enum_t *ep)
{
if (sizeof (enum_t) == sizeof (long)) {
return (XDR_LONG(xdrs, (long *)ep));
} else if (sizeof (enum_t) == sizeof (short)) {
return (xdr_short(xdrs, (short *)ep));
} else if (sizeof (enum_t) == sizeof (short)) {
return (xdr_char(xdrs, (char *)ep));
} else {
return (FALSE);
}
}
int xdr_receive_data(XDR * xdrs, struct data **buffer)
{
struct data *bp;
int i, rc;
char *p;
bp = *buffer = (struct data *)malloc(sizeof(struct data));
rc = xdr_long(xdrs, &(bp->address));
rc = rc && xdr_long(xdrs, &bp->request_id);
rc = rc && xdr_long(xdrs, &bp->data_length);
p = (*buffer)->data = (char *)malloc(bp->data_length);
for (i = 0; rc && i < bp->data_length; p++, i++)
rc = xdr_char(xdrs, p);
return (rc);
}
int
xdr_afsUUID(XDR * xdrs, afsUUID * objp)
{
if (!xdr_afs_uint32(xdrs, &objp->time_low)) {
return (FALSE);
}
if (!xdr_u_short(xdrs, &objp->time_mid)) {
return (FALSE);
}
if (!xdr_u_short(xdrs, &objp->time_hi_and_version)) {
return (FALSE);
}
if (!xdr_char(xdrs, &objp->clock_seq_hi_and_reserved)) {
return (FALSE);
}
if (!xdr_char(xdrs, &objp->clock_seq_low)) {
return (FALSE);
}
/* Cast needed here because xdrproc_t officially takes 3 args :-( */
if (!xdr_vector(xdrs, (char *)objp->node, 6, sizeof(char), (xdrproc_t)xdr_char)) {
return (FALSE);
}
return (TRUE);
}
int xdr_batch_decode(XDR *xdrpars, void *input) {
int i;
batch_t *batch = (batch_t *) input;
if (!xdr_int(xdrpars, &batch->count))
return (FALSE);
for (i = 0; i < batch->count; i++)
if (!xdr_char(xdrpars, &batch->cmd[i]))
return (FALSE);
for (i = 0; i < batch->count; i++)
if (!xdr_int(xdrpars, &batch->first[i]))
return (FALSE);
for (i = 0; i < batch->count; i++)
if (!xdr_int(xdrpars, &batch->second[i]))
return (FALSE);
return (TRUE);
}
bool_t
xdr_operation (XDR *xdrs, operation *objp)
{
register int32_t *buf;
int i;
if (!xdr_vector (xdrs, (char *)objp->op1, 500,
sizeof (char), (xdrproc_t) xdr_char))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->op2, 500,
sizeof (char), (xdrproc_t) xdr_char))
return FALSE;
if (!xdr_char (xdrs, &objp->operator))
return FALSE;
return TRUE;
}
bool_t
xdr_voter_pack (XDR *xdrs, voter_pack *objp)
{
register int32_t *buf;
int i;
if (!xdr_char (xdrs, &objp->command))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->password, 100,
sizeof (char), (xdrproc_t) xdr_char))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->username, 100,
sizeof (char), (xdrproc_t) xdr_char))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->new_password, 100,
sizeof (char), (xdrproc_t) xdr_char))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->cname, 100,
sizeof (char), (xdrproc_t) xdr_char))
return FALSE;
if (!xdr_int (xdrs, &objp->voter_id))
return FALSE;
return TRUE;
}
bool_t xdr_Device_ReadParms (XDR *xdrs, Device_ReadParms *objp)
{
#if defined(SOLARIS) && !defined(_LP64)
register long *buf;
#else
register int32_t *buf;
#endif
if (xdrs->x_op == XDR_ENCODE) {
if (!xdr_Device_Link (xdrs, &objp->lid))
return FALSE;
buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
if (buf == NULL) {
if (!xdr_u_long (xdrs, &objp->requestSize))
return FALSE;
if (!xdr_u_long (xdrs, &objp->io_timeout))
return FALSE;
if (!xdr_u_long (xdrs, &objp->lock_timeout))
return FALSE;
} else {
IXDR_PUT_U_INT32(buf, objp->requestSize);
IXDR_PUT_U_INT32(buf, objp->io_timeout);
IXDR_PUT_U_INT32(buf, objp->lock_timeout);
}
if (!xdr_Device_Flags (xdrs, &objp->flags))
return FALSE;
if (!xdr_char (xdrs, &objp->termChar))
return FALSE;
return TRUE;
} else if (xdrs->x_op == XDR_DECODE) {
if (!xdr_Device_Link (xdrs, &objp->lid))
return FALSE;
buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
if (buf == NULL) {
if (!xdr_u_long (xdrs, &objp->requestSize))
return FALSE;
if (!xdr_u_long (xdrs, &objp->io_timeout))
return FALSE;
if (!xdr_u_long (xdrs, &objp->lock_timeout))
return FALSE;
} else {
objp->requestSize = IXDR_GET_U_INT32(buf);
objp->io_timeout = IXDR_GET_U_INT32(buf);
objp->lock_timeout = IXDR_GET_U_INT32(buf);
}
if (!xdr_Device_Flags (xdrs, &objp->flags))
return FALSE;
if (!xdr_char (xdrs, &objp->termChar))
return FALSE;
return TRUE;
}
if (!xdr_Device_Link (xdrs, &objp->lid))
return FALSE;
if (!xdr_u_long (xdrs, &objp->requestSize))
return FALSE;
if (!xdr_u_long (xdrs, &objp->io_timeout))
return FALSE;
if (!xdr_u_long (xdrs, &objp->lock_timeout))
return FALSE;
if (!xdr_Device_Flags (xdrs, &objp->flags))
return FALSE;
if (!xdr_char (xdrs, &objp->termChar))
return FALSE;
return TRUE;
}
bool_t
xdr_jobCard (XDR *xdrs, struct jobCard *jCard, struct LSFHeader *hdr)
{
static char fname[]="xdr_jobCard()";
char *sp1;
if (xdrs->x_op == XDR_FREE) {
FREEUP(jCard->actCmd);
FREEUP(jCard->exitFile);
if (!xdr_jobSpecs(xdrs, &jCard->jobSpecs, hdr))
return(FALSE);
return(TRUE);
}
sp1 = jCard->execUsername;
if (! xdr_int(xdrs, (int *)&jCard->execGid)
|| !xdr_int(xdrs, &jCard->notReported)
|| !xdr_time_t(xdrs, &jCard->windEdge)
|| !xdr_char(xdrs, &jCard->active)
|| !xdr_char(xdrs, &jCard->timeExpire)
|| !xdr_char(xdrs, &jCard->missing)
|| !xdr_char(xdrs, &jCard->mbdRestarted)
|| !xdr_time_t(xdrs, &jCard->windWarnTime)
|| !xdr_int(xdrs, &jCard->runTime)
|| !xdr_int(xdrs, &jCard->w_status)
|| !xdr_float(xdrs, &jCard->cpuTime)
|| !xdr_time_t(xdrs, &jCard->lastChkpntTime)
|| !xdr_int(xdrs, &jCard->migCnt)
|| !xdr_int(xdrs, &jCard->cleanupPid)
|| !xdr_int(xdrs, &jCard->execJobFlag)) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr");
return(FALSE);
}
if (! xdr_time_t(xdrs, &jCard->lastStatusMbdTime)) {
return(FALSE);
}
if (xdrs->x_op == XDR_DECODE) {
sp1[0] = '\0';
}
if (!xdr_string(xdrs, &sp1, MAX_LSB_NAME_LEN)) {
ls_syslog(LOG_ERR, I18N_FUNC_S_FAIL_M, fname,
"xdr_string", "execUserName");
return(FALSE);
}
if (! xdr_int(xdrs, &jCard->actReasons)
|| !xdr_int(xdrs, &jCard->actSubReasons)) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr");
return(FALSE);
}
if (! xdr_var_string(xdrs, &jCard->actCmd)
|| !xdr_var_string(xdrs, &jCard->exitFile)
|| !xdr_var_string(xdrs, &jCard->clusterName))
return(FALSE);
if (!xdr_arrayElement(xdrs,
(char *)&jCard->jobSpecs,
hdr,
xdr_jobSpecs)) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_jobSpecs");
return(FALSE);
}
if (!xdr_int(xdrs, &jCard->servSocket))
return(FALSE);
if (! xdr_int(xdrs, &jCard->maxRusage.mem)
|| !xdr_int(xdrs, &jCard->maxRusage.swap)
|| !xdr_int(xdrs, &jCard->maxRusage.utime)
|| !xdr_int(xdrs, &jCard->maxRusage.stime)
|| !xdr_int(xdrs, &jCard->maxRusage.npids)) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_int jRusage");
return(FALSE);
}
if (!xdr_int(xdrs, (int *)&jCard->actFlags)) {
ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_actFlags");
return(FALSE);
}
return(TRUE);
}
void
F77_FUNC(xdrfchar,XDRFCHAR)(int *xdrid, char *cp, int *ret)
{
*ret = xdr_char(xdridptr[*xdrid], cp);
cnt += sizeof(char);
}
bool FocRttfTradeMsg::xdr_convert(XDR* xdrs, xdr_op x_op)
{
char* str;
if (x_op == XDR_ENCODE)
{
if (!header.xdr_convert(xdrs, x_op))
{
fprintf(stderr, "Bad XDR conversion on CS header\n");
return FALSE;
}
}
else xdrs->x_op = x_op;
if (!xdr_char(xdrs, &ins_upd_del_flag))
{
fprintf(stderr, "Bad XDR conversion on 'ins_upd_del_flag'\n");
return FALSE;
}
if (!xdr_char(xdrs, &put_call))
{
fprintf(stderr, "Bad XDR conversion on 'put_call'\n");
return FALSE;
}
if (!xdr_char(xdrs, &buy_sell))
{
fprintf(stderr, "Bad XDR conversion on 'buy_sell'\n");
return FALSE;
}
if (!xdr_char(xdrs, &origin))
{
fprintf(stderr, "Bad XDR conversion on 'origin'\n");
return FALSE;
}
if (!xdr_char(xdrs, &open_close))
{
fprintf(stderr, "Bad XDR conversion on 'open_close'\n");
return FALSE;
}
str = (char *) trade_id;
if (!xdr_string(xdrs, &str, sizeof(trade_id)))
{
fprintf(stderr, "Bad XDR conversion on 'trade_id'\n");
return FALSE;
}
str = (char *) user_id;
if (!xdr_string(xdrs, &str, sizeof(user_id)))
{
fprintf(stderr, "Bad XDR conversion on 'user_id'\n");
return FALSE;
}
str = (char *) trading_sym;
if (!xdr_string(xdrs, &str, sizeof(trading_sym)))
{
fprintf(stderr, "Bad XDR conversion on 'trading_sym'\n");
return FALSE;
}
str = (char *) base_sym;
if (!xdr_string(xdrs, &str, sizeof(base_sym)))
{
fprintf(stderr, "Bad XDR conversion on 'base_sym'\n");
return FALSE;
}
str = (char *) parent_account;
if (!xdr_string(xdrs, &str, sizeof(parent_account)))
{
fprintf(stderr, "Bad XDR conversion on 'parent_account'\n");
return FALSE;
}
str = (char *) account;
if (!xdr_string(xdrs, &str, sizeof(account)))
{
fprintf(stderr, "Bad XDR conversion on 'account'\n");
return FALSE;
}
str = (char *) q_account;
if (!xdr_string(xdrs, &str, sizeof(q_account)))
{
fprintf(stderr, "Bad XDR conversion on 'q_account'\n");
return FALSE;
}
str = (char *) security_type;
if (!xdr_string(xdrs, &str, sizeof(security_type)))
{
fprintf(stderr, "Bad XDR conversion on 'security_type'\n");
return FALSE;
}
str = (char *) security_subtype;
if (!xdr_string(xdrs, &str, sizeof(security_subtype)))
{
fprintf(stderr, "Bad XDR conversion on 'security_subtype'\n");
return FALSE;
}
str = (char *) clearing_firm;
if (!xdr_string(xdrs, &str, sizeof(clearing_firm)))
{
fprintf(stderr, "Bad XDR conversion on 'clearing_firm'\n");
return FALSE;
}
str = (char *) cusip;
if (!xdr_string(xdrs, &str, sizeof(cusip)))
{
fprintf(stderr, "Bad XDR conversion on 'cusip'\n");
return FALSE;
}
str = (char *) basket_id;
if (!xdr_string(xdrs, &str, sizeof(basket_id)))
{
fprintf(stderr, "Bad XDR conversion on 'basket_id'\n");
return FALSE;
}
str = (char *) giveup_firm;
if (!xdr_string(xdrs, &str, sizeof(giveup_firm)))
{
fprintf(stderr, "Bad XDR conversion on 'giveup_firm'\n");
return FALSE;
}
str = (char *) contra_firm;
if (!xdr_string(xdrs, &str, sizeof(contra_firm)))
{
fprintf(stderr, "Bad XDR conversion on 'contra_firm'\n");
return FALSE;
}
str = (char *) exec_broker;
if (!xdr_string(xdrs, &str, sizeof(exec_broker)))
{
fprintf(stderr, "Bad XDR conversion on 'exec_broker'\n");
return FALSE;
}
str = (char *) contra_broker;
if (!xdr_string(xdrs, &str, sizeof(contra_broker)))
{
fprintf(stderr, "Bad XDR conversion on 'contra_broker'\n");
return FALSE;
}
str = (char *) mmcs_sub_acct;
if (!xdr_string(xdrs, &str, sizeof(mmcs_sub_acct)))
{
fprintf(stderr, "Bad XDR conversion on 'mmcs_sub_acct'\n");
return FALSE;
}
if (!xdr_double(xdrs, &exercise_multiplier))
{
fprintf(stderr, "Bad XDR conversion on 'exercise_multiplier'\n");
return FALSE;
}
if (!xdr_double(xdrs, &extended_premium))
{
fprintf(stderr, "Bad XDR conversion on 'extended_premium'\n");
return FALSE;
}
if (!xdr_double(xdrs, &premium))
{
fprintf(stderr, "Bad XDR conversion on 'premium'\n");
return FALSE;
}
if (!xdr_double(xdrs, &strike))
{
fprintf(stderr, "Bad XDR conversion on 'strike'\n");
return FALSE;
}
if (!xdr_double(xdrs, &price))
{
fprintf(stderr, "Bad XDR conversion on 'price'\n");
return FALSE;
}
if (!xdr_int(xdrs, &quantity))
{
fprintf(stderr, "Bad XDR conversion on 'quantity'\n");
return FALSE;
}
if (!xdr_int(xdrs, &tag))
{
fprintf(stderr, "Bad XDR conversion on 'tag'\n");
return FALSE;
}
if (!xdr_foc_datetime(xdrs, &expiration_date))
{
fprintf(stderr, "Bad XDR conversion on 'expiration_date'\n");
return FALSE;
}
if (!xdr_foc_datetime(xdrs, &execution_date))
{
fprintf(stderr, "Bad XDR conversion on 'execution_date'\n");
return FALSE;
}
if (!xdr_foc_datetime(xdrs, &last_upd_date))
{
fprintf(stderr, "Bad XDR conversion on 'last_upd_date'\n");
return FALSE;
}
if (!xdr_foc_datetime(xdrs, &contract_date))
{
fprintf(stderr, "Bad XDR conversion on 'contract_date'\n");
return FALSE;
}
if (!xdr_int(xdrs, &source_system))
{
fprintf(stderr, "Bad XDR conversion on 'source_system'\n");
return FALSE;
}
if (!xdr_int(xdrs, &trade_id_num))
{
fprintf(stderr, "Bad XDR conversion on 'trade_id_num'\n");
return FALSE;
}
if (!xdr_int(xdrs, &trade_group_id))
{
fprintf(stderr, "Bad XDR conversion on 'trade_group_id'\n");
return FALSE;
}
if (!xdr_foc_datetime(xdrs, &settlement_date))
{
fprintf(stderr, "Bad XDR conversion on 'settlement_date'\n");
return FALSE;
}
str = (char *) entry_firm;
if (!xdr_string(xdrs, &str, sizeof(entry_firm)))
{
fprintf(stderr, "Bad XDR conversion on 'entry_firm'\n");
return FALSE;
}
if (!xdr_char(xdrs, &matched_flag))
{
fprintf(stderr, "Bad XDR conversion on 'matched_flag'\n");
return FALSE;
}
if (!xdr_char(xdrs, &spread_ind))
{
fprintf(stderr, "Bad XDR conversion on 'spread_ind'\n");
return FALSE;
}
if (!xdr_double(xdrs, &premium_multiplier))
{
fprintf(stderr, "Bad XDR conversion on 'premium_multiplier'\n");
return FALSE;
}
str = (char *) source_code;
if (!xdr_string(xdrs, &str, sizeof(source_code)))
{
fprintf(stderr, "Bad XDR conversion on 'source_code'\n");
return FALSE;
}
str = (char *) parent_acct_intrl_id;
if (!xdr_string(xdrs, &str, sizeof(parent_acct_intrl_id)))
{
fprintf(stderr, "Bad XDR conversion on 'parent_acct_intrl_id'\n");
return FALSE;
}
str = (char *) acct_intrl_id;
if (!xdr_string(xdrs, &str, sizeof(acct_intrl_id)))
{
fprintf(stderr, "Bad XDR conversion on 'acct_intrl_id'\n");
return FALSE;
}
str = (char *) q_acct_intrl_id;
if (!xdr_string(xdrs, &str, sizeof(q_acct_intrl_id)))
{
fprintf(stderr, "Bad XDR conversion on 'q_acct_intrl_id'\n");
return FALSE;
}
if (!xdr_double(xdrs, &cap_interval))
{
fprintf(stderr, "Bad XDR conversion on 'cap_interval'\n");
return FALSE;
}
if (!xdr_int(xdrs, &trade_exchange))
{
fprintf(stderr, "Bad XDR conversion on 'trade_exchange'\n");
return FALSE;
}
if (!xdr_char(xdrs, &settled_unsettled_ind))
{
fprintf(stderr, "Bad XDR conversion on 'settled_unsettled_ind'\n");
return FALSE;
}
if (!xdr_char(xdrs, &stock_origin))
{
fprintf(stderr, "Bad XDR conversion on 'stock_origin'\n");
return FALSE;
}
str = (char *) mm_card_number;
if (!xdr_string(xdrs, &str, sizeof(mm_card_number)))
{
fprintf(stderr, "Bad XDR conversion on 'mm_card_number'\n");
return FALSE;
}
if (!xdr_int(xdrs, &basket_tag))
{
fprintf(stderr, "Bad XDR conversion on 'basket_tag'\n");
return FALSE;
}
if (!xdr_double(xdrs, &basket_price))
{
fprintf(stderr, "Bad XDR conversion on 'basket_price'\n");
return FALSE;
}
if (!xdr_char(xdrs, &short_sale))
{
fprintf(stderr, "Bad XDR conversion on 'short_sale'\n");
return FALSE;
}
str = (char *) commission_code;
if (!xdr_string(xdrs, &str, sizeof(commission_code)))
{
fprintf(stderr, "Bad XDR conversion on 'commission_code'\n");
return FALSE;
}
if (!xdr_double(xdrs, &commission))
{
fprintf(stderr, "Bad XDR conversion on 'commission'\n");
return FALSE;
}
if (!xdr_char(xdrs, &same_day_exer))
{
fprintf(stderr, "Bad XDR conversion on 'same_day_exer'\n");
return FALSE;
}
str = (char *) terminal_name;
if (!xdr_string(xdrs, &str, sizeof(terminal_name)))
{
fprintf(stderr, "Bad XDR conversion on 'terminal_name'\n");
return FALSE;
}
return TRUE;
}
bool_t
xdr_ppathcnf (XDR *xdrs, ppathcnf *objp)
{
register int32_t *buf;
int i;
if (xdrs->x_op == XDR_ENCODE) {
buf = XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT);
if (buf == NULL) {
if (!xdr_int (xdrs, &objp->pc_link_max))
return FALSE;
if (!xdr_short (xdrs, &objp->pc_max_canon))
return FALSE;
if (!xdr_short (xdrs, &objp->pc_max_input))
return FALSE;
if (!xdr_short (xdrs, &objp->pc_name_max))
return FALSE;
if (!xdr_short (xdrs, &objp->pc_path_max))
return FALSE;
if (!xdr_short (xdrs, &objp->pc_pipe_buf))
return FALSE;
} else {
IXDR_PUT_LONG(buf, objp->pc_link_max);
IXDR_PUT_SHORT(buf, objp->pc_max_canon);
IXDR_PUT_SHORT(buf, objp->pc_max_input);
IXDR_PUT_SHORT(buf, objp->pc_name_max);
IXDR_PUT_SHORT(buf, objp->pc_path_max);
IXDR_PUT_SHORT(buf, objp->pc_pipe_buf);
}
if (!xdr_u_char (xdrs, &objp->pc_vdisable))
return FALSE;
if (!xdr_char (xdrs, &objp->pc_xxx))
return FALSE;
buf = XDR_INLINE (xdrs, ( 2 ) * BYTES_PER_XDR_UNIT);
if (buf == NULL) {
if (!xdr_vector (xdrs, (char *)objp->pc_mask, 2,
sizeof (short), (xdrproc_t) xdr_short))
return FALSE;
} else {
{
register short *genp;
for (i = 0, genp = objp->pc_mask;
i < 2; ++i) {
IXDR_PUT_SHORT(buf, *genp++);
}
}
}
return TRUE;
} else if (xdrs->x_op == XDR_DECODE) {
buf = XDR_INLINE (xdrs, 6 * BYTES_PER_XDR_UNIT);
if (buf == NULL) {
if (!xdr_int (xdrs, &objp->pc_link_max))
return FALSE;
if (!xdr_short (xdrs, &objp->pc_max_canon))
return FALSE;
if (!xdr_short (xdrs, &objp->pc_max_input))
return FALSE;
if (!xdr_short (xdrs, &objp->pc_name_max))
return FALSE;
if (!xdr_short (xdrs, &objp->pc_path_max))
return FALSE;
if (!xdr_short (xdrs, &objp->pc_pipe_buf))
return FALSE;
} else {
objp->pc_link_max = IXDR_GET_LONG(buf);
objp->pc_max_canon = IXDR_GET_SHORT(buf);
objp->pc_max_input = IXDR_GET_SHORT(buf);
objp->pc_name_max = IXDR_GET_SHORT(buf);
objp->pc_path_max = IXDR_GET_SHORT(buf);
objp->pc_pipe_buf = IXDR_GET_SHORT(buf);
}
if (!xdr_u_char (xdrs, &objp->pc_vdisable))
return FALSE;
if (!xdr_char (xdrs, &objp->pc_xxx))
return FALSE;
buf = XDR_INLINE (xdrs, ( 2 ) * BYTES_PER_XDR_UNIT);
if (buf == NULL) {
if (!xdr_vector (xdrs, (char *)objp->pc_mask, 2,
sizeof (short), (xdrproc_t) xdr_short))
return FALSE;
} else {
{
register short *genp;
for (i = 0, genp = objp->pc_mask;
i < 2; ++i) {
*genp++ = IXDR_GET_SHORT(buf);
}
}
}
return TRUE;
}
if (!xdr_int (xdrs, &objp->pc_link_max))
return FALSE;
if (!xdr_short (xdrs, &objp->pc_max_canon))
return FALSE;
if (!xdr_short (xdrs, &objp->pc_max_input))
return FALSE;
if (!xdr_short (xdrs, &objp->pc_name_max))
return FALSE;
if (!xdr_short (xdrs, &objp->pc_path_max))
return FALSE;
if (!xdr_short (xdrs, &objp->pc_pipe_buf))
return FALSE;
if (!xdr_u_char (xdrs, &objp->pc_vdisable))
return FALSE;
if (!xdr_char (xdrs, &objp->pc_xxx))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->pc_mask, 2,
sizeof (short), (xdrproc_t) xdr_short))
return FALSE;
return TRUE;
}
bool_t P_xdr_char(XDR *x, char *c) { return (xdr_char(x, c));}