bool_t
xdr_ndmp3_scsi_set_target_request (XDR *xdrs, ndmp3_scsi_set_target_request *objp)
{
if (!xdr_string (xdrs, &objp->device, ~0))
return FALSE;
if (!xdr_u_short (xdrs, &objp->target_controller))
return FALSE;
if (!xdr_u_short (xdrs, &objp->target_id))
return FALSE;
if (!xdr_u_short (xdrs, &objp->target_lun))
return FALSE;
return TRUE;
}
bool_t
xdr_ndmp3_connect_open_request (XDR *xdrs, ndmp3_connect_open_request *objp)
{
if (!xdr_u_short (xdrs, &objp->protocol_version))
return FALSE;
return TRUE;
}
/*
* Serializes/deserializes a ypreq_xfr structure.
*/
bool
xdr_ypreq_xfr(XDR *xdrs, struct ypreq_xfr *ps)
{
return ((bool)(xdr_ypmap_parms(xdrs, &ps->map_parms) &&
xdr_u_int(xdrs, &ps->transid) &&
xdr_u_int(xdrs, &ps->proto) &&
xdr_u_short(xdrs, &ps->port)));
}
void
F77_FUNC(xdrfushort,XDRFUSHORT)(int *xdrid, unsigned short *usp, int *ret)
{
xdr_fortran_lock();
*ret = xdr_u_short(xdridptr[*xdrid], (unsigned short *)usp);
cnt += sizeof(unsigned short);
xdr_fortran_unlock();
}
bool_t
xdr_amq_mount_tree(XDR *xdrs, amq_mount_tree *objp)
{
if (!xdr_amq_string(xdrs, &objp->mt_mountinfo)) {
return (FALSE);
}
if (!xdr_amq_string(xdrs, &objp->mt_directory)) {
return (FALSE);
}
if (!xdr_amq_string(xdrs, &objp->mt_mountpoint)) {
return (FALSE);
}
if (!xdr_amq_string(xdrs, &objp->mt_type)) {
return (FALSE);
}
if (!xdr_time_type(xdrs, &objp->mt_mounttime)) {
return (FALSE);
}
if (!xdr_u_short(xdrs, &objp->mt_mountuid)) {
return (FALSE);
}
if (!xdr_int(xdrs, &objp->mt_getattr)) {
return (FALSE);
}
if (!xdr_int(xdrs, &objp->mt_lookup)) {
return (FALSE);
}
if (!xdr_int(xdrs, &objp->mt_readdir)) {
return (FALSE);
}
if (!xdr_int(xdrs, &objp->mt_readlink)) {
return (FALSE);
}
if (!xdr_int(xdrs, &objp->mt_statfs)) {
return (FALSE);
}
if (!xdr_pointer(xdrs, (char **) &objp->mt_next, sizeof(amq_mount_tree), (XDRPROC_T_TYPE) xdr_amq_mount_tree)) {
return (FALSE);
}
if (!xdr_pointer(xdrs, (char **) &objp->mt_child, sizeof(amq_mount_tree), (XDRPROC_T_TYPE) xdr_amq_mount_tree)) {
return (FALSE);
}
return (TRUE);
}
bool_t
xdr_Iu16 (XDR *xdrs, Iu16 *objp)
{
register int32_t *buf;
if (!xdr_u_short (xdrs, objp))
return FALSE;
return TRUE;
}
bool_t
xdr_ndmp3_tcp_addr (XDR *xdrs, ndmp3_tcp_addr *objp)
{
if (!xdr_u_long (xdrs, &objp->ip_addr))
return FALSE;
if (!xdr_u_short (xdrs, &objp->port))
return FALSE;
return TRUE;
}
bool_t
xdr_resStty (XDR *xdrs, struct resStty *tty, struct LSFHeader *hdr)
{
if (xdrs->x_op == XDR_ENCODE) {
if (!encodeTermios_(xdrs, &tty->termattr))
return (FALSE);
} else {
if (!decodeTermios_(xdrs, &tty->termattr))
return (FALSE);
}
if (! (xdr_u_short(xdrs, &tty->ws.ws_row) &&
xdr_u_short(xdrs, &tty->ws.ws_col) &&
xdr_u_short(xdrs, &tty->ws.ws_xpixel) &&
xdr_u_short(xdrs, &tty->ws.ws_ypixel)))
return (FALSE);
return (TRUE);
}
bool_t
xdr_ndmp3_notify_connected_request (XDR *xdrs, ndmp3_notify_connected_request *objp)
{
if (!xdr_ndmp3_connect_reason (xdrs, &objp->reason))
return FALSE;
if (!xdr_u_short (xdrs, &objp->protocol_version))
return FALSE;
if (!xdr_string (xdrs, &objp->text_reason, ~0))
return FALSE;
return TRUE;
}
bool_t
xdr_authunix_parms (XDR * xdrs, struct authunix_parms *p)
{
if (xdr_u_long (xdrs, &(p->aup_time))
&& xdr_string (xdrs, &(p->aup_machname), MAX_MACHINE_NAME)
&& (sizeof (uid_t) == sizeof (short int)
? xdr_u_short (xdrs, (u_short *) & (p->aup_uid))
: xdr_u_int (xdrs, (u_int *) & (p->aup_uid)))
&& (sizeof (gid_t) == sizeof (short int)
? xdr_u_short (xdrs, (u_short *) & (p->aup_gid))
: xdr_u_int (xdrs, (u_int *) & (p->aup_gid)))
&& xdr_array (xdrs, (caddr_t *) & (p->aup_gids),
& (p->aup_len), NGRPS, sizeof (gid_t),
(sizeof (gid_t) == sizeof (short int)
? (xdrproc_t) xdr_u_short : (xdrproc_t) xdr_u_int)))
{
return TRUE;
}
return FALSE;
}
bool_t
xdr_pmap(
XDR *xdrs,
struct pmap *regs)
{
if (xdr_prog_t(xdrs, ®s->pm_prog) &&
xdr_vers_t(xdrs, ®s->pm_vers) &&
xdr_proto_t(xdrs, ®s->pm_prot))
return (xdr_u_short(xdrs, ®s->pm_port));
return (FALSE);
}
bool_t xdr_Create_LinkResp (XDR *xdrs, Create_LinkResp *objp)
{
if (!xdr_Device_ErrorCode (xdrs, &objp->error))
return FALSE;
if (!xdr_Device_Link (xdrs, &objp->lid))
return FALSE;
if (!xdr_u_short (xdrs, &objp->abortPort))
return FALSE;
if (!xdr_u_long (xdrs, &objp->maxRecvSize))
return FALSE;
return TRUE;
}
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);
}
/*
* More XDR routines - Should be used for OUTPUT ONLY.
*/
bool_t
xdr_amq_mount_tree_node(XDR *xdrs, amq_mount_tree *objp)
{
am_node *mp = (am_node *) objp;
long mtime;
if (!xdr_amq_string(xdrs, &mp->am_al->al_mnt->mf_info)) {
return (FALSE);
}
if (!xdr_amq_string(xdrs, &mp->am_path)) {
return (FALSE);
}
if (!xdr_amq_string(xdrs, mp->am_link ? &mp->am_link : &mp->am_al->al_mnt->mf_mount)) {
return (FALSE);
}
if (!xdr_amq_string(xdrs, &mp->am_al->al_mnt->mf_ops->fs_type)) {
return (FALSE);
}
mtime = mp->am_stats.s_mtime;
if (!xdr_long(xdrs, &mtime)) {
return (FALSE);
}
if (!xdr_u_short(xdrs, &mp->am_stats.s_uid)) {
return (FALSE);
}
if (!xdr_int(xdrs, &mp->am_stats.s_getattr)) {
return (FALSE);
}
if (!xdr_int(xdrs, &mp->am_stats.s_lookup)) {
return (FALSE);
}
if (!xdr_int(xdrs, &mp->am_stats.s_readdir)) {
return (FALSE);
}
if (!xdr_int(xdrs, &mp->am_stats.s_readlink)) {
return (FALSE);
}
if (!xdr_int(xdrs, &mp->am_stats.s_statfs)) {
return (FALSE);
}
return (TRUE);
}
bool_t xdr_foc_datetime(XDR* xdrs, FOC_DATETIME* dttm)
{
if (!xdr_u_char(xdrs, &dttm->sec))
{
fprintf(stderr, "Bad XDR conversion on 'FOC_DATETIME(sec)'\n");
return FALSE;
}
if (!xdr_u_char(xdrs, &dttm->min))
{
fprintf(stderr, "Bad XDR conversion on 'FOC_DATETIME(min)'\n");
return FALSE;
}
if (!xdr_u_char(xdrs, &dttm->hour))
{
fprintf(stderr, "Bad XDR conversion on 'FOC_DATETIME(hour)'\n");
return FALSE;
}
if (!xdr_u_char(xdrs, &dttm->day))
{
fprintf(stderr, "Bad XDR conversion on 'FOC_DATETIME(day)'\n");
return FALSE;
}
if (!xdr_u_char(xdrs, &dttm->month))
{
fprintf(stderr, "Bad XDR conversion on 'FOC_DATETIME(month)'\n");
return FALSE;
}
if (!xdr_u_short(xdrs, &dttm->year))
{
fprintf(stderr, "Bad XDR conversion on 'FOC_DATETIME(year)'\n");
return FALSE;
}
return TRUE;
}
bool FocCsHeader::xdr_convert(XDR* xdrs, xdr_op x_op)
{
char* str;
xdrs->x_op = x_op;
str = (char *) orig_id;
if (!xdr_string(xdrs, &str, sizeof(orig_id)))
{
fprintf(stderr, "Bad XDR conversion on 'orig_id'\n");
return FALSE;
}
str = (char *) recip_id;
if (!xdr_string(xdrs, &str, sizeof(recip_id)))
{
fprintf(stderr, "Bad XDR conversion on 'recip_id'\n");
return FALSE;
}
if (!xdr_u_char(xdrs, &msg_priority))
{
fprintf(stderr, "Bad XDR conversion on 'msg_priority'\n");
return FALSE;
}
if (!xdr_u_char(xdrs, &msg_class))
{
fprintf(stderr, "Bad XDR conversion on 'msg_class'\n");
return FALSE;
}
if (!xdr_u_char(xdrs, &num_items))
{
fprintf(stderr, "Bad XDR conversion on 'num_items'\n");
return FALSE;
}
if (!xdr_u_char(xdrs, &msg_type))
{
fprintf(stderr, "Bad XDR conversion on 'msg_type'\n");
return FALSE;
}
if (!xdr_u_short(xdrs, &service_id))
{
fprintf(stderr, "Bad XDR conversion on 'service_id'\n");
return FALSE;
}
if (!xdr_u_short(xdrs, &msg_time))
{
fprintf(stderr, "Bad XDR conversion on 'msg_time'\n");
return FALSE;
}
if (!xdr_u_long(xdrs, &msg_seq_num))
{
fprintf(stderr, "Bad XDR conversion on 'msg_seq_num'\n");
return FALSE;
}
return TRUE;
}
/*--------------------------------------------------------------------*/
int mbr_hsds2lam_wr_data(int verbose, void *mbio_ptr, void *store_ptr, int *error)
{
char *function_name = "mbr_hsds2lam_wr_data";
int status = MB_SUCCESS;
struct mb_io_struct *mb_io_ptr;
struct mbsys_atlas_struct *store;
int xdr_status;
int strlength;
int telegram_id;
int i;
/* print input debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> called\n",function_name);
fprintf(stderr,"dbg2 Input arguments:\n");
fprintf(stderr,"dbg2 verbose: %d\n",verbose);
fprintf(stderr,"dbg2 mbio_ptr: %lu\n",(size_t)mbio_ptr);
fprintf(stderr,"dbg2 store_ptr: %lu\n",(size_t)store_ptr);
}
/* get pointer to mbio descriptor */
mb_io_ptr = (struct mb_io_struct *) mbio_ptr;
/* get pointer to raw data structure */
store = (struct mbsys_atlas_struct *) store_ptr;
/* print debug statements */
#ifndef MBR_HSDS2LAM_DEBUG
if (verbose >= 5)
#endif
{
fprintf(stderr,"\ndbg5 HSDS2LAM telegram to be written in MBIO function <%s>\n",function_name);
fprintf(stderr,"dbg5 kind: %d\n",store->kind);
if (store->kind == MB_DATA_COMMENT)
{
fprintf(stderr,"dbg5 comment: %s\n",store->comment);
}
else
{
fprintf(stderr,"dbg5 start_ping_no: %d\n",store->start_ping_no);
fprintf(stderr,"dbg5 start_transmit_time_d: %f\n",store->start_transmit_time_d);
fprintf(stderr,"dbg5 start_opmode: ");
for (i=0;i<32;i++)
fprintf(stderr," %d",store->start_opmode[i]);
fprintf(stderr,"\n");
fprintf(stderr,"dbg5 start_heave: %f\n",store->start_heave);
fprintf(stderr,"dbg5 start_roll: %f\n",store->start_roll);
fprintf(stderr,"dbg5 start_pitch: %f\n",store->start_pitch);
fprintf(stderr,"dbg5 start_heading: %f\n",store->start_heading);
fprintf(stderr,"dbg5 start_ckeel: %f\n",store->start_ckeel);
fprintf(stderr,"dbg5 start_cmean: %f\n",store->start_cmean);
fprintf(stderr,"dbg5 start_depth_min: %f\n",store->start_depth_min);
fprintf(stderr,"dbg5 start_depth_max: %f\n",store->start_depth_max);
fprintf(stderr,"dbg5 tt_ping_no: %d\n",store->tt_ping_no);
fprintf(stderr,"dbg5 tt_transmit_time_d: %f\n",store->tt_transmit_time_d);
fprintf(stderr,"dbg5 tt_beam_table_index: %d\n",store->tt_beam_table_index);
fprintf(stderr,"dbg5 tt_beam_cnt: %d\n",store->tt_beam_cnt);
fprintf(stderr,"dbg5 tt_long1: %d\n",store->tt_long1);
fprintf(stderr,"dbg5 tt_long2: %d\n",store->tt_long2);
fprintf(stderr,"dbg5 tt_long3: %d\n",store->tt_long3);
fprintf(stderr,"dbg5 tt_xdraught: %d\n",store->tt_xdraught);
fprintf(stderr,"dbg5 tt_double1: %f\n",store->tt_double1);
fprintf(stderr,"dbg5 tt_double2: %f\n",store->tt_double2);
fprintf(stderr,"dbg5 tt_sensdraught: %f\n",store->tt_sensdraught);
fprintf(stderr,"dbg5 tt_draught: %f\n",store->tt_draught);
fprintf(stderr,"dbg5 beam bath xtrack lttrack tt amp stat flag:\n");
for (i=0;i<store->tt_beam_cnt;i++)
fprintf(stderr,"dbg5 %4d %12f %12f %12f %12f %3d %3d %3d\n",
i, store->pr_bath[i], store->pr_bathacrosstrack[i], store->pr_bathalongtrack[i],
store->tt_lruntime[i], store->tt_lamplitude[i],
store->tt_lstatus[i], store->pr_beamflag[i]);
fprintf(stderr,"dbg5 ss_ping_no: %d\n",store->ss_ping_no);
fprintf(stderr,"dbg5 ss_transmit_time_d: %f\n",store->ss_transmit_time_d);
fprintf(stderr,"dbg5 ss_timedelay: %f\n",store->ss_timedelay);
fprintf(stderr,"dbg5 ss_timespacing: %f\n",store->ss_timespacing);
fprintf(stderr,"dbg5 ss_max_side_bb_cnt: %d\n",store->ss_max_side_bb_cnt);
fprintf(stderr,"dbg5 ss_max_side_sb_cnt: %d\n",store->ss_max_side_sb_cnt);
for (i=0;i<(store->ss_max_side_bb_cnt + store->ss_max_side_sb_cnt);i++)
fprintf(stderr,"dbg5 pixel[%d] ss: %d\n",i, store->ss_sidescan[i]);
fprintf(stderr,"dbg5 tr_ping_no: %d\n",store->tr_ping_no);
fprintf(stderr,"dbg5 tr_transmit_time_d: %f\n",store->tr_transmit_time_d);
fprintf(stderr,"dbg5 tr_window_mode: %d\n",store->tr_window_mode);
fprintf(stderr,"dbg5 tr_no_of_win_groups: %d\n",store->tr_no_of_win_groups);
for (i=0;i<MBSYS_ATLAS_MAXWINDOWS;i++)
{
fprintf(stderr,"dbg5 window[%d]:cnt start stop: %d %f %f\n",
i, store->tr_repeat_count[i], store->tr_start[i], store->tr_stop[i]);
}
fprintf(stderr,"dbg5 bs_ping_no: %d\n",store->bs_ping_no);
fprintf(stderr,"dbg5 bs_transmit_time_d: %f\n",store->bs_transmit_time_d);
fprintf(stderr,"dbg5 bs_nrActualGainSets: %d\n",store->bs_nrActualGainSets);
fprintf(stderr,"dbg5 bs_rxGup: %f\n",store->bs_rxGup);
fprintf(stderr,"dbg5 bs_rxGain: %f\n",store->bs_rxGain);
fprintf(stderr,"dbg5 bs_ar: %f\n",store->bs_ar);
for (i=0;i<MBSYS_ATLAS_HSDS2_RX_PAR;i++)
{
fprintf(stderr,"dbg5 tvgrx[%d]: time gain: %f %f\n",
i, store->bs_TvgRx_time[i], store->bs_TvgRx_gain[i]);
}
fprintf(stderr,"dbg5 bs_nrTxSets: %d\n",store->bs_nrTxSets);
for (i=0;i<MBSYS_ATLAS_HSDS2_TX_PAR;i++)
{
fprintf(stderr,"dbg5 tx[%d]: # gain ang len: %d %f %f %f\n",
i, store->bs_txBeamIndex[i], store->bs_txLevel[i],
store->bs_txBeamAngle[i], store->bs_pulseLength[i]);
}
fprintf(stderr,"dbg5 bs_nrBsSets: %d\n",store->bs_nrBsSets);
for (i=0;i<MBSYS_ATLAS_HSDS2_TX_PAR;i++)
{
fprintf(stderr,"dbg5 bs[%d]: # tau amp nis: %f %d %d\n",
i, store->bs_m_tau[i], store->bs_eff_ampli[i], store->bs_nis[i]);
}
}
}
/* write the next record (hsds2lam telegram) */
*error = MB_ERROR_NO_ERROR;
/* write ping record */
if (store->kind == MB_DATA_DATA
|| store->kind == MB_DATA_CALIBRATE)
{
telegram_id = MBSYS_ATLAS_TELEGRAM_HSDS2LAM;
xdr_status = xdr_int(mb_io_ptr->xdrs, &telegram_id);
if (xdr_status == MB_YES)
xdr_status = xdr_u_int(mb_io_ptr->xdrs, &store->start_ping_no);
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &store->start_transmit_time_d);
strlength = 32;
if (xdr_status == MB_YES)
xdr_status = xdr_int(mb_io_ptr->xdrs, &strlength);
if (xdr_status == MB_YES)
xdr_status = xdr_opaque(mb_io_ptr->xdrs, (char *)store->start_opmode, strlength);
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &store->start_heave);
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &store->start_roll);
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &store->start_pitch);
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &store->start_heading);
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &store->start_ckeel);
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &store->start_cmean);
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &store->start_depth_min);
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &store->start_depth_max);
if (xdr_status == MB_YES)
xdr_status = xdr_u_int(mb_io_ptr->xdrs, &store->tt_ping_no);
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &store->tt_transmit_time_d);
if (xdr_status == MB_YES)
xdr_status = xdr_int(mb_io_ptr->xdrs, &store->tt_beam_table_index);
if (xdr_status == MB_YES)
xdr_status = xdr_int(mb_io_ptr->xdrs, &store->tt_beam_cnt);
if (xdr_status == MB_YES)
xdr_status = xdr_int(mb_io_ptr->xdrs, &store->tt_long1);
if (xdr_status == MB_YES)
xdr_status = xdr_int(mb_io_ptr->xdrs, &store->tt_long2);
if (xdr_status == MB_YES)
xdr_status = xdr_int(mb_io_ptr->xdrs, &store->tt_long3);
if (xdr_status == MB_YES)
xdr_status = xdr_int(mb_io_ptr->xdrs, &store->tt_xdraught);
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &store->tt_double1);
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &store->tt_double2);
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &store->tt_sensdraught);
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &store->tt_draught);
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &store->pr_navlon);
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &store->pr_navlat);
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &store->pr_speed);
for (i=0;i<store->tt_beam_cnt;i++)
{
if (xdr_status == MB_YES)
xdr_status = xdr_float(mb_io_ptr->xdrs, &(store->tt_lruntime[i]));
}
if (store->tt_beam_cnt % 4 == 0)
strlength = store->tt_beam_cnt;
else
strlength = 4 * ((store->tt_beam_cnt / 4) + 1);
if (xdr_status == MB_YES)
xdr_status = xdr_int(mb_io_ptr->xdrs, &strlength);
if (xdr_status == MB_YES)
xdr_status = xdr_opaque(mb_io_ptr->xdrs, (char *)store->tt_lamplitude, strlength);
if (store->tt_beam_cnt % 4 == 0)
strlength = store->tt_beam_cnt;
else
strlength = 4 * ((store->tt_beam_cnt / 4) + 1);
if (xdr_status == MB_YES)
xdr_status = xdr_int(mb_io_ptr->xdrs, &strlength);
if (xdr_status == MB_YES)
xdr_status = xdr_opaque(mb_io_ptr->xdrs, (char *)store->tt_lstatus, strlength);
for (i=0;i<store->tt_beam_cnt;i++)
{
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &(store->pr_bath[i]));
}
for (i=0;i<store->tt_beam_cnt;i++)
{
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &(store->pr_bathacrosstrack[i]));
}
for (i=0;i<store->tt_beam_cnt;i++)
{
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &(store->pr_bathalongtrack[i]));
}
if (store->tt_beam_cnt % 4 == 0)
strlength = store->tt_beam_cnt;
else
strlength = 4 * ((store->tt_beam_cnt / 4) + 1);
if (xdr_status == MB_YES)
xdr_status = xdr_int(mb_io_ptr->xdrs, &strlength);
if (xdr_status == MB_YES)
xdr_status = xdr_opaque(mb_io_ptr->xdrs, (char *)store->pr_beamflag, strlength);
if (xdr_status == MB_YES)
xdr_status = xdr_u_int(mb_io_ptr->xdrs, &store->ss_ping_no);
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &store->ss_transmit_time_d);
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &store->ss_timedelay);
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &store->ss_timespacing);
if (xdr_status == MB_YES)
xdr_status = xdr_int(mb_io_ptr->xdrs, &store->ss_max_side_bb_cnt);
if (xdr_status == MB_YES)
xdr_status = xdr_int(mb_io_ptr->xdrs, &store->ss_max_side_sb_cnt);
if ((store->ss_max_side_bb_cnt + store->ss_max_side_sb_cnt) % 4 == 0)
strlength = store->ss_max_side_bb_cnt + store->ss_max_side_sb_cnt;
else
strlength = 4 * (((store->ss_max_side_bb_cnt + store->ss_max_side_sb_cnt) / 4) + 1);
if (xdr_status == MB_YES)
xdr_status = xdr_int(mb_io_ptr->xdrs, &strlength);
xdr_status = xdr_opaque(mb_io_ptr->xdrs, (char *)store->ss_sidescan, strlength);
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &store->tr_transmit_time_d);
if (xdr_status == MB_YES)
xdr_status = xdr_u_int(mb_io_ptr->xdrs, &store->tr_ping_no);
if (xdr_status == MB_YES)
xdr_status = xdr_int(mb_io_ptr->xdrs, &store->tr_window_mode);
if (xdr_status == MB_YES)
xdr_status = xdr_int(mb_io_ptr->xdrs, &store->tr_no_of_win_groups);
for (i=0;i<100;i++)
{
if (xdr_status == MB_YES)
xdr_status = xdr_int(mb_io_ptr->xdrs, &store->tr_repeat_count[i]);
if (xdr_status == MB_YES)
xdr_status = xdr_float(mb_io_ptr->xdrs, &store->tr_start[i]);
if (xdr_status == MB_YES)
xdr_status = xdr_float(mb_io_ptr->xdrs, &store->tr_stop[i]);
}
if (xdr_status == MB_YES)
xdr_status = xdr_double(mb_io_ptr->xdrs, &store->bs_transmit_time_d);
if (xdr_status == MB_YES)
xdr_status = xdr_int(mb_io_ptr->xdrs, &store->bs_ping_no);
if (xdr_status == MB_YES)
xdr_status = xdr_u_short(mb_io_ptr->xdrs, &store->bs_nrActualGainSets);
if (xdr_status == MB_YES)
xdr_status = xdr_float(mb_io_ptr->xdrs, &store->bs_rxGup);
if (xdr_status == MB_YES)
xdr_status = xdr_float(mb_io_ptr->xdrs, &store->bs_rxGain);
if (xdr_status == MB_YES)
xdr_status = xdr_float(mb_io_ptr->xdrs, &store->bs_ar);
for (i=0;i<MBSYS_ATLAS_HSDS2_RX_PAR;i++)
{
if (xdr_status == MB_YES)
xdr_status = xdr_float(mb_io_ptr->xdrs, &store->bs_TvgRx_time[i]);
if (xdr_status == MB_YES)
xdr_status = xdr_float(mb_io_ptr->xdrs, &store->bs_TvgRx_gain[i]);
}
if (xdr_status == MB_YES)
xdr_status = xdr_u_short(mb_io_ptr->xdrs, &store->bs_nrTxSets);
for (i=0;i<MBSYS_ATLAS_HSDS2_TX_PAR;i++)
{
if (xdr_status == MB_YES)
xdr_status = xdr_u_int(mb_io_ptr->xdrs, &store->bs_txBeamIndex[i]);
if (xdr_status == MB_YES)
xdr_status = xdr_float(mb_io_ptr->xdrs, &store->bs_txLevel[i]);
if (xdr_status == MB_YES)
xdr_status = xdr_float(mb_io_ptr->xdrs, &store->bs_txBeamAngle[i]);
if (xdr_status == MB_YES)
xdr_status = xdr_float(mb_io_ptr->xdrs, &store->bs_pulseLength[i]);
}
if (xdr_status == MB_YES)
xdr_status = xdr_u_short(mb_io_ptr->xdrs, &store->bs_nrBsSets);
for (i=0;i<MBSYS_ATLAS_HSDS2_PFB_NUM;i++)
{
if (xdr_status == MB_YES)
xdr_status = xdr_float(mb_io_ptr->xdrs, &store->bs_m_tau[i]);
}
strlength = MBSYS_ATLAS_HSDS2_PFB_NUM;
if (xdr_status == MB_YES)
xdr_status = xdr_int(mb_io_ptr->xdrs, &strlength);
if (xdr_status == MB_YES)
xdr_status = xdr_opaque(mb_io_ptr->xdrs, (char *)store->bs_eff_ampli, strlength);
strlength = MBSYS_ATLAS_HSDS2_PFB_NUM;
if (xdr_status == MB_YES)
xdr_status = xdr_int(mb_io_ptr->xdrs, &strlength);
if (xdr_status == MB_YES)
xdr_status = xdr_opaque(mb_io_ptr->xdrs, (char *)store->bs_nis, strlength);
}
/* write comment record */
else if (store->kind == MB_DATA_COMMENT)
{
telegram_id = MBSYS_ATLAS_TELEGRAM_COMMENTLAM;
xdr_status = xdr_int(mb_io_ptr->xdrs, &telegram_id);
if ((strlen(store->comment) + 1) % 4 == 0)
strlength = strlen(store->comment) + 1;
else
strlength = 4 * (((strlen(store->comment) + 1) / 4) + 1);
if (xdr_status == MB_YES)
xdr_status = xdr_int(mb_io_ptr->xdrs, &strlength);
if (xdr_status == MB_YES)
xdr_status = xdr_opaque(mb_io_ptr->xdrs, (char *)store->comment, strlength);
}
/* set error if required */
if (xdr_status == MB_NO)
{
*error = MB_ERROR_WRITE_FAIL;
status = MB_FAILURE;
}
/* print output debug statements */
if (verbose >= 2)
{
fprintf(stderr,"\ndbg2 MBIO function <%s> completed\n",function_name);
fprintf(stderr,"dbg2 Return values:\n");
fprintf(stderr,"dbg2 error: %d\n",*error);
fprintf(stderr,"dbg2 Return status:\n");
fprintf(stderr,"dbg2 status: %d\n",status);
}
/* return status */
return(status);
}
static gmx_bool do_xdr(t_fileio *fio, void *item, int nitem, int eio,
const char *desc, const char *srcfile, int line)
{
unsigned char ucdum, *ucptr;
bool_t res = 0;
float fvec[DIM];
double dvec[DIM];
int j, m, *iptr, idum;
gmx_large_int_t sdum;
real *ptr;
unsigned short us;
double d = 0;
float f = 0;
gmx_fio_check_nitem(fio, eio, nitem, srcfile, line);
switch (eio)
{
case eioREAL:
if (fio->bDouble)
{
if (item && !fio->bRead)
d = *((real *) item);
res = xdr_double(fio->xdr, &d);
if (item)
*((real *) item) = d;
}
else
{
if (item && !fio->bRead)
f = *((real *) item);
res = xdr_float(fio->xdr, &f);
if (item)
*((real *) item) = f;
}
break;
case eioFLOAT:
if (item && !fio->bRead)
f = *((float *) item);
res = xdr_float(fio->xdr, &f);
if (item)
*((float *) item) = f;
break;
case eioDOUBLE:
if (item && !fio->bRead)
d = *((double *) item);
res = xdr_double(fio->xdr, &d);
if (item)
*((double *) item) = d;
break;
case eioINT:
if (item && !fio->bRead)
idum = *(int *) item;
res = xdr_int(fio->xdr, &idum);
if (item)
*(int *) item = idum;
break;
case eioGMX_LARGE_INT:
/* do_xdr will not generate a warning when a 64bit gmx_large_int_t
* value that is out of 32bit range is read into a 32bit gmx_large_int_t.
*/
if (item && !fio->bRead)
sdum = *(gmx_large_int_t *) item;
res = xdr_gmx_large_int(fio->xdr, &sdum, NULL);
if (item)
*(gmx_large_int_t *) item = sdum;
break;
case eioUCHAR:
if (item && !fio->bRead)
ucdum = *(unsigned char *) item;
res = xdr_u_char(fio->xdr, &ucdum);
if (item)
*(unsigned char *) item = ucdum;
break;
case eioNUCHAR:
ucptr = (unsigned char *) item;
res = 1;
for (j = 0; (j < nitem) && res; j++)
{
res = xdr_u_char(fio->xdr, &(ucptr[j]));
}
break;
case eioUSHORT:
if (item && !fio->bRead)
us = *(unsigned short *) item;
res = xdr_u_short(fio->xdr, (unsigned short *) &us);
if (item)
*(unsigned short *) item = us;
break;
case eioRVEC:
if (fio->bDouble)
{
if (item && !fio->bRead)
for (m = 0; (m < DIM); m++)
dvec[m] = ((real *) item)[m];
res = xdr_vector(fio->xdr, (char *) dvec, DIM,
(unsigned int) sizeof(double),
(xdrproc_t) xdr_double);
if (item)
for (m = 0; (m < DIM); m++)
((real *) item)[m] = dvec[m];
}
else
{
if (item && !fio->bRead)
for (m = 0; (m < DIM); m++)
fvec[m] = ((real *) item)[m];
res = xdr_vector(fio->xdr, (char *) fvec, DIM,
(unsigned int) sizeof(float),
(xdrproc_t) xdr_float);
if (item)
for (m = 0; (m < DIM); m++)
((real *) item)[m] = fvec[m];
}
break;
case eioNRVEC:
ptr = NULL;
res = 1;
for (j = 0; (j < nitem) && res; j++)
{
if (item)
ptr = ((rvec *) item)[j];
res = do_xdr(fio, ptr, 1, eioRVEC, desc, srcfile, line);
}
break;
case eioIVEC:
iptr = (int *) item;
res = 1;
for (m = 0; (m < DIM) && res; m++)
{
if (item && !fio->bRead)
idum = iptr[m];
res = xdr_int(fio->xdr, &idum);
if (item)
iptr[m] = idum;
}
break;
case eioSTRING:
{
char *cptr;
int slen;
if (item)
{
if (!fio->bRead)
slen = strlen((char *) item) + 1;
else
slen = 0;
}
else
slen = 0;
if (xdr_int(fio->xdr, &slen) <= 0)
gmx_fatal(FARGS, "wrong string length %d for string %s"
" (source %s, line %d)",slen,desc,srcfile,line);
if (!item && fio->bRead)
snew(cptr,slen);
else
cptr=(char *)item;
if (cptr)
res = xdr_string(fio->xdr,&cptr,slen);
else
res = 1;
if (!item && fio->bRead)
sfree(cptr);
break;
}
default:
gmx_fio_fe(fio, eio, desc, srcfile, line);
}
if ((res == 0) && (fio->bDebug))
fprintf(stderr,"Error in xdr I/O %s %s to file %s (source %s, line %d)\n",
eioNames[eio],desc,fio->fn,srcfile,line);
return (res != 0);
}
