自学教程：C++ xdr_destroy函数代码示例

int send_trans_tok(BIO *bio, struct trans_tok *t){	char *buf = calloc(BUFSIZ, sizeof(char));	XDR xdr;	xdrmem_create(&xdr, buf, BUFSIZ, XDR_ENCODE);	if(!xdr_trans_tok(&xdr, t)) {		perror("could not encode trans tok/n");		return -1;	}	int result = send_char_buf(bio, buf, BUFSIZ);	xdr_destroy(&xdr);	free(buf);	return result;}

int virNetMessageEncodePayloadEmpty(virNetMessagePtr msg){    XDR xdr;    unsigned int msglen;    /* Re-encode the length word. */    VIR_DEBUG("Encode length as %zu", msg->bufferOffset);    xdrmem_create(&xdr, msg->buffer, VIR_NET_MESSAGE_HEADER_XDR_LEN, XDR_ENCODE);    msglen = msg->bufferOffset;    if (!xdr_u_int(&xdr, &msglen)) {        virReportError(VIR_ERR_RPC, "%s", _("Unable to encode message length"));        goto error;    }    xdr_destroy(&xdr);    msg->bufferLength = msg->bufferOffset;    msg->bufferOffset = 0;    return 0;error:    xdr_destroy(&xdr);    return -1;}

voidnfs2_reply(struct xid_map *xm, struct tuple4 *addr, u_char *buf, int len){	XDR xdrs;	struct diropres dres;	struct readres rres;		switch (xm->proc) {			case NFSPROC_LOOKUP:		xdrmem_create(&xdrs, buf, len, XDR_DECODE);		memset(&dres, 0, sizeof(dres));				if (xdr_diropres(&xdrs, &dres)) {			if (dres.status == NFS_OK)				fh_map_add((char *)xm->data,					   dres.diropres_u.diropres.file.data,					   NFS_FHSIZE);		}		xdr_destroy(&xdrs);		break;			case NFSPROC_READ:		xdrmem_create(&xdrs, buf, len, XDR_DECODE);		memset(&rres, 0, sizeof(rres));				if (xdr_readres(&xdrs, &rres)) {			if (rres.status == NFS_OK) {				nfs_save(addr, (struct myreadargs *)xm->data,					 rres.readres_u.reply.data.data_val,					 rres.readres_u.reply.data.data_len);			}		}		xdr_destroy(&xdrs);		break;	}}

static intrclose(int sock, struct LSFHeader *hdr){    static char fname[] = "rclose()";    int reqfd;    char buf[LSRCP_MSGSIZE];    XDR xdrs;    xdrmem_create(&xdrs, buf, LSRCP_MSGSIZE, XDR_DECODE);    if (readDecodeMsg_(sock, buf, hdr, SOCK_READ_FIX, &xdrs, (char *) &reqfd,                       xdr_int, NULL)) {        ls_errlog(stderr, I18N_FUNC_FAIL_MM, fname, "readDecodeMsg_");        xdr_destroy(&xdrs);        closesocket(sock);        return -1;    }    xdr_destroy(&xdrs);    if (close(reqfd) == -1) {        if (lsSendMsg_(sock, -errnoEncode_(errno), 0, NULL, buf,                       sizeof(struct LSFHeader), NULL, SOCK_WRITE_FIX, NULL)            < 0) {            ls_errlog(stderr, I18N_FUNC_FAIL_MM, fname, "lsSendMsg_");            close(sock);        }        return 0;    }    if (lsSendMsg_(sock, 0, 0, NULL, buf,                   sizeof(struct LSFHeader), NULL, SOCK_WRITE_FIX, NULL) < 0) {        ls_errlog(stderr, I18N_FUNC_FAIL_MM, fname, "lsSendMsg_");        close(sock);        return -1;    }    return 0;}

