/*
* XDR a call message
*/
bool_t
xdr_callmsg(XDR *xdrs, struct rpc_msg *cmsg)
{
enum msg_type *prm_direction;
int32_t *buf;
struct opaque_auth *oa;
if (xdrs->x_op == XDR_ENCODE) {
if (cmsg->rm_call.cb_cred.oa_length > MAX_AUTH_BYTES) {
return (FALSE);
}
if (cmsg->rm_call.cb_verf.oa_length > MAX_AUTH_BYTES) {
return (FALSE);
}
buf = XDR_INLINE(xdrs, 8 * BYTES_PER_XDR_UNIT
+ RNDUP(cmsg->rm_call.cb_cred.oa_length)
+ 2 * BYTES_PER_XDR_UNIT
+ RNDUP(cmsg->rm_call.cb_verf.oa_length));
if (buf != NULL) {
IXDR_PUT_INT32(buf, cmsg->rm_xid);
IXDR_PUT_ENUM(buf, cmsg->rm_direction);
if (cmsg->rm_direction != CALL) {
return (FALSE);
}
IXDR_PUT_INT32(buf, cmsg->rm_call.cb_rpcvers);
if (cmsg->rm_call.cb_rpcvers != RPC_MSG_VERSION) {
return (FALSE);
}
IXDR_PUT_INT32(buf, cmsg->rm_call.cb_prog);
IXDR_PUT_INT32(buf, cmsg->rm_call.cb_vers);
IXDR_PUT_INT32(buf, cmsg->rm_call.cb_proc);
oa = &cmsg->rm_call.cb_cred;
IXDR_PUT_ENUM(buf, oa->oa_flavor);
IXDR_PUT_INT32(buf, oa->oa_length);
if (oa->oa_length) {
memcpy(buf, oa->oa_base, oa->oa_length);
buf += RNDUP(oa->oa_length) / sizeof (int32_t);
}
oa = &cmsg->rm_call.cb_verf;
IXDR_PUT_ENUM(buf, oa->oa_flavor);
IXDR_PUT_INT32(buf, oa->oa_length);
if (oa->oa_length) {
memcpy(buf, oa->oa_base, oa->oa_length);
/* no real need....
buf += RNDUP(oa->oa_length) / sizeof (int32_t);
*/
}
return (TRUE);
}
}
if (xdrs->x_op == XDR_DECODE) {
buf = XDR_INLINE(xdrs, 8 * BYTES_PER_XDR_UNIT);
if (buf != NULL) {
cmsg->rm_xid = IXDR_GET_UINT32(buf);
cmsg->rm_direction = IXDR_GET_ENUM(buf, enum msg_type);
if (cmsg->rm_direction != CALL) {
return (FALSE);
}
cmsg->rm_call.cb_rpcvers = IXDR_GET_UINT32(buf);
if (cmsg->rm_call.cb_rpcvers != RPC_MSG_VERSION) {
return (FALSE);
}
cmsg->rm_call.cb_prog = IXDR_GET_UINT32(buf);
cmsg->rm_call.cb_vers = IXDR_GET_UINT32(buf);
cmsg->rm_call.cb_proc = IXDR_GET_UINT32(buf);
oa = &cmsg->rm_call.cb_cred;
oa->oa_flavor = IXDR_GET_ENUM(buf, enum_t);
oa->oa_length = (u_int)IXDR_GET_UINT32(buf);
if (oa->oa_length) {
if (oa->oa_length > MAX_AUTH_BYTES) {
return (FALSE);
}
if (oa->oa_base == NULL) {
oa->oa_base = (caddr_t)
mem_alloc(oa->oa_length);
if (oa->oa_base == NULL)
return (FALSE);
}
buf = XDR_INLINE(xdrs, RNDUP(oa->oa_length));
if (buf == NULL) {
if (xdr_opaque(xdrs, oa->oa_base,
oa->oa_length) == FALSE) {
return (FALSE);
}
} else {
memcpy(oa->oa_base, buf,
oa->oa_length);
/* no real need....
buf += RNDUP(oa->oa_length) /
sizeof (int32_t);
*/
}
}
oa = &cmsg->rm_call.cb_verf;
buf = XDR_INLINE(xdrs, 2 * BYTES_PER_XDR_UNIT);
if (buf == NULL) {
if (xdr_enum(xdrs, &oa->oa_flavor) == FALSE ||
xdr_u_int(xdrs, &oa->oa_length) == FALSE) {
return (FALSE);
}
} else {
oa->oa_flavor = IXDR_GET_ENUM(buf, enum_t);
oa->oa_length = (u_int)IXDR_GET_UINT32(buf);
}
if (oa->oa_length) {
if (oa->oa_length > MAX_AUTH_BYTES) {
return (FALSE);
}
if (oa->oa_base == NULL) {
oa->oa_base = (caddr_t)
mem_alloc(oa->oa_length);
if (oa->oa_base == NULL)
return (FALSE);
}
buf = XDR_INLINE(xdrs, RNDUP(oa->oa_length));
if (buf == NULL) {
if (xdr_opaque(xdrs, oa->oa_base,
oa->oa_length) == FALSE) {
return (FALSE);
}
} else {
memcpy(oa->oa_base, buf,
oa->oa_length);
/* no real need...
buf += RNDUP(oa->oa_length) /
sizeof (int32_t);
*/
}
}
return (TRUE);
}
/*
* XDR null terminated ASCII strings
* xdr_string deals with "C strings" - arrays of bytes that are
* terminated by a NULL character. The parameter cpp references a
* pointer to storage; If the pointer is null, then the necessary
* storage is allocated. The last parameter is the max allowed length
* of the string as specified by a protocol.
*/
bool_t
xdr_string(XDR *xdrs, char **cpp, const uint_t maxsize)
{
char *sp = *cpp; /* sp is the actual string pointer */
uint_t size;
uint_t nodesize;
/*
* first deal with the length since xdr strings are counted-strings
*/
switch (xdrs->x_op) {
case XDR_FREE:
if (sp == NULL)
return (TRUE); /* already free */
/* FALLTHROUGH */
case XDR_ENCODE:
size = (sp != NULL) ? (uint_t)strlen(sp) : 0;
break;
case XDR_DECODE:
break;
}
if (!xdr_u_int(xdrs, &size)) {
return (FALSE);
}
if (size > maxsize) {
return (FALSE);
}
nodesize = size + 1;
/*
* now deal with the actual bytes
*/
switch (xdrs->x_op) {
case XDR_DECODE:
if (nodesize == 0)
return (TRUE);
if (sp == NULL)
sp = (char *)mem_alloc(nodesize);
sp[size] = 0;
if (!xdr_opaque(xdrs, sp, size)) {
/*
* free up memory if allocated here
*/
if (*cpp == NULL) {
mem_free(sp, nodesize);
}
return (FALSE);
}
if (strlen(sp) != size) {
if (*cpp == NULL) {
mem_free(sp, nodesize);
}
return (FALSE);
}
*cpp = sp;
return (TRUE);
case XDR_ENCODE:
return (xdr_opaque(xdrs, sp, size));
case XDR_FREE:
mem_free(sp, nodesize);
*cpp = NULL;
return (TRUE);
}
return (FALSE);
}
static int
occompile1(OCstate* state, OCnode* xnode, OCmemdata** memdatap, XDR* xdrs)
{
unsigned int i,j,xdrcount;
int stat = OC_NOERR;
size_t nelements;
OCmemdata* memdata = NULL;
OCmemdata* structdata = NULL;
OClist* records = NULL;
OCerror ocstat = OC_NOERR;
OCmemdata** pmem = NULL;
/* Allocate the space for this memdata chunk */
switch (xnode->octype) {
case OC_Dataset:
case OC_Grid:
case OC_Structure: {
if(xnode->array.rank == 0) {
ocstat = occompilefields(state,xnode,&memdata,xdrs);
if(ocstat != OC_NOERR) goto fail;
} else { /* rank > 0 */
/* Compute the actual index count after projections */
nelements = totaldimsize(xnode);
if(nelements == 0) return OCTHROW(OC_ENODATA);
memdata = makememdata(xnode->octype,OC_NAT,nelements);
MEMCHECK(memdata,OC_ENOMEM);
memdata->mode = Dimmode;
pmem = (OCmemdata**)&memdata->data;
/* Consume the leading count field */
if(!xdr_u_int(xdrs,&xdrcount)) {stat = OC_EXDR; goto fail;}
/* validate the datadds dimensions */
if(xdrcount != nelements) {stat=OC_EINVALCOORDS; goto fail;}
for(i=0;i<nelements;i++) {
ocstat = occompilefields(state,xnode,&structdata,xdrs);
if(ocstat != OC_NOERR) {
if(ocstat != OC_ENODATA) goto fail;
structdata = NULL; /* Leave a hole for this element */
}
pmem[i] = structdata;
structdata = NULL;
}
}
} break;
case OC_Sequence:{
/* Since we do not know the # records beforehand,
use a oclist to collect the record instances.
Query: this stores by recor (where e.g. original ocapi
stores by column). How hard would it be to make the
storage choice conditional on some user defined flag?
*/
records = oclistnew();
for(;;) {
/* pick up the sequence record begin marker*/
char tmp[sizeof(unsigned int)];
/* extract the tag byte*/
if(!xdr_opaque(xdrs,tmp,sizeof(tmp))) {stat = OC_EXDR; goto fail;}
if(tmp[0] == StartOfoclist) { /* Walk each member field*/
ocstat = occompilefields(state,xnode,&structdata,xdrs);
if(ocstat != OC_NOERR) goto fail;
oclistpush(records,(ocelem)structdata);
structdata = NULL;
} else if(tmp[0] == EndOfoclist) {
break; /* we are done with the this sequence instance*/
} else {
oc_log(LOGERR,"missing/invalid begin/end record marker\n");
stat = OC_EINVALCOORDS;
goto fail;
}
}
/* Convert the list to a proper OCmemdata */
nelements = oclistlength(records);
memdata = makememdata(xnode->octype,OC_NAT,nelements);
MEMCHECK(memdata,OC_ENOMEM);
memdata->mode = Recordmode;
pmem = (OCmemdata**)&memdata->data;
for(j=0;j<nelements;j++) {
OCmemdata* record = (OCmemdata*)oclistget(records,j);
pmem[j] = record;
}
oclistfree(records);
records = NULL;
} break;
case OC_Primitive:
ocstat = occompileprim(state,xnode,&memdata,xdrs);
if(ocstat != OC_NOERR) goto fail;
break;
default: OCPANIC1("ocmap: encountered unexpected node type: %x",xnode->octype);
break;
}
/*ok:*/
if(memdatap) *memdatap = memdata;
return OCTHROW(ocstat);
fail:
if(records != NULL) for(i=0;i<oclistlength(records);i++)
freeocmemdata((OCmemdata*)oclistget(records,i));
freeocmemdata(memdata);
freeocmemdata(structdata);
return OCTHROW(ocstat);
}
/*--------------------------------------------------------------------*/
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 int
occompileprim(OCstate* state, OCnode* xnode, OCmemdata** memdatap, XDR* xdrs)
{
unsigned int xdrcount,i;
size_t nelements = 0;
OCerror ocstat = OC_NOERR;
OCmemdata* memdata = NULL;
OCASSERT((xnode->octype == OC_Primitive));
/* Use the count from the datadds */
nelements = totaldimsize(xnode);
if(xnode->array.rank > 0) {
/* Get first copy of the dimension count */
if(!xdr_u_int(xdrs,&xdrcount)) {ocstat = OC_EXDR; goto fail;}
if(xdrcount != nelements) {ocstat=OC_EINVALCOORDS; goto fail;}
if(xnode->etype != OC_String && xnode->etype != OC_URL) {
/* Get second copy of the dimension count */
if(!xdr_u_int(xdrs,&xdrcount)) {ocstat = OC_EXDR; goto fail;}
if(xdrcount != nelements) {ocstat=OC_EINVALCOORDS; goto fail;}
}
} else {
nelements = 1;
xdrcount = 1;
}
memdata = makememdata(xnode->octype,xnode->etype,nelements);
MEMCHECK(memdata,OC_ENOMEM);
memdata->mode = (xnode->array.rank > 0?Dimmode:Datamode);
switch (xnode->etype) {
case OC_String: case OC_URL: {/* Get the array of strings and store pointers in buf */
char** dst = (char**)memdata->data.data;
for(i=0;i<xdrcount;i++) {
char* s = NULL;
if(!xdr_string(xdrs,(void*)&s,OC_INT32_MAX)) {ocstat = OC_EXDR; goto fail;}
dst[i] = s;
}
} break;
case OC_Byte:
case OC_UByte:
case OC_Char: {
if(xnode->array.rank == 0) { /* Single unpacked character/byte */
union {unsigned int i; char c[BYTES_PER_XDR_UNIT];} u;
if(!xdr_opaque(xdrs,u.c,BYTES_PER_XDR_UNIT)) {ocstat = OC_EXDR; goto fail;}
u.i = ocntoh(u.i);
memdata->data.data[0] = (char)u.i;
} else { /* Packed characters; count will have already been read */
char* dst = memdata->data.data;
if(!xdr_opaque(xdrs,dst,xdrcount)) {ocstat = OC_EXDR; goto fail;}
}
} break;
case OC_Int16: case OC_UInt16: {
unsigned short* dst = (unsigned short*)memdata->data.data;
unsigned int* src;
size_t xdrsize = xdrcount*BYTES_PER_XDR_UNIT;
src = (unsigned int*)ocmalloc(xdrsize);
if(!xdr_opaque(xdrs,(char*)src,xdrsize)) {ocfree(src); ocstat = OC_EXDR; goto fail;}
if(!oc_network_order) {
for(i=0;i<xdrcount;i++) { /* Write in place */
unsigned int hostint = src[i];
swapinline(dst[i],hostint);
}
}
ocfree(src);
} break;
case OC_Int32: case OC_UInt32:
case OC_Float32: {
unsigned int* dst = (unsigned int*)memdata->data.data;
size_t xdrsize = xdrcount*BYTES_PER_XDR_UNIT;
if(!xdr_opaque(xdrs,(char*)dst,xdrsize)) {ocstat = OC_EXDR; goto fail;}
if(!oc_network_order) {
for(i=0;i<xdrcount;i++) {
unsigned int hostint = dst[i];
swapinline(dst[i],hostint);
}
}
} break;
case OC_Int64: case OC_UInt64:
case OC_Float64: {
unsigned int* dst = (unsigned int*)memdata->data.data;
size_t xdrsize = 2*xdrcount*BYTES_PER_XDR_UNIT;
if(!xdr_opaque(xdrs,(char*)dst,xdrsize)) {ocstat = OC_EXDR; goto fail;}
if(!oc_network_order) {
for(i=0;i<2*xdrcount;i++) {
unsigned int hostint = dst[i];
swapinline(dst[i],hostint);
}
}
if(oc_invert_xdr_double) { /* May need to invert each pair */
for(i=0;i<2*xdrcount;i+=2) {
unsigned int tmp = dst[i];
dst[i] = dst[i+1];
dst[i+1] = tmp;
}
}
} break;
default: OCPANIC1("unexpected etype: %d",xnode->etype);
} /* switch */
/*ok:*/
if(memdatap) *memdatap = memdata;
return OCTHROW(ocstat);
fail:
freeocmemdata(memdata);
return OCTHROW(ocstat);
}
