bool_t
xdrrdma_getrdmablk(XDR *xdrs, struct clist **rlist, uint_t *sizep,
CONN **conn, const uint_t maxsize)
{
xrdma_private_t *xdrp = (xrdma_private_t *)(xdrs->x_private);
struct clist *cle = *(xdrp->xp_rcl_next);
struct clist *rdclist = NULL, *prev = NULL;
bool_t retval = TRUE;
uint32_t cur_offset = 0;
uint32_t total_segments = 0;
uint32_t actual_segments = 0;
uint32_t alen;
uint_t total_len;
ASSERT(xdrs->x_op != XDR_FREE);
/*
* first deal with the length since xdr bytes are counted
*/
if (!xdr_u_int(xdrs, sizep)) {
DTRACE_PROBE(xdr__e__getrdmablk_sizep_fail);
return (FALSE);
}
total_len = *sizep;
if (total_len > maxsize) {
DTRACE_PROBE2(xdr__e__getrdmablk_bad_size,
int, total_len, int, maxsize);
return (FALSE);
}
(*conn) = xdrp->xp_conn;
/*
* if no data we are done
*/
if (total_len == 0)
return (TRUE);
while (cle) {
total_segments++;
cle = cle->c_next;
}
cle = *(xdrp->xp_rcl_next);
/*
* If there was a chunk at the current offset, then setup a read
* chunk list which records the destination address and length
* and will RDMA READ the data in later.
*/
if (cle == NULL)
return (FALSE);
if (cle->c_xdroff != (xdrp->xp_offp - xdrs->x_base))
return (FALSE);
/*
* Setup the chunk list with appropriate
* address (offset) and length
*/
for (actual_segments = 0;
actual_segments < total_segments; actual_segments++) {
DTRACE_PROBE3(krpc__i__xdrrdma_getrdmablk, uint32_t, cle->c_len,
uint32_t, total_len, uint32_t, cle->c_xdroff);
if (total_len <= 0)
break;
/*
* not the first time in the loop
*/
if (actual_segments > 0)
cle = cle->c_next;
cle->u.c_daddr = (uint64) cur_offset;
alen = 0;
if (cle->c_len > total_len) {
alen = cle->c_len;
cle->c_len = total_len;
}
if (!alen)
xdrp->xp_rcl_next = &cle->c_next;
cur_offset += cle->c_len;
total_len -= cle->c_len;
if ((total_segments - actual_segments - 1) == 0 &&
total_len > 0) {
DTRACE_PROBE(krpc__e__xdrrdma_getblk_chunktooshort);
retval = FALSE;
}
if ((total_segments - actual_segments - 1) > 0 &&
total_len == 0) {
DTRACE_PROBE2(krpc__e__xdrrdma_getblk_toobig,
int, total_segments, int, actual_segments);
}
rdclist = clist_alloc();
(*rdclist) = (*cle);
if ((*rlist) == NULL)
(*rlist) = rdclist;
if (prev == NULL)
prev = rdclist;
else {
prev->c_next = rdclist;
prev = rdclist;
}
}
out:
if (prev != NULL)
prev->c_next = NULL;
/*
* Adjust the chunk length, if we read only a part of
* a chunk.
*/
if (alen) {
cle->w.c_saddr =
(uint64)(uintptr_t)cle->w.c_saddr + cle->c_len;
cle->c_len = alen - cle->c_len;
}
return (retval);
}
/* Skip arbitrary single instance; except for primitives
Assumes that parent will handle arrays of compound instances
or records of compound instances of this node type
Specifically, all array counts have been absorbed by some parent caller.*/
int
ocskipinstance(OCnode* node, XDR* xdrs)
{
unsigned int i;
int stat = OC_NOERR;
unsigned int xdrcount;
#if 0
unsigned int j,rank;
switch (node->octype) {
case OC_Dataset:
case OC_Grid:
OCASSERT((node->array.rank == 0));
stat = ocskip(node,xdrs);
break;
case OC_Sequence: /* instance is essentially same a structure */
case OC_Structure:
if(node->dap.instancesize > 0) { /* do a direct skip*/
if(!xdr_skip(xdrs,node->dap.instancesize)) return xdrerror();
} else {
/* Non-uniform size, we have to skip field by field*/
/* Walk each structure/sequence field*/
for(j=0;j<oclistlength(node->subnodes);j++) {
OCnode* field = (OCnode*)oclistget(node->subnodes,j);
stat = ocskip(field,xdrs);
if(stat != OC_NOERR) break;
}
if(stat != OC_NOERR) break;
}
break;
case OC_Primitive:
if(node->etype == OC_String || node->etype == OC_URL) {
if(!xdr_u_int(xdrs,&xdrcount)) return xdrerror();
if(!xdr_skip(xdrs,xdrcount)) return xdrerror();
} else {
OCASSERT((node->dap.instancesize > 0));
if(!xdr_skip(xdrs,node->dap.instancesize)) return xdrerror();
}
break;
default:
OCPANIC1("oc_move: encountered unexpected node type: %x",node->octype);
break;
}
#else
if(node->dap.instancesize > 0) { /* do a direct skip*/
if(!xdr_skip(xdrs,node->dap.instancesize)) return xdrerror();
} else if(node->octype == OC_Primitive) {
OCASSERT((node->etype == OC_String || node->etype == OC_URL));
if(!xdr_u_int(xdrs,&xdrcount)) return xdrerror();
if(!xdr_skip(xdrs,xdrcount)) return xdrerror();
} else {
/* Non-uniform size Grid/Sequence/Structure/Dataset;*/
/* we have to skip field by field*/
for(i=0;i<oclistlength(node->subnodes);i++) {
OCnode* field = (OCnode*)oclistget(node->subnodes,i);
stat = ocskip(field,xdrs);
if(stat != OC_NOERR) break;
}
}
#endif
return THROW(stat);
}
bool_t
Xdr_rpc_gss_unwrap_data(XDR *xdrs, xdrproc_t xdr_func, caddr_t xdr_ptr,
gss_ctx_id_t ctx, gss_qop_t qop,
rpc_gss_svc_t svc, u_int seq)
{
XDR tmpxdrs;
gss_buffer_desc databuf, wrapbuf;
OM_uint32 maj_stat, min_stat;
u_int seq_num, qop_state;
int conf_state;
bool_t xdr_stat;
if (xdr_func == (xdrproc_t)xdr_void || xdr_ptr == NULL)
return (TRUE);
memset(&databuf, 0, sizeof(databuf));
memset(&wrapbuf, 0, sizeof(wrapbuf));
if (svc == RPCSEC_GSS_SVC_INTEGRITY) {
/* Decode databody_integ. */
if (!Xdr_rpc_gss_buf(xdrs, &databuf, (u_int)-1)) {
LogFullDebug(COMPONENT_RPCSEC_GSS,"xdr decode databody_integ failed");
return (FALSE);
}
/* Decode checksum. */
if (!Xdr_rpc_gss_buf(xdrs, &wrapbuf, (u_int)-1)) {
gss_release_buffer(&min_stat, &databuf);
LogFullDebug(COMPONENT_RPCSEC_GSS,"xdr decode checksum failed");
return (FALSE);
}
/* Verify checksum and QOP. */
maj_stat = gss_verify_mic(&min_stat, ctx, &databuf,
&wrapbuf, &qop_state);
gss_release_buffer(&min_stat, &wrapbuf);
if (maj_stat != GSS_S_COMPLETE || qop_state != qop) {
gss_release_buffer(&min_stat, &databuf);
LogFullDebug(COMPONENT_RPCSEC_GSS,"gss_verify_mic %d %d", maj_stat, min_stat);
return (FALSE);
}
}
else if (svc == RPCSEC_GSS_SVC_PRIVACY) {
/* Decode databody_priv. */
if (!Xdr_rpc_gss_buf(xdrs, &wrapbuf, (u_int)-1)) {
LogFullDebug(COMPONENT_RPCSEC_GSS,"xdr decode databody_priv failed");
return (FALSE);
}
/* Decrypt databody. */
maj_stat = gss_unwrap(&min_stat, ctx, &wrapbuf, &databuf,
&conf_state, &qop_state);
gss_release_buffer(&min_stat, &wrapbuf);
/* Verify encryption and QOP. */
if (maj_stat != GSS_S_COMPLETE || qop_state != qop ||
conf_state != TRUE) {
gss_release_buffer(&min_stat, &databuf);
LogFullDebug(COMPONENT_RPCSEC_GSS,"gss_unwrap %d %d", maj_stat, min_stat);
return (FALSE);
}
}
/* Decode rpc_gss_data_t (sequence number + arguments). */
xdrmem_create(&tmpxdrs, databuf.value, databuf.length, XDR_DECODE);
xdr_stat = (xdr_u_int(&tmpxdrs, &seq_num) &&
(*xdr_func)(&tmpxdrs, xdr_ptr));
XDR_DESTROY(&tmpxdrs);
gss_release_buffer(&min_stat, &databuf);
/* Verify sequence number. */
if (xdr_stat == TRUE && seq_num != seq) {
LogFullDebug(COMPONENT_RPCSEC_GSS,"wrong sequence number in databody");
return (FALSE);
}
return (xdr_stat);
}
bool_t xdr_sattr(XDR *xdrs, sattr *objp)
{
register int32_t *buf = buf;
if(xdrs->x_op == XDR_ENCODE)
{
buf = XDR_INLINE(xdrs, 4 * BYTES_PER_XDR_UNIT);
if(buf == NULL)
{
if(!xdr_u_int(xdrs, &objp->mode))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->uid))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->gid))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->size))
{
return (FALSE);
}
}
else
{
IXDR_PUT_U_LONG(buf, objp->mode);
IXDR_PUT_U_LONG(buf, objp->uid);
IXDR_PUT_U_LONG(buf, objp->gid);
IXDR_PUT_U_LONG(buf, objp->size);
}
if(!xdr_nfstime(xdrs, &objp->atime))
{
return (FALSE);
}
if(!xdr_nfstime(xdrs, &objp->mtime))
{
return (FALSE);
}
return (TRUE);
}
else if(xdrs->x_op == XDR_DECODE)
{
buf = XDR_INLINE(xdrs, 4 * BYTES_PER_XDR_UNIT);
if(buf == NULL)
{
if(!xdr_u_int(xdrs, &objp->mode))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->uid))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->gid))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->size))
{
return (FALSE);
}
}
else
{
objp->mode = IXDR_GET_U_LONG(buf);
objp->uid = IXDR_GET_U_LONG(buf);
objp->gid = IXDR_GET_U_LONG(buf);
objp->size = IXDR_GET_U_LONG(buf);
}
if(!xdr_nfstime(xdrs, &objp->atime))
{
return (FALSE);
}
if(!xdr_nfstime(xdrs, &objp->mtime))
{
return (FALSE);
}
return (TRUE);
}
if(!xdr_u_int(xdrs, &objp->mode))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->uid))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->gid))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->size))
{
return (FALSE);
}
if(!xdr_nfstime(xdrs, &objp->atime))
{
return (FALSE);
}
if(!xdr_nfstime(xdrs, &objp->mtime))
{
return (FALSE);
}
return (TRUE);
}
bool_t xdr_statfsokres(XDR *xdrs, statfsokres *objp)
{
register int32_t *buf = buf;
if(xdrs->x_op == XDR_ENCODE)
{
buf = XDR_INLINE(xdrs, 5 * BYTES_PER_XDR_UNIT);
if(buf == NULL)
{
if(!xdr_u_int(xdrs, &objp->tsize))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->bsize))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->blocks))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->bfree))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->bavail))
{
return (FALSE);
}
}
else
{
IXDR_PUT_U_LONG(buf, objp->tsize);
IXDR_PUT_U_LONG(buf, objp->bsize);
IXDR_PUT_U_LONG(buf, objp->blocks);
IXDR_PUT_U_LONG(buf, objp->bfree);
IXDR_PUT_U_LONG(buf, objp->bavail);
}
return (TRUE);
}
else if(xdrs->x_op == XDR_DECODE)
{
buf = XDR_INLINE(xdrs, 5 * BYTES_PER_XDR_UNIT);
if(buf == NULL)
{
if(!xdr_u_int(xdrs, &objp->tsize))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->bsize))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->blocks))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->bfree))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->bavail))
{
return (FALSE);
}
}
else
{
objp->tsize = IXDR_GET_U_LONG(buf);
objp->bsize = IXDR_GET_U_LONG(buf);
objp->blocks = IXDR_GET_U_LONG(buf);
objp->bfree = IXDR_GET_U_LONG(buf);
objp->bavail = IXDR_GET_U_LONG(buf);
}
return (TRUE);
}
if(!xdr_u_int(xdrs, &objp->tsize))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->bsize))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->blocks))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->bfree))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->bavail))
{
return (FALSE);
}
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
xdr_string(XDR *xdrs, char **cpp, u_int maxsize)
{
char *sp = *cpp; /* sp is the actual string pointer */
u_int size = 0;
u_int 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:
if (sp == NULL)
return FALSE;
size = strlen(sp);
break;
case XDR_DECODE:
break;
}
if (! xdr_u_int(xdrs, &size)) {
return (FALSE);
}
if (size > maxsize) {
return (FALSE);
}
nodesize = size + 1;
if (nodesize == 0) {
/* This means an overflow. It a bug in the caller which
* provided a too large maxsize but nevertheless catch it
* here.
*/
return FALSE;
}
/*
* now deal with the actual bytes
*/
switch (xdrs->x_op) {
case XDR_DECODE:
if (sp == NULL)
*cpp = sp = mem_alloc(nodesize);
if (sp == NULL) {
__warnx(TIRPC_DEBUG_FLAG_XDR,
"xdr_string: out of memory");
return (FALSE);
}
sp[size] = 0;
/* FALLTHROUGH */
case XDR_ENCODE:
return (xdr_opaque(xdrs, sp, size));
case XDR_FREE:
mem_free(sp, nodesize);
*cpp = NULL;
return (TRUE);
}
/* NOTREACHED */
return (FALSE);
}
bool_t
xdr_stats (XDR *xdrs, stats *objp)
{
register int32_t *buf;
int i;
if (xdrs->x_op == XDR_ENCODE) {
buf = XDR_INLINE (xdrs, (10 + CPUSTATES + DK_NDRIVE )* BYTES_PER_XDR_UNIT);
if (buf == NULL) {
if (!xdr_vector (xdrs, (char *)objp->cp_time, CPUSTATES,
sizeof (int), (xdrproc_t) xdr_int))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->dk_xfer, DK_NDRIVE,
sizeof (int), (xdrproc_t) xdr_int))
return FALSE;
if (!xdr_u_int (xdrs, &objp->v_pgpgin))
return FALSE;
if (!xdr_u_int (xdrs, &objp->v_pgpgout))
return FALSE;
if (!xdr_u_int (xdrs, &objp->v_pswpin))
return FALSE;
if (!xdr_u_int (xdrs, &objp->v_pswpout))
return FALSE;
if (!xdr_u_int (xdrs, &objp->v_intr))
return FALSE;
if (!xdr_int (xdrs, &objp->if_ipackets))
return FALSE;
if (!xdr_int (xdrs, &objp->if_ierrors))
return FALSE;
if (!xdr_int (xdrs, &objp->if_oerrors))
return FALSE;
if (!xdr_int (xdrs, &objp->if_collisions))
return FALSE;
if (!xdr_int (xdrs, &objp->if_opackets))
return FALSE;
} else {
{
register int *genp;
for (i = 0, genp = objp->cp_time;
i < CPUSTATES; ++i) {
IXDR_PUT_LONG(buf, *genp++);
}
}
{
register int *genp;
for (i = 0, genp = objp->dk_xfer;
i < DK_NDRIVE; ++i) {
IXDR_PUT_LONG(buf, *genp++);
}
}
IXDR_PUT_U_LONG(buf, objp->v_pgpgin);
IXDR_PUT_U_LONG(buf, objp->v_pgpgout);
IXDR_PUT_U_LONG(buf, objp->v_pswpin);
IXDR_PUT_U_LONG(buf, objp->v_pswpout);
IXDR_PUT_U_LONG(buf, objp->v_intr);
IXDR_PUT_LONG(buf, objp->if_ipackets);
IXDR_PUT_LONG(buf, objp->if_ierrors);
IXDR_PUT_LONG(buf, objp->if_oerrors);
IXDR_PUT_LONG(buf, objp->if_collisions);
IXDR_PUT_LONG(buf, objp->if_opackets);
}
return TRUE;
} else if (xdrs->x_op == XDR_DECODE) {
buf = XDR_INLINE (xdrs, (10 + CPUSTATES + DK_NDRIVE )* BYTES_PER_XDR_UNIT);
if (buf == NULL) {
if (!xdr_vector (xdrs, (char *)objp->cp_time, CPUSTATES,
sizeof (int), (xdrproc_t) xdr_int))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->dk_xfer, DK_NDRIVE,
sizeof (int), (xdrproc_t) xdr_int))
return FALSE;
if (!xdr_u_int (xdrs, &objp->v_pgpgin))
return FALSE;
if (!xdr_u_int (xdrs, &objp->v_pgpgout))
return FALSE;
if (!xdr_u_int (xdrs, &objp->v_pswpin))
return FALSE;
if (!xdr_u_int (xdrs, &objp->v_pswpout))
return FALSE;
if (!xdr_u_int (xdrs, &objp->v_intr))
return FALSE;
if (!xdr_int (xdrs, &objp->if_ipackets))
return FALSE;
if (!xdr_int (xdrs, &objp->if_ierrors))
return FALSE;
if (!xdr_int (xdrs, &objp->if_oerrors))
return FALSE;
if (!xdr_int (xdrs, &objp->if_collisions))
return FALSE;
if (!xdr_int (xdrs, &objp->if_opackets))
return FALSE;
} else {
{
register int *genp;
for (i = 0, genp = objp->cp_time;
i < CPUSTATES; ++i) {
*genp++ = IXDR_GET_LONG(buf);
}
}
{
register int *genp;
for (i = 0, genp = objp->dk_xfer;
i < DK_NDRIVE; ++i) {
*genp++ = IXDR_GET_LONG(buf);
}
}
objp->v_pgpgin = IXDR_GET_U_LONG(buf);
objp->v_pgpgout = IXDR_GET_U_LONG(buf);
objp->v_pswpin = IXDR_GET_U_LONG(buf);
objp->v_pswpout = IXDR_GET_U_LONG(buf);
objp->v_intr = IXDR_GET_U_LONG(buf);
objp->if_ipackets = IXDR_GET_LONG(buf);
objp->if_ierrors = IXDR_GET_LONG(buf);
objp->if_oerrors = IXDR_GET_LONG(buf);
objp->if_collisions = IXDR_GET_LONG(buf);
objp->if_opackets = IXDR_GET_LONG(buf);
}
return TRUE;
}
if (!xdr_vector (xdrs, (char *)objp->cp_time, CPUSTATES,
sizeof (int), (xdrproc_t) xdr_int))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->dk_xfer, DK_NDRIVE,
sizeof (int), (xdrproc_t) xdr_int))
return FALSE;
if (!xdr_u_int (xdrs, &objp->v_pgpgin))
return FALSE;
if (!xdr_u_int (xdrs, &objp->v_pgpgout))
return FALSE;
if (!xdr_u_int (xdrs, &objp->v_pswpin))
return FALSE;
if (!xdr_u_int (xdrs, &objp->v_pswpout))
return FALSE;
if (!xdr_u_int (xdrs, &objp->v_intr))
return FALSE;
if (!xdr_int (xdrs, &objp->if_ipackets))
return FALSE;
if (!xdr_int (xdrs, &objp->if_ierrors))
return FALSE;
if (!xdr_int (xdrs, &objp->if_oerrors))
return FALSE;
if (!xdr_int (xdrs, &objp->if_collisions))
return FALSE;
if (!xdr_int (xdrs, &objp->if_opackets))
return FALSE;
return TRUE;
}
/* Receive file chunks, repeatedly calling 'cb'. */
int
receive_file (receive_cb cb, void *opaque)
{
guestfs_chunk chunk;
char lenbuf[4];
char *buf;
XDR xdr;
int r;
uint32_t len;
for (;;) {
if (verbose)
fprintf (stderr, "guestfsd: receive_file: reading length word\n");
/* Read the length word. */
if (xread (sock, lenbuf, 4) == -1)
exit (EXIT_FAILURE);
xdrmem_create (&xdr, lenbuf, 4, XDR_DECODE);
xdr_u_int (&xdr, &len);
xdr_destroy (&xdr);
if (len == GUESTFS_CANCEL_FLAG)
continue; /* Just ignore it. */
if (len > GUESTFS_MESSAGE_MAX) {
fprintf (stderr, "guestfsd: incoming message is too long (%u bytes)\n",
len);
exit (EXIT_FAILURE);
}
buf = malloc (len);
if (!buf) {
perror ("malloc");
return -1;
}
if (xread (sock, buf, len) == -1)
exit (EXIT_FAILURE);
xdrmem_create (&xdr, buf, len, XDR_DECODE);
memset (&chunk, 0, sizeof chunk);
if (!xdr_guestfs_chunk (&xdr, &chunk)) {
xdr_destroy (&xdr);
free (buf);
return -1;
}
xdr_destroy (&xdr);
free (buf);
if (verbose)
fprintf (stderr,
"guestfsd: receive_file: got chunk: cancel = 0x%x, len = %d, buf = %p\n",
chunk.cancel, chunk.data.data_len, chunk.data.data_val);
if (chunk.cancel != 0 && chunk.cancel != 1) {
fprintf (stderr,
"guestfsd: receive_file: chunk.cancel != [0|1] ... "
"continuing even though we have probably lost synchronization with the library\n");
return -1;
}
if (chunk.cancel) {
if (verbose)
fprintf (stderr,
"guestfsd: receive_file: received cancellation from library\n");
xdr_free ((xdrproc_t) xdr_guestfs_chunk, (char *) &chunk);
return -2;
}
if (chunk.data.data_len == 0) {
if (verbose)
fprintf (stderr,
"guestfsd: receive_file: end of file, leaving function\n");
xdr_free ((xdrproc_t) xdr_guestfs_chunk, (char *) &chunk);
return 0; /* end of file */
}
/* Note that the callback can generate progress messages. */
if (cb)
r = cb (opaque, chunk.data.data_val, chunk.data.data_len);
else
r = 0;
xdr_free ((xdrproc_t) xdr_guestfs_chunk, (char *) &chunk);
if (r == -1) { /* write error */
if (verbose)
fprintf (stderr, "guestfsd: receive_file: write error\n");
return -1;
}
}
}
void
notify_progress (uint64_t position, uint64_t total)
{
struct timeval now_t;
gettimeofday (&now_t, NULL);
/* Always send a notification at 100%. This simplifies callers by
* allowing them to 'finish' the progress bar at 100% without
* needing special code.
*/
if (count_progress > 0 && position == total)
goto send;
/* Calculate time in microseconds since the last progress message
* was sent out (or since the start of the call).
*/
int64_t last_us, now_us, elapsed_us;
last_us =
(int64_t) last_progress_t.tv_sec * 1000000 + last_progress_t.tv_usec;
now_us = (int64_t) now_t.tv_sec * 1000000 + now_t.tv_usec;
elapsed_us = now_us - last_us;
/* Rate limit. */
if ((count_progress == 0 && elapsed_us < NOTIFICATION_INITIAL_DELAY) ||
(count_progress > 0 && elapsed_us < NOTIFICATION_PERIOD))
return;
send:
/* We're going to send a message now ... */
count_progress++;
last_progress_t = now_t;
/* Send the header word. */
XDR xdr;
char buf[128];
uint32_t i = GUESTFS_PROGRESS_FLAG;
size_t len;
xdrmem_create (&xdr, buf, 4, XDR_ENCODE);
xdr_u_int (&xdr, &i);
xdr_destroy (&xdr);
if (xwrite (sock, buf, 4) == -1) {
fprintf (stderr, "guestfsd: xwrite failed\n");
exit (EXIT_FAILURE);
}
guestfs_progress message = {
.proc = proc_nr,
.serial = serial,
.position = position,
.total = total,
};
xdrmem_create (&xdr, buf, sizeof buf, XDR_ENCODE);
if (!xdr_guestfs_progress (&xdr, &message)) {
fprintf (stderr, "guestfsd: xdr_guestfs_progress: failed to encode message\n");
xdr_destroy (&xdr);
return;
}
len = xdr_getpos (&xdr);
xdr_destroy (&xdr);
if (xwrite (sock, buf, len) == -1) {
fprintf (stderr, "guestfsd: xwrite failed\n");
exit (EXIT_FAILURE);
}
}
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);
}
bool_t
xdr_auth_glusterfs_parms_v2 (XDR *xdrs, auth_glusterfs_parms_v2 *objp)
{
register int32_t *buf;
buf = NULL;
if (xdrs->x_op == XDR_ENCODE) {
buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
if (buf == NULL) {
if (!xdr_int (xdrs, &objp->pid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->uid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->gid))
return FALSE;
} else {
IXDR_PUT_LONG(buf, objp->pid);
IXDR_PUT_U_LONG(buf, objp->uid);
IXDR_PUT_U_LONG(buf, objp->gid);
}
if (!xdr_array (xdrs, (char **)&objp->groups.groups_val, (u_int *) &objp->groups.groups_len, ~0,
sizeof (u_int), (xdrproc_t) xdr_u_int))
return FALSE;
if (!xdr_bytes (xdrs, (char **)&objp->lk_owner.lk_owner_val, (u_int *) &objp->lk_owner.lk_owner_len, ~0))
return FALSE;
return TRUE;
} else if (xdrs->x_op == XDR_DECODE) {
buf = XDR_INLINE (xdrs, 3 * BYTES_PER_XDR_UNIT);
if (buf == NULL) {
if (!xdr_int (xdrs, &objp->pid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->uid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->gid))
return FALSE;
} else {
objp->pid = IXDR_GET_LONG(buf);
objp->uid = IXDR_GET_U_LONG(buf);
objp->gid = IXDR_GET_U_LONG(buf);
}
if (!xdr_array (xdrs, (char **)&objp->groups.groups_val, (u_int *) &objp->groups.groups_len, ~0,
sizeof (u_int), (xdrproc_t) xdr_u_int))
return FALSE;
if (!xdr_bytes (xdrs, (char **)&objp->lk_owner.lk_owner_val, (u_int *) &objp->lk_owner.lk_owner_len, ~0))
return FALSE;
return TRUE;
}
if (!xdr_int (xdrs, &objp->pid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->uid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->gid))
return FALSE;
if (!xdr_array (xdrs, (char **)&objp->groups.groups_val, (u_int *) &objp->groups.groups_len, ~0,
sizeof (u_int), (xdrproc_t) xdr_u_int))
return FALSE;
if (!xdr_bytes (xdrs, (char **)&objp->lk_owner.lk_owner_val, (u_int *) &objp->lk_owner.lk_owner_len, ~0))
return FALSE;
return TRUE;
}
bool_t
xdr_auth_glusterfs_parms (XDR *xdrs, auth_glusterfs_parms *objp)
{
register int32_t *buf;
int i;
buf = NULL;
if (xdrs->x_op == XDR_ENCODE) {
if (!xdr_u_quad_t (xdrs, &objp->lk_owner))
return FALSE;
buf = XDR_INLINE (xdrs, (4 + 16 )* BYTES_PER_XDR_UNIT);
if (buf == NULL) {
if (!xdr_u_int (xdrs, &objp->pid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->uid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->gid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->ngrps))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->groups, 16,
sizeof (u_int), (xdrproc_t) xdr_u_int))
return FALSE;
} else {
IXDR_PUT_U_LONG(buf, objp->pid);
IXDR_PUT_U_LONG(buf, objp->uid);
IXDR_PUT_U_LONG(buf, objp->gid);
IXDR_PUT_U_LONG(buf, objp->ngrps);
{
register u_int *genp;
for (i = 0, genp = objp->groups;
i < 16; ++i) {
IXDR_PUT_U_LONG(buf, *genp++);
}
}
}
return TRUE;
} else if (xdrs->x_op == XDR_DECODE) {
if (!xdr_u_quad_t (xdrs, &objp->lk_owner))
return FALSE;
buf = XDR_INLINE (xdrs, (4 + 16 )* BYTES_PER_XDR_UNIT);
if (buf == NULL) {
if (!xdr_u_int (xdrs, &objp->pid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->uid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->gid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->ngrps))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->groups, 16,
sizeof (u_int), (xdrproc_t) xdr_u_int))
return FALSE;
} else {
objp->pid = IXDR_GET_U_LONG(buf);
objp->uid = IXDR_GET_U_LONG(buf);
objp->gid = IXDR_GET_U_LONG(buf);
objp->ngrps = IXDR_GET_U_LONG(buf);
{
register u_int *genp;
for (i = 0, genp = objp->groups;
i < 16; ++i) {
*genp++ = IXDR_GET_U_LONG(buf);
}
}
}
return TRUE;
}
if (!xdr_u_quad_t (xdrs, &objp->lk_owner))
return FALSE;
if (!xdr_u_int (xdrs, &objp->pid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->uid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->gid))
return FALSE;
if (!xdr_u_int (xdrs, &objp->ngrps))
return FALSE;
if (!xdr_vector (xdrs, (char *)objp->groups, 16,
sizeof (u_int), (xdrproc_t) xdr_u_int))
return FALSE;
return TRUE;
}
bool xdr_sq_dqblk(XDR * xdrs, sq_dqblk * objp)
{
register int32_t *buf;
if (xdrs->x_op == XDR_ENCODE) {
buf = xdr_inline_encode(xdrs, 8 * BYTES_PER_XDR_UNIT);
if (buf != NULL) {
/* most likely */
IXDR_PUT_U_INT32(buf, objp->rq_bhardlimit);
IXDR_PUT_U_INT32(buf, objp->rq_bsoftlimit);
IXDR_PUT_U_INT32(buf, objp->rq_curblocks);
IXDR_PUT_U_INT32(buf, objp->rq_fhardlimit);
IXDR_PUT_U_INT32(buf, objp->rq_fsoftlimit);
IXDR_PUT_U_INT32(buf, objp->rq_curfiles);
IXDR_PUT_U_INT32(buf, objp->rq_btimeleft);
IXDR_PUT_U_INT32(buf, objp->rq_ftimeleft);
} else {
if (!XDR_PUTUINT32(xdrs, objp->rq_bhardlimit))
return false;
if (!XDR_PUTUINT32(xdrs, objp->rq_bsoftlimit))
return false;
if (!XDR_PUTUINT32(xdrs, objp->rq_curblocks))
return false;
if (!XDR_PUTUINT32(xdrs, objp->rq_fhardlimit))
return false;
if (!XDR_PUTUINT32(xdrs, objp->rq_fsoftlimit))
return false;
if (!XDR_PUTUINT32(xdrs, objp->rq_curfiles))
return false;
if (!XDR_PUTUINT32(xdrs, objp->rq_btimeleft))
return false;
if (!XDR_PUTUINT32(xdrs, objp->rq_ftimeleft))
return false;
}
return true;
}
if (xdrs->x_op == XDR_DECODE) {
buf = xdr_inline_decode(xdrs, 8 * BYTES_PER_XDR_UNIT);
if (buf != NULL) {
/* most likely */
objp->rq_bhardlimit = IXDR_GET_U_INT32(buf);
objp->rq_bsoftlimit = IXDR_GET_U_INT32(buf);
objp->rq_curblocks = IXDR_GET_U_INT32(buf);
objp->rq_fhardlimit = IXDR_GET_U_INT32(buf);
objp->rq_fsoftlimit = IXDR_GET_U_INT32(buf);
objp->rq_curfiles = IXDR_GET_U_INT32(buf);
objp->rq_btimeleft = IXDR_GET_U_INT32(buf);
objp->rq_ftimeleft = IXDR_GET_U_INT32(buf);
} else {
if (!XDR_GETUINT32(xdrs, &objp->rq_bhardlimit))
return false;
if (!XDR_GETUINT32(xdrs, &objp->rq_bsoftlimit))
return false;
if (!XDR_GETUINT32(xdrs, &objp->rq_curblocks))
return false;
if (!XDR_GETUINT32(xdrs, &objp->rq_fhardlimit))
return false;
if (!XDR_GETUINT32(xdrs, &objp->rq_fsoftlimit))
return false;
if (!XDR_GETUINT32(xdrs, &objp->rq_curfiles))
return false;
if (!XDR_GETUINT32(xdrs, &objp->rq_btimeleft))
return false;
if (!XDR_GETUINT32(xdrs, &objp->rq_ftimeleft))
return false;
}
return true;
}
if (!xdr_u_int(xdrs, &objp->rq_bhardlimit))
return false;
if (!xdr_u_int(xdrs, &objp->rq_bsoftlimit))
return false;
if (!xdr_u_int(xdrs, &objp->rq_curblocks))
return false;
if (!xdr_u_int(xdrs, &objp->rq_fhardlimit))
return false;
if (!xdr_u_int(xdrs, &objp->rq_fsoftlimit))
return false;
if (!xdr_u_int(xdrs, &objp->rq_curfiles))
return false;
if (!xdr_u_int(xdrs, &objp->rq_btimeleft))
return false;
if (!xdr_u_int(xdrs, &objp->rq_ftimeleft))
return false;
return true;
}
void
main_loop (int _sock)
{
XDR xdr;
char *buf;
char lenbuf[4];
uint32_t len;
struct guestfs_message_header hdr;
sock = _sock;
for (;;) {
/* Read the length word. */
if (xread (sock, lenbuf, 4) == -1)
exit (EXIT_FAILURE);
xdrmem_create (&xdr, lenbuf, 4, XDR_DECODE);
xdr_u_int (&xdr, &len);
xdr_destroy (&xdr);
if (verbose)
fprintf (stderr,
"guestfsd: main_loop: new request, len 0x%" PRIx32 "\n",
len);
/* Cancellation sent from the library and received after the
* previous request has finished processing. Just ignore it.
*/
if (len == GUESTFS_CANCEL_FLAG)
continue;
if (len > GUESTFS_MESSAGE_MAX) {
fprintf (stderr, "guestfsd: incoming message is too long (%u bytes)\n",
len);
exit (EXIT_FAILURE);
}
buf = malloc (len);
if (!buf) {
reply_with_perror ("malloc");
continue;
}
if (xread (sock, buf, len) == -1)
exit (EXIT_FAILURE);
#ifdef ENABLE_PACKET_DUMP
if (verbose) {
size_t i, j;
for (i = 0; i < len; i += 16) {
printf ("%04zx: ", i);
for (j = i; j < MIN (i+16, len); ++j)
printf ("%02x ", (unsigned char) buf[j]);
for (; j < i+16; ++j)
printf (" ");
printf ("|");
for (j = i; j < MIN (i+16, len); ++j)
if (c_isprint (buf[j]))
printf ("%c", buf[j]);
else
printf (".");
for (; j < i+16; ++j)
printf (" ");
printf ("|\n");
}
}
#endif
gettimeofday (&start_t, NULL);
last_progress_t = start_t;
count_progress = 0;
/* Decode the message header. */
xdrmem_create (&xdr, buf, len, XDR_DECODE);
if (!xdr_guestfs_message_header (&xdr, &hdr)) {
fprintf (stderr, "guestfsd: could not decode message header\n");
exit (EXIT_FAILURE);
}
/* Check the version etc. */
if (hdr.prog != GUESTFS_PROGRAM) {
reply_with_error ("wrong program (%d)", hdr.prog);
goto cont;
}
if (hdr.vers != GUESTFS_PROTOCOL_VERSION) {
reply_with_error ("wrong protocol version (%d)", hdr.vers);
goto cont;
}
if (hdr.direction != GUESTFS_DIRECTION_CALL) {
reply_with_error ("unexpected message direction (%d)", hdr.direction);
goto cont;
}
if (hdr.status != GUESTFS_STATUS_OK) {
reply_with_error ("unexpected message status (%d)", hdr.status);
goto cont;
}
proc_nr = hdr.proc;
serial = hdr.serial;
progress_hint = hdr.progress_hint;
optargs_bitmask = hdr.optargs_bitmask;
/* Clear errors before we call the stub functions. This is just
* to ensure that we can accurately report errors in cases where
* error handling paths don't set errno correctly.
*/
errno = 0;
#ifdef WIN32
SetLastError (0);
WSASetLastError (0);
#endif
/* Now start to process this message. */
dispatch_incoming_message (&xdr);
/* Note that dispatch_incoming_message will also send a reply. */
/* In verbose mode, display the time taken to run each command. */
if (verbose) {
struct timeval end_t;
gettimeofday (&end_t, NULL);
int64_t start_us, end_us, elapsed_us;
start_us = (int64_t) start_t.tv_sec * 1000000 + start_t.tv_usec;
end_us = (int64_t) end_t.tv_sec * 1000000 + end_t.tv_usec;
elapsed_us = end_us - start_us;
fprintf (stderr,
"guestfsd: main_loop: proc %d (%s) took %d.%02d seconds\n",
proc_nr,
proc_nr >= 0 && proc_nr <= GUESTFS_MAX_PROC_NR
? function_names[proc_nr] : "UNKNOWN PROCEDURE",
(int) (elapsed_us / 1000000),
(int) ((elapsed_us / 10000) % 100));
}
cont:
xdr_destroy (&xdr);
free (buf);
}
}
/*
* XDR an array of arbitrary elements
* *addrp is a pointer to the array, *sizep is the number of elements.
* If addrp is NULL (*sizep * elsize) bytes are allocated.
* elsize is the size (in bytes) of each element, and elproc is the
* xdr procedure to call to handle each element of the array.
*/
bool_t
xdr_array(XDR *xdrs,
caddr_t *addrp, /* array pointer */
u_int *sizep, /* number of elements */
u_int maxsize, /* max numberof elements */
u_int elsize, /* size in bytes of each element */
xdrproc_t elproc) /* xdr routine to handle each element */
{
u_int i;
caddr_t target = *addrp;
u_int c; /* the actual element count */
bool_t stat = TRUE;
u_int nodesize;
/* like strings, arrays are really counted arrays */
if (!xdr_u_int(xdrs, sizep)) {
return (FALSE);
}
c = *sizep;
if ((c > maxsize || UINT_MAX/elsize < c) &&
(xdrs->x_op != XDR_FREE)) {
return (FALSE);
}
nodesize = c * elsize;
/*
* if we are deserializing, we may need to allocate an array.
* We also save time by checking for a null array if we are freeing.
*/
if (target == NULL)
switch (xdrs->x_op) {
case XDR_DECODE:
if (c == 0)
return (TRUE);
*addrp = target = mem_alloc(nodesize);
if (target == NULL) {
printf("xdr_array: out of memory");
return (FALSE);
}
memset(target, 0, nodesize);
break;
case XDR_FREE:
return (TRUE);
case XDR_ENCODE:
break;
}
/*
* now we xdr each element of array
*/
for (i = 0; (i < c) && stat; i++) {
stat = (*elproc)(xdrs, target);
target += elsize;
}
/*
* the array may need freeing
*/
if (xdrs->x_op == XDR_FREE) {
mem_free(*addrp, nodesize);
*addrp = NULL;
}
return (stat);
}
bool_t
xdr_u_long(XDR *xdrs, unsigned long *up)
{
return (xdr_u_int(xdrs, (uint_t *)up));
}
/*
* 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);
}
/*
* XDR an array of arbitrary elements
* *addrp is a pointer to the array, *sizep is the number of elements.
* If addrp is NULL (*sizep * elsize) bytes are allocated.
* elsize is the size (in bytes) of each element, and elproc is the
* xdr procedure to call to handle each element of the array.
*/
bool_t
xdr_array(XDR *xdrs,
caddr_t *addrp,
u_int *sizep, u_int maxsize, u_int elsize, xdrproc_t elproc)
{
u_int i;
caddr_t target = *addrp;
u_int c; /* the actual element count */
bool_t stat = TRUE;
u_int nodesize;
/* like strings, arrays are really counted arrays */
if (!xdr_u_int(xdrs, sizep))
return (FALSE);
c = *sizep;
if ((c > maxsize || UINT_MAX / elsize < c) && (xdrs->x_op != XDR_FREE))
return (FALSE);
nodesize = c * elsize;
/*
* if we are deserializing, we may need to allocate an array.
* We also save time by checking for a null array if we are freeing.
*/
if (target == NULL)
switch (xdrs->x_op) {
case XDR_DECODE:
if (c == 0)
return (TRUE);
*addrp = target = (caddr_t)XDR_ALLOC(xdrs, nodesize);
if (target == NULL) {
// warnx("xdr_array: out of memory");
return (FALSE);
}
memset(target, 0, nodesize);
break;
case XDR_FREE:
return (TRUE);
case XDR_ENCODE:
break;
}
/*
* now we xdr each element of array
*/
for (i = 0; (i < c) && stat; i++) {
stat = (*elproc) (xdrs, target);
target += elsize;
}
/*
* the array may need freeing
*/
if (xdrs->x_op == XDR_FREE) {
XDR_DEALLOC(xdrs, *addrp, nodesize);
*addrp = NULL;
}
return (stat);
}
int
main (int argc, char *argv[])
{
static const char *options = "rv?";
static const struct option long_options[] = {
{ "help", 0, 0, '?' },
{ "verbose", 0, 0, 'v' },
{ 0, 0, 0, 0 }
};
int c;
char *cmdline;
ignore_value (chdir ("/"));
if (winsock_init () == -1)
error (EXIT_FAILURE, 0, "winsock initialization failed");
#ifdef HAVE_REGISTER_PRINTF_SPECIFIER
/* http://udrepper.livejournal.com/20948.html */
register_printf_specifier ('Q', print_shell_quote, print_arginfo);
register_printf_specifier ('R', print_sysroot_shell_quote, print_arginfo);
#else
#ifdef HAVE_REGISTER_PRINTF_FUNCTION
register_printf_function ('Q', print_shell_quote, print_arginfo);
register_printf_function ('R', print_sysroot_shell_quote, print_arginfo);
#else
#error "HAVE_REGISTER_PRINTF_{SPECIFIER|FUNCTION} not defined"
#endif
#endif
/* XXX The appliance /init script sets LD_PRELOAD=../libSegFault.so.
* However if we CHROOT_IN to the sysroot that file might not exist,
* resulting in all commands failing. What we'd really like to do
* is to have LD_PRELOAD only set while outside the chroot. I
* suspect the proper way to solve this is to remove the
* CHROOT_IN/_OUT hack and replace it properly (fork), but that is
* for another day.
*/
unsetenv ("LD_PRELOAD");
struct stat statbuf;
if (stat ("/", &statbuf) == 0)
root_device = statbuf.st_dev;
for (;;) {
c = getopt_long (argc, argv, options, long_options, NULL);
if (c == -1) break;
switch (c) {
/* The -r flag is used when running standalone. It changes
* several aspects of the daemon.
*/
case 'r':
sysroot = "";
sysroot_len = 0;
autosync_umount = 0;
break;
case 'v':
verbose = 1;
break;
case '?':
usage ();
exit (EXIT_SUCCESS);
default:
fprintf (stderr, "guestfsd: unexpected command line option 0x%x\n", c);
exit (EXIT_FAILURE);
}
}
if (optind < argc) {
usage ();
exit (EXIT_FAILURE);
}
cmdline = read_cmdline ();
/* Set the verbose flag. */
verbose = verbose ||
(cmdline && strstr (cmdline, "guestfs_verbose=1") != NULL);
if (verbose)
printf ("verbose daemon enabled\n");
if (verbose) {
if (cmdline)
printf ("linux commmand line: %s\n", cmdline);
else
printf ("could not read linux command line\n");
}
enable_network = cmdline && strstr (cmdline, "guestfs_network=1") != NULL;
#ifndef WIN32
/* Make sure SIGPIPE doesn't kill us. */
struct sigaction sa;
memset (&sa, 0, sizeof sa);
sa.sa_handler = SIG_IGN;
sa.sa_flags = 0;
if (sigaction (SIGPIPE, &sa, NULL) == -1)
perror ("sigaction SIGPIPE"); /* but try to continue anyway ... */
#endif
#ifdef WIN32
# define setenv(n,v,f) _putenv(n "=" v)
#endif
/* Set up a basic environment. After we are called by /init the
* environment is essentially empty.
* https://bugzilla.redhat.com/show_bug.cgi?id=502074#c5
*
* NOTE: if you change $PATH, you must also change 'prog_exists'
* function below.
*/
setenv ("PATH", "/sbin:/usr/sbin:/bin:/usr/bin", 1);
setenv ("SHELL", "/bin/sh", 1);
setenv ("LC_ALL", "C", 1);
setenv ("TERM", "dumb", 1);
#ifndef WIN32
/* We document that umask defaults to 022 (it should be this anyway). */
umask (022);
#else
/* This is the default for Windows anyway. It's not even clear if
* Windows ever uses this -- the MSDN documentation for the function
* contains obvious errors.
*/
_umask (0);
#endif
/* Make a private copy of /etc/lvm so we can change the config (see
* daemon/lvm-filter.c).
*/
copy_lvm ();
/* Connect to virtio-serial channel. */
char *channel, *p;
if (cmdline && (p = strstr (cmdline, "guestfs_channel=")) != NULL) {
p += 16;
channel = strndup (p, strcspn (p, " \n"));
}
else
channel = strdup (VIRTIO_SERIAL_CHANNEL);
if (!channel) {
perror ("strdup");
exit (EXIT_FAILURE);
}
if (verbose)
printf ("trying to open virtio-serial channel '%s'\n", channel);
int sock = open (channel, O_RDWR|O_CLOEXEC);
if (sock == -1) {
fprintf (stderr,
"\n"
"Failed to connect to virtio-serial channel.\n"
"\n"
"This is a fatal error and the appliance will now exit.\n"
"\n"
"Usually this error is caused by either QEMU or the appliance\n"
"kernel not supporting the vmchannel method that the\n"
"libguestfs library chose to use. Please run\n"
"'libguestfs-test-tool' and provide the complete, unedited\n"
"output to the libguestfs developers, either in a bug report\n"
"or on the libguestfs redhat com mailing list.\n"
"\n");
perror (channel);
exit (EXIT_FAILURE);
}
/* If it's a serial-port like device then it probably has echoing
* enabled. Put it into complete raw mode.
*/
if (STRPREFIX (channel, "/dev/ttyS"))
makeraw (channel, sock);
/* cmdline, channel not used after this point */
free (cmdline);
free (channel);
/* Wait for udev devices to be created. If you start libguestfs,
* especially with disks that contain complex (eg. mdadm) data
* already, then it is possible for the 'mdadm' and LVM commands
* that the init script runs to have not completed by the time the
* daemon starts executing library commands. (This is very rare and
* hard to test however, but we have seen it in 'brew'). Run
* udev_settle, but do it as late as possible to minimize the chance
* that we'll have to do any waiting here.
*/
udev_settle ();
/* Send the magic length message which indicates that
* userspace is up inside the guest.
*/
char lenbuf[4];
XDR xdr;
uint32_t len = GUESTFS_LAUNCH_FLAG;
xdrmem_create (&xdr, lenbuf, sizeof lenbuf, XDR_ENCODE);
xdr_u_int (&xdr, &len);
if (xwrite (sock, lenbuf, sizeof lenbuf) == -1) {
perror ("xwrite");
exit (EXIT_FAILURE);
}
xdr_destroy (&xdr);
/* Enter the main loop, reading and performing actions. */
main_loop (sock);
exit (EXIT_SUCCESS);
}
bool_t xdr_writeargs(XDR *xdrs, writeargs *objp)
{
register int32_t *buf = buf;
if(xdrs->x_op == XDR_ENCODE)
{
if(!xdr_nfs_fh(xdrs, &objp->file))
{
return (FALSE);
}
buf = XDR_INLINE(xdrs, 3 * BYTES_PER_XDR_UNIT);
if(buf == NULL)
{
if(!xdr_u_int(xdrs, &objp->beginoffset))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->offset))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->totalcount))
{
return (FALSE);
}
}
else
{
IXDR_PUT_U_LONG(buf, objp->beginoffset);
IXDR_PUT_U_LONG(buf, objp->offset);
IXDR_PUT_U_LONG(buf, objp->totalcount);
}
if(!xdr_bytes(xdrs, (char **)&objp->data.data_val, (u_int *)&objp->data.data_len, NFS_MAXDATA))
{
return (FALSE);
}
return (TRUE);
}
else if(xdrs->x_op == XDR_DECODE)
{
if(!xdr_nfs_fh(xdrs, &objp->file))
{
return (FALSE);
}
buf = XDR_INLINE(xdrs, 3 * BYTES_PER_XDR_UNIT);
if(buf == NULL)
{
if(!xdr_u_int(xdrs, &objp->beginoffset))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->offset))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->totalcount))
{
return (FALSE);
}
}
else
{
objp->beginoffset = IXDR_GET_U_LONG(buf);
objp->offset = IXDR_GET_U_LONG(buf);
objp->totalcount = IXDR_GET_U_LONG(buf);
}
if(!xdr_bytes(xdrs, (char **)&objp->data.data_val, (u_int *)&objp->data.data_len, NFS_MAXDATA))
{
return (FALSE);
}
return (TRUE);
}
if(!xdr_nfs_fh(xdrs, &objp->file))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->beginoffset))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->offset))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->totalcount))
{
return (FALSE);
}
if(!xdr_bytes(xdrs, (char **)&objp->data.data_val, (u_int *)&objp->data.data_len, NFS_MAXDATA))
{
return (FALSE);
}
return (TRUE);
}
int
ocgetcontent(OCstate* state, OCcontent* content, void* memory, size_t memsize,
size_t start, size_t count)
{
int stat = OC_NOERR;
XDR* xdrs;
OCtype etype;
int isscalar;
size_t elemsize, totalsize;
int packed;
unsigned int xdrcount;
if(state == NULL || content == NULL || memory == NULL)
{OCTHROWCHK(stat=OC_EINVAL); goto done;}
if(content->node->octype != OC_Primitive)
{OCTHROWCHK(stat=OC_EINVAL); goto done;}
if(content->maxindex > 0 && content->maxindex < start+count)
return OCTHROW(OC_ENODATA);
etype = content->node->etype;
isscalar = (content->node->array.rank == 0);
if(isscalar && (start != 0 || count != 1))
{OCTHROWCHK(stat=OC_EINVALCOORDS); goto done;}
/* validate memory space*/
elemsize = octypesize(etype);
totalsize = elemsize*count;
if(memsize < totalsize) return OCTHROW(OC_EINVAL);
OCASSERT((occontentmode(state,content)==Dimmode || isscalar));
if(content->memdata != NULL) { /* Get data from the compiled version */
stat = ocgetmemdata(state,content,memory,memsize,start,count);
goto done;
}
/* No memdata => use xdr */
xdrs = content->tree->data.xdrs;
if(xdrs == NULL) return OCTHROW(OC_EXDR);
/* check if the data is packed*/
packed = (!isscalar && (etype == OC_Byte || etype == OC_UByte || etype == OC_Char));
content->packed = packed;
/* Make sure we are at the proper offset: ie at count if !scalar */
if(!xdr_setpos(xdrs,content->xdrpos.offset)) goto shortxdr;
if(!isscalar) {
/* Collect the dimension count from the xdr data packet*/
if(!xdr_u_int(xdrs,&xdrcount)) goto shortxdr;
if(xdrcount < start) return OCTHROW(OC_EINVALCOORDS);
if(xdrcount < start+count) return OCTHROW(OC_EINVALCOORDS);
/* pull out redundant second count*/
/* (note that String/URL do not have redundant count)*/
if(etype != OC_String && etype != OC_URL) {
if(!xdr_u_int(xdrs,&xdrcount)) goto shortxdr;
}
}
/* Extract the data */
#ifdef OCPROGRESS
oc_log(LOGNOTE,"reading xdr: %lu bytes",(unsigned long)memsize);
#endif
stat = ocxdrread(xdrs,(char*)memory,memsize,packed,content->node->etype,start,count);
if(!xdr_setpos(xdrs,content->xdrpos.offset)) return xdrerror(); /* restore location*/
done:
return OCTHROW(stat);
shortxdr:
oc_log(LOGERR,"DAP DATADDS appears to be too short");
return OC_EDATADDS;
}
bool_t xdr_fattr(XDR *xdrs, fattr *objp)
{
register int32_t *buf = buf;
if(xdrs->x_op == XDR_ENCODE)
{
if(!xdr_ftype(xdrs, &objp->type))
{
return (FALSE);
}
buf = XDR_INLINE(xdrs, 10 * BYTES_PER_XDR_UNIT);
if(buf == NULL)
{
if(!xdr_u_int(xdrs, &objp->mode))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->nlink))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->uid))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->gid))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->size))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->blocksize))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->rdev))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->blocks))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->fsid))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->fileid))
{
return (FALSE);
}
}
else
{
IXDR_PUT_U_LONG(buf, objp->mode);
IXDR_PUT_U_LONG(buf, objp->nlink);
IXDR_PUT_U_LONG(buf, objp->uid);
IXDR_PUT_U_LONG(buf, objp->gid);
IXDR_PUT_U_LONG(buf, objp->size);
IXDR_PUT_U_LONG(buf, objp->blocksize);
IXDR_PUT_U_LONG(buf, objp->rdev);
IXDR_PUT_U_LONG(buf, objp->blocks);
IXDR_PUT_U_LONG(buf, objp->fsid);
IXDR_PUT_U_LONG(buf, objp->fileid);
}
if(!xdr_nfstime(xdrs, &objp->atime))
{
return (FALSE);
}
if(!xdr_nfstime(xdrs, &objp->mtime))
{
return (FALSE);
}
if(!xdr_nfstime(xdrs, &objp->ctime))
{
return (FALSE);
}
return (TRUE);
}
else if(xdrs->x_op == XDR_DECODE)
{
if(!xdr_ftype(xdrs, &objp->type))
{
return (FALSE);
}
buf = XDR_INLINE(xdrs, 10 * BYTES_PER_XDR_UNIT);
if(buf == NULL)
{
if(!xdr_u_int(xdrs, &objp->mode))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->nlink))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->uid))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->gid))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->size))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->blocksize))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->rdev))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->blocks))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->fsid))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->fileid))
{
return (FALSE);
}
}
else
{
objp->mode = IXDR_GET_U_LONG(buf);
objp->nlink = IXDR_GET_U_LONG(buf);
objp->uid = IXDR_GET_U_LONG(buf);
objp->gid = IXDR_GET_U_LONG(buf);
objp->size = IXDR_GET_U_LONG(buf);
objp->blocksize = IXDR_GET_U_LONG(buf);
objp->rdev = IXDR_GET_U_LONG(buf);
objp->blocks = IXDR_GET_U_LONG(buf);
objp->fsid = IXDR_GET_U_LONG(buf);
objp->fileid = IXDR_GET_U_LONG(buf);
}
if(!xdr_nfstime(xdrs, &objp->atime))
{
return (FALSE);
}
if(!xdr_nfstime(xdrs, &objp->mtime))
{
return (FALSE);
}
if(!xdr_nfstime(xdrs, &objp->ctime))
{
return (FALSE);
}
return (TRUE);
}
if(!xdr_ftype(xdrs, &objp->type))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->mode))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->nlink))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->uid))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->gid))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->size))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->blocksize))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->rdev))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->blocks))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->fsid))
{
return (FALSE);
}
if(!xdr_u_int(xdrs, &objp->fileid))
{
return (FALSE);
}
if(!xdr_nfstime(xdrs, &objp->atime))
{
return (FALSE);
}
if(!xdr_nfstime(xdrs, &objp->mtime))
{
return (FALSE);
}
if(!xdr_nfstime(xdrs, &objp->ctime))
{
return (FALSE);
}
return (TRUE);
}
/* Remember: we are operating wrt the datadds count, not the dds count */
int
ocarraycontent(OCstate* state, OCcontent* content, OCcontent* newcontent, size_t index)
{
unsigned int i;
int stat = OC_NOERR;
XDR* xdrs;
unsigned int xdrcount;
int packed;
OCtype etype,octype;
if(state == NULL || content == NULL) return OCTHROW(OC_EINVAL);
if(content->mode != Dimmode) return OCTHROW(OC_EINVAL);
if(content->node->array.rank == 0) return OCTHROW(OC_EINVAL);
etype = content->node->etype;
octype = content->node->octype;
if(content->maxindex > 0 && content->maxindex <= index)
return OCTHROW(OC_EINVALCOORDS);
content->index = index; /* Track our location in parent content */
/* check if the data is packed*/
packed = (octype == OC_Primitive &&
(etype == OC_Byte || etype == OC_UByte || etype == OC_Char));
ocresetcontent(state,newcontent);
/* Set the some of the new content*/
newcontent->state = state; /* make sure*/
newcontent->tree = content->tree;
newcontent->node = content->node; /* keep same node*/
newcontent->packed = packed;
newcontent->mode = modetransition(newcontent->node, content->mode);
newcontent->index = 0;
newcontent->maxindex = maxindexfor(newcontent->node, content->mode);
if(content->memdata != NULL) { /* Get data from the compiled version */
OCASSERT((content->memdata->mode == Dimmode));
/* Leave the primitive alone to be picked up by oc_getcontent */
if(octype != OC_Primitive) {
OCmemdata* next;
OCASSERT((octype == OC_Structure));
if(content->memdata->count <= index) return OCTHROW(OC_ENODATA);
next = ((OCmemdata**)content->memdata->data.data)[index];
newcontent->memdata = next;
} else
newcontent->memdata = content->memdata; /* use same memdata */
goto done;
}
xdrs = content->tree->data.xdrs;
if(xdrs == NULL) return OCTHROW(OC_EXDR);
/* checkpoint the beginning of this instance*/
if(!content->xdrpos.valid) {
content->xdrpos.offset = xdr_getpos(xdrs);
content->xdrpos.valid = 1;
}
/* move to checkpoint position*/
if(!xdr_setpos(xdrs,content->xdrpos.offset)) return xdrerror();
/* Collect the dimension count from the xdr data packet*/
if(!xdr_u_int(xdrs,&xdrcount)) return xdrerror();
if(xdrcount < index) return OCTHROW(OC_ENODATA);
/* pull out redundant second count*/
/* (note that String/URL do not redundant count)*/
if(octype == OC_Primitive && etype != OC_String && etype != OC_URL) {
if(!xdr_u_int(xdrs,&xdrcount)) return xdrerror();
}
/* We have to treat OC_Byte/UByte/Char specially*/
/* because the data is packed in the xdr packet*/
if(packed) {
/* In effect, compile where the data is, but wait*/
/* until a getcontent to retrieve it*/
OCASSERT((newcontent->mode == Datamode));
newcontent->index = index; /* record final destination in the packed data*/
newcontent->packed = 1;
return OCTHROW(OC_NOERR);
}
for(i=0;i<index;i++) {
stat = ocskipinstance(content->node,xdrs);
if(stat != OC_NOERR) return OCTHROW(stat);
}
/* Record the location of the newcontent */
newcontent->xdrpos.offset = xdr_getpos(xdrs);
newcontent->xdrpos.valid = 1;
/* move back to checkpoint position*/
if(!xdr_setpos(xdrs,content->xdrpos.offset)) return xdrerror();
done:
return OCTHROW(stat);
}
/* Skip arbitrary dimensioned instance; handles dimensioning.*/
int
ocskip(OCnode* node, XDR* xdrs)
{
unsigned int i,j,rank;
int stat = OC_NOERR;
unsigned int xdrcount;
unsigned int len;
switch (node->octype) {
case OC_Primitive:
/* handle non-uniform types separately*/
if(node->etype == OC_String || node->etype == OC_URL) {
rank = node->array.rank;
xdrcount = 1;
if(rank > 0 && !xdr_u_int(xdrs,&xdrcount)) return xdrerror();
len = xdrcount;
for(i=0;i<xdrcount;i++) {
if(!xdr_u_int(xdrs,&len)) return xdrerror();
if(!xdr_skip(xdrs,len)) return xdrerror();
}
} else { /* uniform => do a direct skip*/
OCASSERT((node->dap.arraysize > 0
&& node->dap.instancesize > 0));
if(node->array.rank > 0) {
if(!xdr_skip(xdrs,node->dap.arraysize)) return xdrerror();
} else {
if(!xdr_skip(xdrs,node->dap.instancesize)) return xdrerror();
}
}
break;
case OC_Grid:
OCASSERT((node->array.rank == 0));
if(node->dap.instancesize > 0) { /* do a direct skip*/
if(!xdr_skip(xdrs,node->dap.arraysize)) return xdrerror();
break;
} else { /* Non-uniform size*/
/* Walk array and maps*/
for(j=0;j<oclistlength(node->subnodes);j++) {
OCnode* field = (OCnode*)oclistget(node->subnodes,j);
stat = ocskip(field,xdrs);
if(stat != OC_NOERR) {THROWCHK(stat); break;}
}
if(stat != OC_NOERR) {THROWCHK(stat); break;}
}
break;
case OC_Dataset:
OCASSERT((node->array.rank == 0));
/* fall-thru*/
case OC_Structure:
if(node->dap.instancesize > 0) { /* do a direct skip*/
if(!xdr_skip(xdrs,node->dap.arraysize)) return xdrerror();
} else {
/* Non-uniform size, we have to skip element by element*/
rank = node->array.rank;
xdrcount = 1;
if(rank > 0 && !xdr_u_int(xdrs,&xdrcount)) return xdrerror();
for(i=0;i<xdrcount;i++) { /* skip element by element*/
/* Walk each structure field*/
for(j=0;j<oclistlength(node->subnodes);j++) {
OCnode* field = (OCnode*)oclistget(node->subnodes,j);
stat = ocskip(field,xdrs);
if(stat != OC_NOERR) {THROWCHK(stat); break;}
}
if(stat != OC_NOERR) {THROWCHK(stat); break;}
}
}
break;
case OC_Sequence: /* not uniform, so walk record by record*/
OCASSERT((node->array.rank == 0));
for(;;) {
/* pick up the sequence record begin marker*/
char tmp[sizeof(unsigned int)];
/* extract the tag byte*/
if(!xdr_opaque(xdrs,tmp,sizeof(tmp))) return xdrerror();
if(tmp[0] == StartOfoclist) {
/* Walk each member field*/
for(j=0;j<oclistlength(node->subnodes);j++) {
OCnode* member = (OCnode*)oclistget(node->subnodes,j);
stat = ocskip(member,xdrs);
if(stat != OC_NOERR) {THROWCHK(stat); break;}
}
} 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;
{THROWCHK(stat); break;}
}
if(stat != OC_NOERR) {THROWCHK(stat); break;}
}
break;
default:
OCPANIC1("oc_move: encountered unexpected node type: %x",node->octype);
break;
}
return THROW(stat);
}
bool_t
Xdr_rpc_gss_wrap_data(XDR *xdrs, xdrproc_t xdr_func, caddr_t xdr_ptr,
gss_ctx_id_t ctx, gss_qop_t qop,
rpc_gss_svc_t svc, u_int seq)
{
gss_buffer_desc databuf, wrapbuf;
OM_uint32 maj_stat, min_stat;
int start, end, conf_state;
bool_t xdr_stat = FALSE;
u_int databuflen, maxwrapsz;
/* Skip databody length. */
start = XDR_GETPOS(xdrs);
XDR_SETPOS(xdrs, start + 4);
memset(&databuf, 0, sizeof(databuf));
memset(&wrapbuf, 0, sizeof(wrapbuf));
/* Marshal rpc_gss_data_t (sequence number + arguments). */
if (!xdr_u_int(xdrs, &seq) || !(*xdr_func)(xdrs, xdr_ptr))
return (FALSE);
end = XDR_GETPOS(xdrs);
/* Set databuf to marshalled rpc_gss_data_t. */
databuflen = end - start - 4;
XDR_SETPOS(xdrs, start + 4);
databuf.value = XDR_INLINE(xdrs, databuflen);
databuf.length = databuflen;
xdr_stat = FALSE;
if (svc == RPCSEC_GSS_SVC_INTEGRITY) {
/* Marshal databody_integ length. */
XDR_SETPOS(xdrs, start);
if (!xdr_u_int(xdrs, (u_int *)&databuflen))
return (FALSE);
/* Checksum rpc_gss_data_t. */
maj_stat = gss_get_mic(&min_stat, ctx, qop,
&databuf, &wrapbuf);
if (maj_stat != GSS_S_COMPLETE) {
LogFullDebug(COMPONENT_RPCSEC_GSS,"gss_get_mic failed");
return (FALSE);
}
/* Marshal checksum. */
XDR_SETPOS(xdrs, end);
maxwrapsz = (u_int)(wrapbuf.length + RPC_SLACK_SPACE);
xdr_stat = Xdr_rpc_gss_buf(xdrs, &wrapbuf, maxwrapsz);
gss_release_buffer(&min_stat, &wrapbuf);
}
else if (svc == RPCSEC_GSS_SVC_PRIVACY) {
/* Encrypt rpc_gss_data_t. */
maj_stat = gss_wrap(&min_stat, ctx, TRUE, qop, &databuf,
&conf_state, &wrapbuf);
if (maj_stat != GSS_S_COMPLETE) {
LogFullDebug(COMPONENT_RPCSEC_GSS,"gss_wrap %d %d", maj_stat, min_stat);
return (FALSE);
}
/* Marshal databody_priv. */
XDR_SETPOS(xdrs, start);
maxwrapsz = (u_int)(wrapbuf.length + RPC_SLACK_SPACE);
xdr_stat = Xdr_rpc_gss_buf(xdrs, &wrapbuf, maxwrapsz);
gss_release_buffer(&min_stat, &wrapbuf);
}
return (xdr_stat);
}