voidsped_populate_npools(spe_npool *p){    struct nfsspe_args	args;    XDR			xdrs;    char			*buf;    size_t			len = 0;    args.nsa_opcode = SPE_OP_NPOOL_POPULATE;    args.nsa_did = 0xdead4ead;    if (!p)        return;    args.nsa_xdr_len =        xdr_sizeof((xdrproc_t)xdr_spe_npool, (void *)p);    args.nsa_xdr = calloc(args.nsa_xdr_len, sizeof (char));    if (!args.nsa_xdr)        return;    xdrmem_create(&xdrs, args.nsa_xdr, args.nsa_xdr_len, XDR_ENCODE);    if (!xdr_spe_npool(&xdrs, p)) {        free(args.nsa_xdr);        xdr_destroy(&xdrs);        return;    }#if 0    sped_xdr_dump(args.nsa_xdr, args.nsa_xdr_len);#endif    (void) _nfssys(NFS_SPE, &args);    free(args.nsa_xdr);    xdr_destroy(&xdrs);}

static notify_list *recv_rply(u_long *portp){	char			msgbuf[NSM_MAXMSGSIZE];	ssize_t			msglen;	notify_list		*lp = NULL;	XDR			xdr;	struct sockaddr_in	sin;	socklen_t		alen = (socklen_t)sizeof(sin);	uint32_t		xid;	memset(msgbuf, 0, sizeof(msgbuf));	msglen = recvfrom(sockfd, msgbuf, sizeof(msgbuf), 0,				(struct sockaddr *)(char *)&sin, &alen);	if (msglen == (ssize_t)-1) {		xlog_warn("%s: recvfrom failed: %m", __func__);		return NULL;	}	memset(&xdr, 0, sizeof(xdr));	xdrmem_create(&xdr, msgbuf, (unsigned int)msglen, XDR_DECODE);	xid = nsm_parse_reply(&xdr);	if (xid == 0)		goto done;	if (sin.sin_addr.s_addr != htonl(INADDR_LOOPBACK)) {		struct in_addr addr = sin.sin_addr;		char buf[INET_ADDRSTRLEN];		xlog_warn("%s: Unrecognized reply from %s", __func__,				inet_ntop(AF_INET, &addr, buf,						(socklen_t)sizeof(buf)));		goto done;	}	for (lp = notify; lp != NULL; lp = lp->next) {		/* LH - this was a bug... it should have been checking		 * the xid from the response message from the client,		 * not the static, internal xid */		if (lp->xid != xid)			continue;		if (lp->port == 0)			*portp = nsm_recv_getport(&xdr);		break;	}done:	xdr_destroy(&xdr);	return lp;}

/* * @msg: the outgoing message, whose header to encode * * Encodes the length word and header of the message, setting the * message offset ready to encode the payload. Leaves space * for the length field later. Upon return bufferLength will * refer to the total available space for message, while * bufferOffset will refer to current space used by header * * returns 0 if successfully encoded, -1 upon fatal error */gboolean gvir_sandbox_rpcpacket_encode_header(GVirSandboxRPCPacket *msg,                                              GError **error){    XDR xdr;    gboolean ret = FALSE;    unsigned int len = 0;    msg->bufferLength = sizeof(msg->buffer);    msg->bufferOffset = 0;    /* Format the header. */    xdrmem_create(&xdr,                  msg->buffer,                  msg->bufferLength,                  XDR_ENCODE);    /* The real value is filled in shortly */    if (!xdr_u_int(&xdr, &len)) {        g_set_error(error, 0, 0,                    "%s", "Unable to encode message length");        goto cleanup;    }    if (!xdr_GVirSandboxProtocolHeader(&xdr, &msg->header)) {        g_set_error(error, 0, 0,                    "%s", "Unable to encode message header");        goto cleanup;    }    len = xdr_getpos(&xdr);    xdr_setpos(&xdr, 0);    /* Fill in current length - may be re-written later     * if a payload is added     */    if (!xdr_u_int(&xdr, &len)) {        g_set_error(error, 0, 0,                    "%s", "Unable to re-encode message length");        goto cleanup;    }    msg->bufferOffset += len;    ret = TRUE;cleanup:    xdr_destroy(&xdr);    return ret;}

/* * @msg: the outgoing message, whose header to encode * * Encodes the length word and header of the message, setting the * message offset ready to encode the payload. Leaves space * for the length field later. Upon return bufferLength will * refer to the total available space for message, while * bufferOffset will refer to current space used by header * * returns 0 if successfully encoded, -1 upon fatal error */int virNetMessageEncodeHeader(virNetMessagePtr msg){    XDR xdr;    int ret = -1;    unsigned int len = 0;    msg->bufferLength = VIR_NET_MESSAGE_MAX + VIR_NET_MESSAGE_LEN_MAX;    if (VIR_REALLOC_N(msg->buffer, msg->bufferLength) < 0) {        virReportOOMError();        return ret;    }    msg->bufferOffset = 0;    /* Format the header. */    xdrmem_create(&xdr,                  msg->buffer,                  msg->bufferLength,                  XDR_ENCODE);    /* The real value is filled in shortly */    if (!xdr_u_int(&xdr, &len)) {        virReportError(VIR_ERR_RPC, "%s", _("Unable to encode message length"));        goto cleanup;    }    if (!xdr_virNetMessageHeader(&xdr, &msg->header)) {        virReportError(VIR_ERR_RPC, "%s", _("Unable to encode message header"));        goto cleanup;    }    len = xdr_getpos(&xdr);    xdr_setpos(&xdr, 0);    /* Fill in current length - may be re-written later     * if a payload is added     */    if (!xdr_u_int(&xdr, &len)) {        virReportError(VIR_ERR_RPC, "%s", _("Unable to re-encode message length"));        goto cleanup;    }    msg->bufferOffset += len;    ret = 0;cleanup:    xdr_destroy(&xdr);    return ret;}

void writeInput(void){  const char routineName[] = "writeInput";  bool_t  result=TRUE, PRD_angle_dep, XRD, big_endian;  FILE   *fp_out;  XDR     xdrs;  if (!strcmp(INPUT_DOT_OUT, "none")) return;  if ((fp_out = fopen(INPUT_DOT_OUT, "w")) == NULL) {    sprintf(messageStr, "Unable to open output file %s",	    INPUT_DOT_OUT);    Error(ERROR_LEVEL_1, routineName, messageStr);    return;  }  xdrstdio_create(&xdrs, fp_out, XDR_ENCODE);  PRD_angle_dep = (input.PRD_angle_dep != PRD_ANGLE_INDEP  &&  atmos.NPRDactive > 0);  XRD           = (input.XRD  &&  atmos.NPRDactive > 0);  /* --- Write various input parameters to file --     -------------- */        result &= xdr_bool(&xdrs, &input.magneto_optical);  result &= xdr_bool(&xdrs, &PRD_angle_dep);  result &= xdr_bool(&xdrs, &XRD);  result &= xdr_enum(&xdrs, (enum_t *) &input.startJ);  result &= xdr_enum(&xdrs, (enum_t *) &input.StokesMode);  result &= xdr_double(&xdrs, &input.metallicity);  result &= xdr_bool(&xdrs, &input.backgr_pol);  /* --- Write Endianness of compute architecture so that J can be         read properly in the analysis --              -------------- */  big_endian = is_big_endian();  result &= xdr_bool(&xdrs, &big_endian);  if (!result) {    sprintf(messageStr, "Unable to write proper amount to output file %s",	    INPUT_DOT_OUT);    Error(ERROR_LEVEL_1, routineName, messageStr);  }  xdr_destroy(&xdrs);  fclose(fp_out);}

gboolean gvir_sandbox_rpcpacket_encode_payload_empty(GVirSandboxRPCPacket *msg,                                                     GError **error){    XDR xdr;    unsigned int msglen;    /* Re-encode the length word. */    xdrmem_create(&xdr, msg->buffer, GVIR_SANDBOX_PROTOCOL_LEN_MAX, XDR_ENCODE);    msglen = msg->bufferOffset;    if (!xdr_u_int(&xdr, &msglen)) {        g_set_error(error, 0, 0,                    "%s", "Unable to encode message length");        goto error;    }    xdr_destroy(&xdr);    msg->bufferLength = msg->bufferOffset;    msg->bufferOffset = 0;    return TRUE;error:    xdr_destroy(&xdr);    return FALSE;}

gboolean gvir_sandbox_rpcpacket_encode_payload_raw(GVirSandboxRPCPacket *msg,                                                   const char *data,                                                   gsize len,                                                   GError **error){    XDR xdr;    unsigned int msglen;    if ((msg->bufferLength - msg->bufferOffset) < len) {        g_set_error(error, 0, 0,                    "Raw data too long to send (%zu bytes needed, %zu bytes available)",                    len, (msg->bufferLength - msg->bufferOffset));        return FALSE;    }    memcpy(msg->buffer + msg->bufferOffset, data, len);    msg->bufferOffset += len;    /* Re-encode the length word. */    xdrmem_create(&xdr, msg->buffer, GVIR_SANDBOX_PROTOCOL_LEN_MAX, XDR_ENCODE);    msglen = msg->bufferOffset;    if (!xdr_u_int(&xdr, &msglen)) {        g_set_error(error, 0, 0,                    "%s", "Unable to encode message length");        goto error;    }    xdr_destroy(&xdr);    msg->bufferLength = msg->bufferOffset;    msg->bufferOffset = 0;    return TRUE;error:    xdr_destroy(&xdr);    return FALSE;}

static intsend_chunk (const guestfs_chunk *chunk){  const size_t buf_len = GUESTFS_MAX_CHUNK_SIZE + 48;  CLEANUP_FREE char *buf = NULL;  char lenbuf[4];  XDR xdr;  uint32_t len;  buf = malloc (buf_len);  if (buf == NULL) {    perror ("malloc");    return -1;  }  xdrmem_create (&xdr, buf, buf_len, XDR_ENCODE);  if (!xdr_guestfs_chunk (&xdr, (guestfs_chunk *) chunk)) {    fprintf (stderr, "guestfsd: send_chunk: failed to encode chunk/n");    xdr_destroy (&xdr);    return -1;  }  len = xdr_getpos (&xdr);  xdr_destroy (&xdr);  xdrmem_create (&xdr, lenbuf, 4, XDR_ENCODE);  xdr_u_int (&xdr, &len);  xdr_destroy (&xdr);  const int err = (xwrite (sock, lenbuf, 4) == 0                   && xwrite (sock, buf, len) == 0 ? 0 : -1);  if (err)    error (EXIT_FAILURE, 0, "send_chunk: write failed");  return err;}

voiddo_sbdDebug(XDR * xdrs, int chfd, struct LSFHeader * reqHdr){    static char       fname[] = "do_sbdDebug()";    struct debugReq    debugReq;    char               reply_buf[MSGSIZE / 8];    XDR                xdrs2;    sbdReplyType       reply;    struct LSFHeader   replyHdr;    if (!xdr_debugReq(xdrs, &debugReq, reqHdr)) {        reply = LSBE_XDR;        ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_debugReq");    }    else        reply = ctrlSbdDebug(&debugReq);    xdrmem_create(&xdrs2, reply_buf, MSGSIZE / 8, XDR_ENCODE);    initLSFHeader_(&replyHdr);    replyHdr.opCode = reply;    if (!xdr_encodeMsg(&xdrs2, (char *) 0, &replyHdr, 0, 0, NULL)) {        ls_syslog(LOG_ERR, I18N_FUNC_FAIL, fname, "xdr_encodeMsg");        xdr_destroy(&xdrs2);        return;    }    if (chanWrite_(chfd, reply_buf, XDR_GETPOS(&xdrs2)) <= 0) {        ls_syslog(LOG_ERR, _i18n_msg_get(ls_catd , NL_SETN, 5833,                                         "%s: Sending  reply to master failed : %m"), /* catgets 5833 */                  fname);        xdr_destroy(&xdrs2);        return;    }    xdr_destroy(&xdrs2);    return;}

int rgetpidCompletionHandler_(struct lsRequest *request){    struct resPid pidReply;    XDR xdrs;    int rc;        rc = resRC2LSErr_(request->rc);    if (rc != 0)	return(-1);    xdrmem_create(&xdrs, request->replyBuf, sizeof(struct resPid), XDR_DECODE);    if (! xdr_resGetpid(&xdrs, &pidReply, NULL)) {	lserrno = LSE_BAD_XDR;	xdr_destroy(&xdrs);	return(-1);    }        *((int *)request->extra) = pidReply.pid;    xdr_destroy(&xdrs);    return(0);} 

static bool_twrite_nis_obj (const char *name, const void *obj, iofct_t writefct){  FILE *out = fopen (name, "wce");  if (out == NULL)    return FALSE;  XDR xdrs;  xdrstdio_create (&xdrs, out, XDR_ENCODE);  bool_t status = writefct (&xdrs, (void *) obj);  xdr_destroy (&xdrs);  fclose (out);  return status;}

/* * Decode an XDR buffer into a door header structure. */intsmb_doorhdr_decode(smb_doorhdr_t *hdr, uint8_t *buf, uint32_t buflen){	XDR xdrs;	int rc = 0;	bzero(hdr, sizeof (smb_doorhdr_t));	xdrmem_create(&xdrs, (const caddr_t)buf, buflen, XDR_DECODE);	if (!smb_doorhdr_xdr(&xdrs, hdr))		rc = -1;	xdr_destroy(&xdrs);	return (rc);}

int virNetMessageDecodeLength(virNetMessagePtr msg){    XDR xdr;    unsigned int len;    int ret = -1;    xdrmem_create(&xdr, msg->buffer,                  msg->bufferLength, XDR_DECODE);    if (!xdr_u_int(&xdr, &len)) {        virReportError(VIR_ERR_RPC, "%s", _("Unable to decode message length"));        goto cleanup;    }    msg->bufferOffset = xdr_getpos(&xdr);    if (len < VIR_NET_MESSAGE_LEN_MAX) {        virReportError(VIR_ERR_RPC,                       _("packet %d bytes received from server too small, want %d"),                       len, VIR_NET_MESSAGE_LEN_MAX);        goto cleanup;    }    /* Length includes length word - adjust to real length to read. */    len -= VIR_NET_MESSAGE_LEN_MAX;    if (len > VIR_NET_MESSAGE_MAX) {        virReportError(VIR_ERR_RPC,                       _("packet %d bytes received from server too large, want %d"),                       len, VIR_NET_MESSAGE_MAX);        goto cleanup;    }    /* Extend our declared buffer length and carry       on reading the header + payload */    msg->bufferLength += len;    if (VIR_REALLOC_N(msg->buffer, msg->bufferLength) < 0) {        virReportOOMError();        goto cleanup;    }    VIR_DEBUG("Got length, now need %zu total (%u more)",              msg->bufferLength, len);    ret = 0;cleanup:    xdr_destroy(&xdr);    return ret;}

voidltspfs_getattr (int sockfd, XDR *in){  XDR         out;  char        path[PATH_MAX];  char 	      output[LTSP_MAXBUF];  int         i;  struct stat stbuf;  if (get_fn(sockfd, in, path)) {    if (debug)      info ("get_fn failed/n");    eacces(sockfd);    return;  }  if (lstat (path, &stbuf) == -1) {    status_return(sockfd, FAIL);    return;  }  xdrmem_create(&out, output, LTSP_MAXBUF, XDR_ENCODE);  i = 0;  xdr_int(&out, &i);	 			/* First, the dummy length */  xdr_int(&out, &i);				/* Then the 0 status return */  xdr_u_longlong_t(&out, &(stbuf.st_dev));	/* device */  xdr_u_longlong_t(&out, &(stbuf.st_ino));	/* inode */  xdr_u_int(&out, &(stbuf.st_mode));		/* protection */  xdr_u_int(&out, &(stbuf.st_nlink));		/* number of hard links */  xdr_u_int(&out, &(stbuf.st_uid));		/* user ID of owner */  xdr_u_int(&out, &(stbuf.st_gid));		/* group ID of owner */  xdr_u_longlong_t(&out, &(stbuf.st_rdev));	/* device type */  xdr_longlong_t(&out, &(stbuf.st_size));	/* total size, in bytes */  xdr_long(&out, &(stbuf.st_blksize));		/* blocksize for fs I/O */  xdr_longlong_t(&out, &(stbuf.st_blocks));	/* number of blocks allocated */  xdr_long(&out, &(stbuf.st_atime));		/* time of last access */  xdr_long(&out, &(stbuf.st_mtime));		/* time of last modification */  xdr_long(&out, &(stbuf.st_ctime));		/* time of last status change */  i = xdr_getpos(&out);				/* Get our position */  xdr_setpos(&out, 0);				/* Rewind to the beginning */  xdr_int(&out, &i);				/* Rewrite with proper length */  xdr_destroy(&out);  if (debug)    info("returning OK");  writen(sockfd, output, i);}

int sodero_deserialize_UDP_report_v1(char *buffer, int numbytes, int *start_pos,		const int num_max_elements, TSoderoUDPReportMsg *stored_data) {	XDR xdr_handle;	int result, size, num_element;	TSoderoUDPReportMsg incoming_data;	xdrmem_create(&xdr_handle, buffer, SEND_RECV_BUFFER_SIZE, XDR_DECODE);	int curr_pos, prev_pos;	prev_pos = *start_pos;	curr_pos = prev_pos;	num_element = 0;	for (; curr_pos < numbytes;) {		// printf("+++++++++++++++++++++++++++++++++++++++++++++++++++++++/n");		xdr_setpos(&xdr_handle, curr_pos);		memset(&incoming_data, 0, sizeof(TSoderoUDPReportMsg));		// result = xdr_TSoderoUDPReport(& xdr_handle, &incoming_data);		result = xdr_TSoderoUDPReportMsg(&xdr_handle,				&stored_data[num_element]);		if (result != TRUE) {			// error			printf("Decoding error/n");			return 0;		}		size = xdr_getpos(&xdr_handle);		// printf("Decode %d bytes of encoded data/n", size - curr_pos);		curr_pos = size;		num_element++;		if (num_element == num_max_elements) {//          printf("Reach max report data elements/n");//          printf("-------------------------------------------------------/n/n");			break;		}		// printf("-------------------------------------------------------/n/n");	}	*start_pos = curr_pos;	xdr_destroy(&xdr_handle);	return num_element;}

/* Extract the information from the entry, serialize and send it out. * Return 0 on success, -1 on error. */static intsend_dirent_info (TSK_FS_FILE *fsfile, const char *path){  XDR xdr;  int ret = 0;  size_t len = 0;  struct guestfs_int_tsk_dirent dirent;  CLEANUP_FREE char *buf = NULL, *fname = NULL;  /* Set dirent fields */  memset (&dirent, 0, sizeof dirent);  /* Build the full relative path of the entry */  ret = asprintf (&fname, "%s%s", path, fsfile->name->name);  if (ret < 0) {    perror ("asprintf");    return -1;  }  dirent.tsk_inode = fsfile->name->meta_addr;  dirent.tsk_type = file_type (fsfile);  dirent.tsk_name = fname;  dirent.tsk_flags = file_flags (fsfile);  file_metadata (fsfile->meta, &dirent);  /* Serialize tsk_dirent struct. */  buf = malloc (GUESTFS_MAX_CHUNK_SIZE);  if (buf == NULL) {    perror ("malloc");    return -1;  }  xdrmem_create (&xdr, buf, GUESTFS_MAX_CHUNK_SIZE, XDR_ENCODE);  ret = xdr_guestfs_int_tsk_dirent (&xdr, &dirent);  if (ret == 0) {    perror ("xdr_guestfs_int_tsk_dirent");    return -1;  }  len = xdr_getpos (&xdr);  xdr_destroy (&xdr);  /* Send serialised tsk_dirent out. */  return send_file_write (buf, len);}

voidltspfs_readdir (int sockfd, XDR *in){  XDR  out;  char path[PATH_MAX];  char output[LTSP_MAXBUF];  DIR  *dp;  char *nameptr;  struct dirent *de;  int  i;  if (get_fn(sockfd, in, path)) {		/* Get the dir name */     eacces(sockfd);    return;  }  dp = opendir (path);  if (dp == NULL) {    status_return(sockfd, FAIL);		/* opendir failed */    return;  }  while ((de = readdir (dp)) != NULL) {    xdrmem_create(&out, output, LTSP_MAXBUF, XDR_ENCODE);    i = 0;    xdr_int(&out, &i);	 			/* First, the dummy length */    i = LTSP_STATUS_CONT;    xdr_int(&out, &i);				/* Then the 2 status return */    xdr_u_longlong_t(&out, &(de->d_ino));	/* Inode */    xdr_u_char(&out, &(de->d_type));		/* type */    nameptr = de->d_name;    xdr_string(&out, &nameptr, PATH_MAX);	/* filename */    i = xdr_getpos(&out);			/* Get our position */    xdr_setpos(&out, 0);			/* Rewind to the beginning */    xdr_int(&out, &i);				/* Rewrite with proper length */    xdr_destroy(&out);    if (debug)      info("returning %s", de->d_name);    writen(sockfd, output, i);  }  closedir (dp);  status_return(sockfd, OK);}

void gmx_fio_rewind(t_fileio* fio){    gmx_fio_lock(fio);    if (fio->xdr)    {        xdr_destroy(fio->xdr);        frewind(fio->fp);        xdrstdio_create(fio->xdr, fio->fp, fio->xdrmode);    }    else    {        frewind(fio->fp);    }    gmx_fio_unlock(fio);}

//serialise a message_client and send it over bioint send_c_message(BIO *bio, struct message_client* m){	//printf("Preparing to send message to server:/n");	//message_print_c(m);	char *buf = calloc(BUFSIZ, sizeof(char));	XDR xdr;	xdrmem_create(&xdr, buf, BUFSIZ, XDR_ENCODE);	if(!xdr_message_client(&xdr, m)) {		perror("could not encode message/n");		return -1;	}	int result = send_char_buf(bio, buf, BUFSIZ);	xdr_destroy(&xdr);	free(buf);	return result;}

int save_data(void *data){    container_2 *old_data;  old_data=(container_2 *)data;  //printf("Before serialization: %s/n",old_data->name);  XDR xdrs;  //Serialization  FILE *fp;  fp=fopen(ser_process_var,"w");  xdrstdio_create(&xdrs,fp, XDR_ENCODE);  if(!xdr_container(&xdrs,old_data)) {printf("Serialization error/n"); return 1;}  //else printf("Data saved/n");   xdr_destroy (&xdrs);  fclose (fp);  return 0;}

void mcfioC_CloseDirect(int jstr)/*** Close a direct access stream, Standard I/O or Memory Mapped***/{   int i;   mcfStream *str;   nTuDDL *ddl;         str =  McfStreamPtrList[jstr];   if (str->row == MCFIO_WRITE) {       /*       **  Flush the event header, and the last table header.        */       if (str->status == MCFIO_RUNNING) {          str->table->numevts++;         str->ehead->evtnum++;         if (mcfioC_WrtEvt(str, FLUSH) == FALSE) return;         str->table->nextLocator = -2;         str->table->numevts--; /* Decrement, the table is incomplete at          				this point */         if (mcfioC_Wrttable(str, FLUSH) == FALSE) return;         if (mcfioC_Wrtfhead(str, FLUSH) == FALSE) return;       }     }     xdr_destroy(str->xdr);     if (str->dos == MCFIO_DIRECT) {          fclose(str->filePtr);     } else {         /*         ** Memory mapped I/O, one has to unmapped..          */         munmap((caddr_t) str->fileAddr, str->fileLen);         close(str->fileDescr);     }     /*     ** One must declare the Ntuples obsolete for this stream.      ** Do not release the memory, just flag these Ntuple with an obsolete      ** stream     */     for (i=0; i<NumOfNTuples; i++) {         ddl = mcf_GetNTuByPtrID((i+1));         if ((ddl != NULL) && (ddl->streamId == (jstr+1)))               ddl->streamId = -1;    }}

/* * Encode an smb_netfileinfo_t into a buffer. */intsmb_netfileinfo_encode(smb_netfileinfo_t *info, uint8_t *buf,    uint32_t buflen, uint_t *nbytes){	XDR xdrs;	int rc = 0;	xdrmem_create(&xdrs, (const caddr_t)buf, buflen, XDR_ENCODE);	if (!smb_netfileinfo_xdr(&xdrs, info))		rc = -1;	if (nbytes != NULL)		*nbytes = xdr_getpos(&xdrs);	xdr_destroy(&xdrs);	return (rc);}

/** * Receive a chunk of file data. * * Returns C<-1> = error, C<0> = EOF, C<E<gt>0> = more data */static ssize_treceive_file_data (guestfs_h *g, void **buf_r){  int r;  CLEANUP_FREE void *buf = NULL;  uint32_t len;  XDR xdr;  guestfs_chunk chunk;  r = guestfs_int_recv_from_daemon (g, &len, &buf);  if (r == -1)    return -1;  if (len == GUESTFS_LAUNCH_FLAG || len == GUESTFS_CANCEL_FLAG) {    error (g, _("receive_file_data: unexpected flag received when reading file chunks"));    return -1;  }  memset (&chunk, 0, sizeof chunk);  xdrmem_create (&xdr, buf, len, XDR_DECODE);  if (!xdr_guestfs_chunk (&xdr, &chunk)) {    error (g, _("failed to parse file chunk"));    return -1;  }  xdr_destroy (&xdr);  if (chunk.cancel) {    if (g->user_cancel)      guestfs_int_error_errno (g, EINTR, _("operation cancelled by user"));    else      error (g, _("file receive cancelled by daemon"));    free (chunk.data.data_val);    return -1;  }  if (chunk.data.data_len == 0) { /* end of transfer */    free (chunk.data.data_val);    return 0;  }  if (buf_r) *buf_r = chunk.data.data_val;  else free (chunk.data.data_val); /* else caller frees */  return chunk.data.data_len;}

int main(){   XDR xdr;   char buffer[512];   FSINFO3args args;   FSINFO3res  res;   memset(&args, 0, sizeof args);   memset(&res, 0, sizeof res);   char rootHandle[28];   args.fsroot.data.data_val = (char*) rootHandle;   args.fsroot.data.data_len = sizeof(rootHandle);   xdrmem_create(&xdr, buffer, sizeof(buffer), XDR_ENCODE);   xdr_FSINFO3args(&xdr, &args);   printf("%d/n", xdr_getpos(&xdr));   xdr_destroy(&xdr);   return 0;}

static bool send_response(XDR *xdr, int fd, int err){	struct rpc_header_res cmd;	xdr_destroy(xdr);	xdrfd_create(xdr, fd, XDR_ENCODE);	cmd.err = errno_to_nerr(err);	if (!xdr_rpc_header_res(xdr, &cmd))		return false; /* failed to send */	if (cmd.err != NERR_SUCCESS)		return true; /* RPC failed */	return true; /* all good */}

/* * Decode an XDR buffer into an smb_netconnectinfo_t. */intsmb_netconnectinfo_decode(smb_netconnectinfo_t *info, uint8_t *buf,    uint32_t buflen, uint_t *nbytes){	XDR xdrs;	int rc = 0;	xdrmem_create(&xdrs, (const caddr_t)buf, buflen, XDR_DECODE);	bzero(info, sizeof (smb_netconnectinfo_t));	if (!smb_netconnectinfo_xdr(&xdrs, info))		rc = -1;	if (nbytes != NULL)		*nbytes = xdr_getpos(&xdrs);	xdr_destroy(&xdrs);	return (rc);}