Пример #1
0
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();
}
Пример #2
0
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);
}
Пример #3
0
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;
}
Пример #4
0
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);
}
Пример #5
0
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;
}
Пример #6
0
/*
 * 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);
    }
}
Пример #7
0
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);
}
Пример #8
0
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);
}
Пример #9
0
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);
}
Пример #10
0
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;
}
Пример #11
0
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;
}
Пример #12
0
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;
}
Пример #13
0
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);
} 
Пример #14
0
void
F77_FUNC(xdrfchar,XDRFCHAR)(int *xdrid, char *cp, int *ret)
{
	*ret = xdr_char(xdridptr[*xdrid], cp);
	cnt += sizeof(char);
}
Пример #15
0
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;
}	
Пример #16
0
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;
}
Пример #17
0
bool_t P_xdr_char(XDR *x, char *c) { return (xdr_char(x, c));}