xref: /illumos-gate/usr/src/cmd/dcs/sparc/sun4u/rdr_messages.c (revision fd3215f7)

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * WARNING: The contents of this file are shared by all projects
 * that  wish to  perform  remote  Dynamic Reconfiguration  (DR)
 * operations. Copies of this file can be found in the following
 * locations:
 *
 *	Project	    Location
 *	-------	    --------
 *	Solaris	    usr/src/cmd/dcs/sparc/sun4u/%M%
 *	SMS	    src/sms/lib/librdr/%M%
 *
 * In order for proper communication to occur,  the files in the
 * above locations must match exactly. Any changes that are made
 * to this file should  be made to all of the files in the list.
 */

/*
 * This file is a module that contains an interface for performing
 * remote Dynamic Reconfiguration (DR) operations. It hides all
 * network operations such as establishing a connection, sending
 * and receiving messages, and closing a connection. It also handles
 * the packing and unpacking of messages for network transport.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <fcntl.h>
#include <errno.h>
#include <dlfcn.h>
#include <netdb.h>
#include <libdscp.h>
#include <sys/socket.h>
#include <sys/systeminfo.h>
#include <netinet/tcp.h>

#include "dcs.h"
#include "remote_cfg.h"
#include "rdr_param_types.h"
#include "rdr_messages.h"


/*
 * Structure holding information about
 * all possible variable length fields
 * that can be present in an RDR message.
 */
typedef struct {
	int	ap_id_int_size;
	int	ap_id_char_size;
	int	*ap_id_sizes;
	char	*ap_id_chars;
	int	errstring_strlen;
	int	errstring_pad_sz;
	int	options_strlen;
	int	options_pad_sz;
	int	listopts_strlen;
	int	listopts_pad_sz;
	int	function_strlen;
	int	function_pad_sz;
} rdr_variable_message_info_t;

/*
 * A table of maximum sizes for each message type. Message size is
 * validated when the message header is first received. This prevents
 * a situation where a corrupted or bad header can cause too much
 * memory to be allocated.
 *
 * The message size limits were chosen to be a very generous upper bound
 * on the amount of data each message can send. They are not intended to
 * be a precise measurement of the data size.
 */
#define	NOMSG		0
#define	SHORTMSG	(150 * 1024)		/* 150 KB */
#define	LONGMSG		(3 * 1024 * 1024)	/* 3 MB */

struct {
	ulong_t	req_max;
	ulong_t	reply_max;
} msg_sizes[] = {
	/*
	 * request	reply
	 * -------	-----
	 */
	{  NOMSG,	NOMSG	  },	/*  Invalid Opcode		*/
	{  SHORTMSG,	SHORTMSG  },	/*  RDR_SES_REQ			*/
	{  NOMSG,	NOMSG	  },	/*  RDR_SES_ESTBL		*/
	{  NOMSG,	NOMSG	  },	/*  RDR_SES_END			*/
	{  SHORTMSG,	SHORTMSG  },	/*  RDR_CONF_CHANGE_STATE	*/
	{  SHORTMSG,	SHORTMSG  },	/*  RDR_CONF_PRIVATE_FUNC	*/
	{  SHORTMSG,	SHORTMSG  },	/*  RDR_CONF_TEST		*/
	{  SHORTMSG,	LONGMSG	  },	/*  RDR_CONF_LIST_EXT		*/
	{  SHORTMSG,	NOMSG	  },	/*  RDR_CONF_HELP		*/
	{  SHORTMSG,	NOMSG	  },	/*  RDR_CONF_AP_ID_CMP		*/
	{  SHORTMSG,	NOMSG	  },	/*  RDR_CONF_ABORT_CMD		*/
	{  SHORTMSG,	SHORTMSG  },	/*  RDR_CONF_CONFIRM_CALLBACK	*/
	{  SHORTMSG,	NOMSG	  },	/*  RDR_CONF_MSG_CALLBACK	*/
	{  SHORTMSG,	LONGMSG	  }	/*  RDR_RSRC_INFO		*/
};


#define	RDR_BAD_FD		(-1)

#define	RDR_MSG_HDR_SIZE	sizeof (rdr_msg_hdr_t)

static const int RDR_ALIGN_64_BIT = 8;   /* 8 bytes */

/*
 * Interfaces for dynamic use of libdscp.
 */

#define	LIBDSCP_PATH	"/usr/platform/%s/lib/libdscp.so.1"

#define	LIBDSCP_BIND	"dscpBind"
#define	LIBDSCP_SECURE	"dscpSecure"
#define	LIBDSCP_AUTH	"dscpAuth"

typedef enum {
	LIBDSCP_UNKNOWN = 0,
	LIBDSCP_AVAILABLE,
	LIBDSCP_UNAVAILABLE
} dscp_status_t;

typedef struct {
	dscp_status_t	status;
	int		(*bind)(int, int, int);
	int		(*secure)(int, int);
	int		(*auth)(int, struct sockaddr *, int);
} libdscp_t;

static libdscp_t libdscp;

/*
 * Static Function Declarations
 */

/*
 * Socket Related Routines
 */
static int rdr_setopt(int fd, int name, int level);

static int rdr_bind(int fd, struct sockaddr *addr);

static int rdr_secure(int fd, struct sockaddr *addr);

static int rdr_auth(struct sockaddr *addr, int len);

static int rdr_snd(int fd, rdr_msg_hdr_t *hdr, char *data, int data_sz,
			int timeout);
static int rdr_snd_raw(int fd, char *msg, int data_sz, int timeout);

static int rdr_rcv(int fd, rdr_msg_hdr_t *hdr, char **data, int timeout);

static int rdr_rcv_raw(int fd, char *msg, int data_size, int timeout);

/*
 * Data Validation Routines
 */
static int validate_header(rdr_msg_hdr_t *hdr);


/*
 * Session Request Routines
 */
static int pack_ses_req_request(ses_req_params_t *params, char **buf,
			int *buf_size);
static int unpack_ses_req_request(ses_req_params_t *params, const char *buf);

static int pack_ses_req_reply(ses_req_params_t *params, char **buf,
			int *buf_size);
static int unpack_ses_req_reply(ses_req_params_t *params, const char *buf);


/*
 * Change State Routines
 */
static int pack_change_state_request(change_state_params_t *params,
			char **buf, int *buf_size);
static int unpack_change_state_request(change_state_params_t *params,
			const char *buf);
static int pack_change_state_reply(change_state_params_t *params,
			char **buf, int *buf_size);
static int unpack_change_state_reply(change_state_params_t *params,
			const char *buf);

/*
 * Private Func Routines
 */
static int pack_private_func_request(private_func_params_t *params,
			char **buf, int *buf_size);
static int unpack_private_func_request(private_func_params_t *params,
			const char *buf);
static int pack_private_func_reply(private_func_params_t *params,
			char **buf, int *buf_size);
static int unpack_private_func_reply(private_func_params_t *params,
			const char *buf);

/*
 * Test Routines
 */
static int pack_test_request(test_params_t *params, char **buf, int *buf_size);

static int unpack_test_request(test_params_t *params, const char *buf);

static int pack_test_reply(test_params_t *params, char **buf, int *buf_size);

static int unpack_test_reply(test_params_t *params, const char *buf);


/*
 * List Ext Routines
 */
static int pack_list_ext_request(list_ext_params_t *params, char **buf,
			int *buf_size);
static int unpack_list_ext_request(list_ext_params_t *params, const char *buf);

static int pack_list_ext_reply(list_ext_params_t *params, char **buf,
			int *buf_size);
static int unpack_list_ext_reply(list_ext_params_t *params, const char *buf);


/*
 * Help Routines
 */
static int pack_help_request(help_params_t *params, char **buf, int *buf_size);

static int unpack_help_request(help_params_t *params, const char *buf);


/*
 * Ap Id Cmp Routines
 */
static int pack_ap_id_cmp_request(ap_id_cmp_params_t *params, char **buf,
			int *buf_size);
static int unpack_ap_id_cmp_request(ap_id_cmp_params_t *params,
			const char *buf);

/*
 * Abort Routines
 */
static int pack_abort_cmd_request(abort_cmd_params_t *params, char **buf,
			int *buf_size);
static int unpack_abort_cmd_request(abort_cmd_params_t *params,
			const char *buf);

/*
 * Confirm Callback Routines
 */
static int pack_confirm_request(confirm_callback_params_t *params, char **buf,
			int *buf_size);
static int unpack_confirm_request(confirm_callback_params_t *params,
			const char *buf);
static int pack_confirm_reply(confirm_callback_params_t *params,
			char **buf, int *buf_size);
static int unpack_confirm_reply(confirm_callback_params_t *params,
			const char *buf);

/*
 * Message Callback Routines
 */
static int pack_message_request(msg_callback_params_t *params, char **buf,
			int *buf_size);
static int unpack_message_request(msg_callback_params_t *params,
			const char *buf);

/*
 * Resource Info Routines
 */
static int pack_rsrc_info_request(rsrc_info_params_t *params, char **buf,
			int *buf_size);
static int unpack_rsrc_info_request(rsrc_info_params_t *params,
			const char *buf);
static int pack_rsrc_info_reply(rsrc_info_params_t *params, char **buf,
			int *buf_size, int encoding);
static int unpack_rsrc_info_reply(rsrc_info_params_t *params, const char *buf);

/*
 * General Pack/Unpack Routines
 */
static int pack_ap_ids(int num_ap_ids, char *const *ap_ids,
			rdr_variable_message_info_t *var_msg_info);
static int unpack_ap_ids(int num_ap_ids, char **ap_ids, const char *buf,
			rdr_variable_message_info_t *var_msg_info);

/*
 * Find Variable Info Sizes
 */
static int find_options_sizes(char *options,
			rdr_variable_message_info_t *var_msg_info);
static int find_listopts_sizes(char *listopts,
			rdr_variable_message_info_t *var_msg_info);
static int find_function_sizes(char *function,
			rdr_variable_message_info_t *var_msg_info);
static int find_errstring_sizes(char **errstring,
			rdr_variable_message_info_t *var_msg_info);

/*
 * Extract Info From Buffers
 */
static int get_ap_ids_from_buf(char ***ap_id_ptr, int num_ap_ids,
			rdr_variable_message_info_t *var_msg_info,
			const char *buf);
static int get_string_from_buf(char **stringptr, int strsize, const char *buf);


/*
 * Cleanup Routines
 */
static int cleanup_ap_ids(int num_ap_ids, char **ap_ids);

static int cleanup_errstring(char **errstring);

static void cleanup_variable_ap_id_info(
			rdr_variable_message_info_t *var_msg_info);

/*
 * Functions for loading libdscp.
 */
static int load_libdscp(libdscp_t *libdscp);

/*
 * Public Functions
 */


/*
 * rdr_open:
 *
 * Establish a transport endpoint to prepare for a new
 * connection. Returns a file descriptor representing the
 * new transport if successful or RDR_BAD_FD upon failure.
 */
int
rdr_open(int family)
{
	int	newfd;


	if ((newfd = socket(family, SOCK_STREAM, 0)) == -1) {
		return (RDR_BAD_FD);
	}

	return (newfd);
}


/*
 * rdr_init:
 *
 * Initialize a transport endpoint. This involves binding to
 * a particular port and setting any user specified socket
 * options.
 */
int
rdr_init(int fd, struct sockaddr *addr, int *opts, int num_opts, int blog)
{
	int	i;


	/* sanity checks */
	if ((fd < 0) || (addr == NULL)) {
		return (RDR_ERROR);
	}

	if ((opts == NULL) || (num_opts < 0)) {
		num_opts = 0;
	}

	/* turn on security features */
	if (rdr_secure(fd, addr) != RDR_OK) {
		return (RDR_NET_ERR);
	}

	/* bind the address, if is not already bound */
	if (rdr_bind(fd, addr) != RDR_OK) {
		return (RDR_NET_ERR);
	}

	/*
	 * Set TCP_NODELAY for this endpoint. This disables Nagle's
	 * algorithm that can cause a delay in sending small sized
	 * messages. Since most of the RDR messages are small, this
	 * is a restriction that negatively impacts performance.
	 */
	if (rdr_setopt(fd, TCP_NODELAY, IPPROTO_TCP) != RDR_OK) {
		return (RDR_NET_ERR);
	}

	/* set the user specified socket options */
	for (i = 0; i < num_opts; i++) {
		if (rdr_setopt(fd, opts[i], SOL_SOCKET) != RDR_OK) {
			return (RDR_NET_ERR);
		}
	}

	/*
	 * If blog is not zero, it is a server that is being
	 * initialized. In order for it to be able to accept
	 * connections, we have to set the size of the incoming
	 * connection queue.
	 */
	if (blog != 0) {
		if (listen(fd, blog) == -1) {
			return (RDR_NET_ERR);
		}
	}

	return (RDR_OK);
}


/*
 * rdr_connect_clnt:
 *
 * Perform the necessary steps for a client to connect to
 * a server process. The required information is the file
 * descriptor for the transport endpoint, and the remote
 * address.
 */
int
rdr_connect_clnt(int fd, struct sockaddr *addr)
{
	unsigned int	addr_len;


	/* sanity check */
	if (addr == NULL) {
		return (RDR_ERROR);
	}

	/* initialize the address length */
	switch (addr->sa_family) {

	case AF_INET:
		addr_len = sizeof (struct sockaddr_in);
		break;

	case AF_INET6:
		addr_len = sizeof (struct sockaddr_in6);
		break;

	default:
		return (RDR_ERROR);
	}

	/* attempt the connection */
	if (connect(fd, addr, addr_len) == -1) {
		return (RDR_NET_ERR);
	}

	return (RDR_OK);
}


/*
 * rdr_connect_srv:
 *
 * Perform the necessary steps for a server to connect to a
 * pending client request. The new connection is allocated a
 * new file descriptor, separate from the one used to accept
 * the connection.
 */
int
rdr_connect_srv(int fd)
{
	int			newfd;
	unsigned int		faddr_len;
	struct sockaddr_storage	faddr;


	/* accept the connection */
	faddr_len = sizeof (faddr);
	if ((newfd = accept(fd, (struct sockaddr *)&faddr, &faddr_len)) == -1) {
		return (RDR_BAD_FD);
	}

	/* if the peer doesn't authenticate properly, reject */
	if (rdr_auth((struct sockaddr *)&faddr, faddr_len) != RDR_OK) {
		(void) close(newfd);
		return (RDR_BAD_FD);
	}

	return (newfd);
}


/*
 * rdr_reject:
 *
 * Reject an incoming connection attempt. This requires
 * that the connection be accepted first.
 */
int
rdr_reject(int fd)
{
	unsigned int		faddr_len;
	struct sockaddr_storage	faddr;


	/* first accept the connection */
	faddr_len = sizeof (faddr);
	if (accept(fd, (struct sockaddr *)&faddr, &faddr_len) == -1) {
		return (RDR_NET_ERR);
	}

	/* then close it */
	(void) close(fd);

	return (RDR_OK);
}


/*
 * rdr_close:
 *
 * Close down an given connection.
 */
int
rdr_close(int fd)
{
	(void) close(fd);

	return (RDR_OK);
}


/*
 * rdr_snd_msg:
 *
 * Public interface for sending an RDR message. The data
 * passed in through hdr and param are packed for network
 * transport and sent.
 */
int
rdr_snd_msg(int fd, rdr_msg_hdr_t *hdr, cfga_params_t *param, int timeout)
{
	int	err;
	char	*pack_buf = NULL;
	int	pack_buf_sz = 0;


	/* sanity checks */
	if ((hdr == NULL) || (param == NULL)) {
		return (RDR_ERROR);
	}

	/*
	 * Pack the message for transport
	 */
	switch (hdr->message_opcode) {

		case RDR_SES_REQ: {

			ses_req_params_t *rparam;
			rparam = (ses_req_params_t *)param;

			if (hdr->data_type == RDR_REQUEST) {
				err = pack_ses_req_request(rparam,
				    &pack_buf, &pack_buf_sz);
			} else {
				err = pack_ses_req_reply(rparam,
				    &pack_buf, &pack_buf_sz);
			}

			break;
		}

		case RDR_SES_ESTBL:
		case RDR_SES_END:

			/*
			 * This is not an error condition because
			 * there is no extra information to pack.
			 */
			err = RDR_OK;
			break;

		case RDR_CONF_CHANGE_STATE: {

			change_state_params_t *cparam;
			cparam = (change_state_params_t *)param;

			if (hdr->data_type == RDR_REQUEST) {
				err = pack_change_state_request(cparam,
				    &pack_buf, &pack_buf_sz);
			} else {
				err = pack_change_state_reply(cparam,
				    &pack_buf, &pack_buf_sz);
			}
			break;
		}

		case RDR_CONF_PRIVATE_FUNC: {

			private_func_params_t *pparam;
			pparam = (private_func_params_t *)param;

			if (hdr->data_type == RDR_REQUEST) {
				err = pack_private_func_request(pparam,
				    &pack_buf, &pack_buf_sz);
			} else {
				err = pack_private_func_reply(pparam,
				    &pack_buf, &pack_buf_sz);
			}
			break;
		}

		case RDR_CONF_TEST: {

			test_params_t *tparam;
			tparam = (test_params_t *)param;

			if (hdr->data_type == RDR_REQUEST) {
				err = pack_test_request(tparam,
				    &pack_buf, &pack_buf_sz);
			} else {
				err = pack_test_reply(tparam,
				    &pack_buf, &pack_buf_sz);
			}
			break;
		}

		case RDR_CONF_LIST_EXT: {

			list_ext_params_t *lparam;
			lparam = (list_ext_params_t *)param;

			if (hdr->data_type == RDR_REQUEST) {
				err = pack_list_ext_request(lparam, &pack_buf,
				    &pack_buf_sz);
			} else {
				err = pack_list_ext_reply(lparam, &pack_buf,
				    &pack_buf_sz);
			}
			break;
		}

		case RDR_CONF_HELP: {

			help_params_t *hparam;
			hparam = (help_params_t *)param;

			if (hdr->data_type == RDR_REQUEST) {
				err = pack_help_request(hparam,
				    &pack_buf, &pack_buf_sz);
			} else {

				/*
				 * This is not an error because help
				 * reply does not have any extra information
				 * to pack.
				 */
				err = RDR_OK;
			}
			break;
		}

		case RDR_CONF_AP_ID_CMP: {

			ap_id_cmp_params_t *aparam;
			aparam = (ap_id_cmp_params_t *)param;

			if (hdr->data_type == RDR_REQUEST) {
				err = pack_ap_id_cmp_request(aparam,
				    &pack_buf, &pack_buf_sz);
			} else {

				/*
				 * This is not an error because ap_id_cmp
				 * reply does not have any extra information
				 * to pack.
				 */
				err = RDR_OK;
			}
			break;
		}

		case RDR_CONF_ABORT_CMD: {

			abort_cmd_params_t *aparam;
			aparam = (abort_cmd_params_t *)param;

			if (hdr->data_type == RDR_REQUEST) {
				err = pack_abort_cmd_request(aparam,
				    &pack_buf, &pack_buf_sz);
			} else {
				/*
				 * This is not an error because session
				 * abort reply does not have any extra
				 * information to pack.
				 */
				err = RDR_OK;
			}
			break;
		}

		case RDR_CONF_CONFIRM_CALLBACK: {

			confirm_callback_params_t *cparam;
			cparam = (confirm_callback_params_t *)param;

			if (hdr->data_type == RDR_REQUEST) {
				err = pack_confirm_request(cparam,
				    &pack_buf, &pack_buf_sz);
			} else {
				err = pack_confirm_reply(cparam, &pack_buf,
				    &pack_buf_sz);
			}
			break;
		}

		case RDR_CONF_MSG_CALLBACK: {

			msg_callback_params_t *mparam;
			mparam = (msg_callback_params_t *)param;

			if (hdr->data_type == RDR_REQUEST) {
				err = pack_message_request(mparam,
				    &pack_buf, &pack_buf_sz);
			} else {
				/*
				 * It is an error to send a reply
				 * to a message callback.
				 */
				err = RDR_MSG_INVAL;
			}
			break;
		}

		case RDR_RSRC_INFO: {

			rsrc_info_params_t *rparam;
			rparam = (rsrc_info_params_t *)param;

			if (hdr->data_type == RDR_REQUEST) {
				err = pack_rsrc_info_request(rparam, &pack_buf,
				    &pack_buf_sz);
			} else {
				if ((hdr->major_version == 1) &&
				    (hdr->minor_version == 0)) {
					err = pack_rsrc_info_reply(rparam,
					    &pack_buf, &pack_buf_sz,
					    NV_ENCODE_NATIVE);
				} else {
					err = pack_rsrc_info_reply(rparam,
					    &pack_buf, &pack_buf_sz,
					    NV_ENCODE_XDR);
				}
			}
			break;
		}

		default:
			err = RDR_MSG_INVAL;
			break;
	}

	/* check if packed correctly */
	if (err != RDR_OK) {
		return (err);
	}

	/* send the message */
	err = rdr_snd(fd, hdr, pack_buf, pack_buf_sz, timeout);

	free((void *)pack_buf);

	return (err);
}


/*
 * rdr_rcv_msg:
 *
 * Public interface for receiving an RDR message. Data is
 * unpacked into the hdr and param paramters.
 */
int
rdr_rcv_msg(int fd, rdr_msg_hdr_t *hdr, cfga_params_t *param, int timeout)
{
	int	err;
	char	*unpack_buf = NULL;


	/* sanity checks */
	if ((hdr == NULL) || (param == NULL)) {
		return (RDR_ERROR);
	}

	(void) memset(param, 0, sizeof (cfga_params_t));

	/* receive the message */
	if ((err = rdr_rcv(fd, hdr, &unpack_buf, timeout)) != RDR_OK) {
		return (err);
	}

	/*
	 * Unpack the message
	 */
	switch (hdr->message_opcode) {

		case RDR_SES_REQ: {

			ses_req_params_t *rparam;
			rparam = (ses_req_params_t *)param;

			if (hdr->data_type == RDR_REQUEST) {
				err = unpack_ses_req_request(rparam,
				    unpack_buf);
			} else {
				err = unpack_ses_req_reply(rparam, unpack_buf);
			}
			break;
		}

		case RDR_SES_ESTBL:
		case RDR_SES_END:

			/* no information to unpack */
			(void) memset(param, 0, sizeof (cfga_params_t));
			err = RDR_OK;
			break;

		case RDR_CONF_CHANGE_STATE: {

			change_state_params_t *cparam;
			cparam = (change_state_params_t *)param;

			if (hdr->data_type == RDR_REQUEST) {
				err = unpack_change_state_request(cparam,
				    unpack_buf);
			} else {
				err = unpack_change_state_reply(cparam,
				    unpack_buf);
			}
			break;
		}

		case RDR_CONF_PRIVATE_FUNC: {

			private_func_params_t *pparam;
			pparam = (private_func_params_t *)param;

			if (hdr->data_type == RDR_REQUEST) {
				err = unpack_private_func_request(pparam,
				    unpack_buf);
			} else {
				err = unpack_private_func_reply(pparam,
				    unpack_buf);
			}
			break;
		}

		case RDR_CONF_TEST: {

			test_params_t *tparam;
			tparam = (test_params_t *)param;

			if (hdr->data_type == RDR_REQUEST) {
				err = unpack_test_request(tparam, unpack_buf);
			} else {
				err = unpack_test_reply(tparam, unpack_buf);
			}
			break;
		}

		case RDR_CONF_LIST_EXT: {

			list_ext_params_t *lparam;
			lparam = (list_ext_params_t *)param;

			if (hdr->data_type == RDR_REQUEST) {
				err = unpack_list_ext_request(lparam,
				    unpack_buf);
			} else {
				err = unpack_list_ext_reply(lparam, unpack_buf);
			}
			break;
		}

		case RDR_CONF_HELP: {

			help_params_t *hparam;
			hparam = (help_params_t *)param;

			if (hdr->data_type == RDR_REQUEST) {
				err = unpack_help_request(hparam,
				    unpack_buf);
			} else {
				/*
				 * This is not an error because help
				 * reply does not have any extra information
				 * to unpack.
				 */
				err = RDR_OK;
			}
			break;
		}

		case RDR_CONF_AP_ID_CMP: {

			ap_id_cmp_params_t *aparam;
			aparam = (ap_id_cmp_params_t *)param;

			if (hdr->data_type == RDR_REQUEST) {
				err = unpack_ap_id_cmp_request(aparam,
				    unpack_buf);
			} else {
				/*
				 * This is not an error because ap_id_cmp
				 * reply does not have any extra information
				 * to pack.
				 */
				err = RDR_OK;
			}
			break;
		}

		case RDR_CONF_ABORT_CMD: {

			abort_cmd_params_t *aparam;
			aparam = (abort_cmd_params_t *)param;

			if (hdr->data_type == RDR_REQUEST) {
				err = unpack_abort_cmd_request(aparam,
				    unpack_buf);
			} else {
				/* no information to unpack */
				(void) memset(param, 0, sizeof (cfga_params_t));
				err = RDR_OK;
			}

			break;
		}

		case RDR_CONF_CONFIRM_CALLBACK: {

			confirm_callback_params_t *cparam;
			cparam = (confirm_callback_params_t *)param;

			if (hdr->data_type == RDR_REQUEST) {
				err = unpack_confirm_request(cparam,
				    unpack_buf);
			} else {
				err = unpack_confirm_reply(cparam, unpack_buf);
			}
			break;
		}

		case RDR_CONF_MSG_CALLBACK: {

			msg_callback_params_t *mparam;
			mparam = (msg_callback_params_t *)param;

			if (hdr->data_type == RDR_REQUEST) {
				err = unpack_message_request(mparam,
				    unpack_buf);
			} else {
				/*
				 * It is an error to send a reply
				 * to a message callback.
				 */
				(void) memset(param, 0, sizeof (cfga_params_t));
				err = RDR_MSG_INVAL;
			}
			break;
		}

		case RDR_RSRC_INFO: {

			rsrc_info_params_t *rparam;
			rparam = (rsrc_info_params_t *)param;

			if (hdr->data_type == RDR_REQUEST) {
				err = unpack_rsrc_info_request(rparam,
				    unpack_buf);
			} else {
				err = unpack_rsrc_info_reply(rparam,
				    unpack_buf);
			}
			break;
		}

		default:
			err = RDR_MSG_INVAL;
			break;
	}

	free(unpack_buf);

	/* check if unpacked correctly */
	if (err != RDR_OK) {
		return (err);
	}

	return (RDR_OK);
}


/*
 * rdr_cleanup_params:
 *
 * Deallocate any memory that was allocated in unpacking a
 * message.
 */
int
rdr_cleanup_params(rdr_msg_opcode_t message_opcode, cfga_params_t *param)
{
	/* sanity check */
	if ((param == NULL)) {
		return (RDR_ERROR);
	}

	/*
	 * Deallocate memory depending on
	 * the operation.
	 */
	switch (message_opcode) {

	case RDR_SES_REQ: {

		ses_req_params_t *sparam;
		sparam = (ses_req_params_t *)param;

		if (sparam->locale_str != NULL) {
			free((void *)sparam->locale_str);
			sparam->locale_str = NULL;
		}
		break;
	}

	case RDR_SES_ESTBL:
	case RDR_SES_END:

		/* nothing to deallocate */
		break;

	case RDR_CONF_CHANGE_STATE: {

		change_state_params_t *cparam;
		cparam = (change_state_params_t *)param;

		cleanup_ap_ids(cparam->num_ap_ids, (char **)cparam->ap_ids);
		cparam->ap_ids = NULL;
		if (cparam->options != NULL) {
			free((void *)cparam->options);
			cparam->options = NULL;
		}
		if (cparam->confp != NULL) {
			free((void *)cparam->confp);
			cparam->confp = NULL;
		}
		if (cparam->msgp != NULL) {
			free((void *)cparam->msgp);
			cparam->msgp = NULL;
		}
		cleanup_errstring(cparam->errstring);
		break;
	}

	case RDR_CONF_PRIVATE_FUNC: {

		private_func_params_t *pparam;
		pparam = (private_func_params_t *)param;

		cleanup_ap_ids(pparam->num_ap_ids, (char **)pparam->ap_ids);
		pparam->ap_ids = NULL;
		if (pparam->options != NULL) {
			free((void *)pparam->options);
			pparam->options = NULL;
		}
		if (pparam->confp != NULL) {
			free((void *)pparam->confp);
			pparam->confp = NULL;
		}
		if (pparam->msgp != NULL) {
			free((void *)pparam->msgp);
			pparam->msgp = NULL;
		}
		cleanup_errstring(pparam->errstring);
		break;
	}

	case RDR_CONF_TEST: {

		test_params_t *tparam;
		tparam = (test_params_t *)param;

		cleanup_ap_ids(tparam->num_ap_ids, (char **)tparam->ap_ids);
		tparam->ap_ids = NULL;
		if (tparam->options != NULL) {
			free((void *)tparam->options);
			tparam->options = NULL;
		}
		if (tparam->msgp != NULL) {
			free((void *)tparam->msgp);
			tparam->msgp = NULL;
		}
		cleanup_errstring(tparam->errstring);
		break;
	}

	case RDR_CONF_LIST_EXT: {

		list_ext_params_t *lparam;
		lparam = (list_ext_params_t *)param;

		cleanup_ap_ids(lparam->num_ap_ids, (char **)lparam->ap_ids);
		lparam->ap_ids = NULL;

		if (lparam->nlist != NULL) {
			free((void *)lparam->nlist);
			lparam->nlist = NULL;
		}
		if (lparam->ap_id_list != NULL) {
			if (*lparam->ap_id_list != NULL) {
				free((void *)*lparam->ap_id_list);
			}
			free((void *)lparam->ap_id_list);
			lparam->ap_id_list = NULL;
		}
		if (lparam->ap_id_list != NULL) {
			free((void *)lparam->ap_id_list);
			lparam->ap_id_list = NULL;
		}

		if (lparam->options != NULL) {
			free((void *)lparam->options);
			lparam->options = NULL;
		}
		if (lparam->listopts != NULL) {
			free((void *)lparam->listopts);
			lparam->listopts = NULL;
		}
		cleanup_errstring(lparam->errstring);
		break;
	}

	case RDR_CONF_HELP: {

		help_params_t *hparam;
		hparam = (help_params_t *)param;

		cleanup_ap_ids(hparam->num_ap_ids, (char **)hparam->ap_ids);
		hparam->ap_ids = NULL;
		if (hparam->msgp != NULL) {
			free((void *)hparam->msgp);
			hparam->msgp = NULL;
		}
		if (hparam->options != NULL) {
			free((void *)hparam->options);
			hparam->options = NULL;
		}
		break;
	}

	case RDR_CONF_AP_ID_CMP: {

		ap_id_cmp_params_t *aparam;
		aparam = (ap_id_cmp_params_t *)param;

		if (aparam->ap_log_id1 != NULL) {
			free((void *)aparam->ap_log_id1);
			aparam->ap_log_id1 = NULL;
		}
		if (aparam->ap_log_id2 != NULL) {
			free((void *)aparam->ap_log_id2);
			aparam->ap_log_id2 = NULL;
		}
		break;
	}

	case RDR_CONF_ABORT_CMD:

		/* nothing to deallocate */
		break;

	case RDR_CONF_CONFIRM_CALLBACK: {

		confirm_callback_params_t *cparam;
		cparam = (confirm_callback_params_t *)param;

		if (cparam->confp != NULL) {
			free((void *)cparam->confp);
			cparam->confp = NULL;
		}
		if (cparam->message != NULL) {
			free((void *)cparam->message);
			cparam->message = NULL;
		}
		break;
	}

	case RDR_CONF_MSG_CALLBACK: {

		msg_callback_params_t *mparam;
		mparam = (msg_callback_params_t *)param;

		if (mparam->msgp != NULL) {
			free((void *)mparam->msgp);
			mparam->msgp = NULL;
		}
		if (mparam->message != NULL) {
			free((void *)mparam->message);
			mparam->message = NULL;
		}
		break;
	}

	default:
		return (RDR_ERROR);
		/* NOTREACHED */
		break;

	}

	return (RDR_OK);
}

/*
 * rdr_setsockopt:
 *
 * Wrapper of the setsockopt(3SOCKET) library function.
 */
int
rdr_setsockopt(int fd, int level, int optname, const void *optval, int optlen)
{
	if (setsockopt(fd, level, optname, optval, optlen) == -1)
		return (RDR_NET_ERR);
	else
		return (RDR_OK);
}


/*
 * Private (static) Functions
 */


/*
 * rdr_setopt:
 *
 * Set the specified option for a given transport endpoint.
 * This function only sets boolean options. It does not
 * provide the ability to unset an option, or set a non-
 * boolean option.
 */
static int
rdr_setopt(int fd, int name, int level)
{
	int	on = 1;


	if (setsockopt(fd, level, name, &on, sizeof (on)) == -1) {
		return (RDR_NET_ERR);
	}

	return (RDR_OK);
}


/*
 * rdr_bind:
 *
 * Bind the specified file descriptor to a specified
 * address. If the address is already bound, no error is
 * returned. This is the expected behavior if a server
 * has been started by inetd (1M).
 */
static int
rdr_bind(int fd, struct sockaddr *addr)
{
	unsigned int		addr_len;
	int			rc;


	/* initialize the address */
	switch (addr->sa_family) {

	case AF_INET:
		addr_len = sizeof (struct sockaddr_in);
		break;

	case AF_INET6:
		addr_len = sizeof (struct sockaddr_in6);
		break;

	default:
		return (RDR_ERROR);
	}

	/* attempt to bind the address */
	rc = bind(fd, addr, addr_len);

	/*
	 * Ignore the error if EINVAL is returned. In
	 * this case, we assume that this means that
	 * the address was already bound. This is not
	 * an error for servers started by inetd (1M).
	 */
	if ((rc == -1) && (errno != EINVAL)) {
		return (RDR_NET_ERR);
	}

	/*
	 * Retreive the address information of the
	 * address that was actually bound.
	 */
	addr_len = sizeof (*addr);
	if (getsockname(fd, addr, &addr_len) == -1) {
		(void) memset(addr, 0, sizeof (*addr));
		return (RDR_NET_ERR);
	}

	return (RDR_OK);
}


/*
 * rdr_secure:
 *
 * Activate security features for a socket.
 *
 * Some platforms have libdscp, which provides additional
 * security features.  An attempt is made to load libdscp
 * and use these features.
 *
 * Nothing is done if libdscp is not available.
 */
static int
rdr_secure(int fd, struct sockaddr *addr)
{
	struct sockaddr_in	*sin;
	int			port;
	int			error;

	if (use_libdscp == 0) {
		return (RDR_OK);
	}

	if (load_libdscp(&libdscp) != 1) {
		return (RDR_ERROR);
	}

	/* LINTED E_BAD_PTR_CAST_ALIGN */
	sin = (struct sockaddr_in *)addr;
	port = ntohs(sin->sin_port);
	error = libdscp.bind(0, fd, port);

	if ((error != DSCP_OK) && (error != DSCP_ERROR_ALREADY)) {
		return (RDR_ERROR);
	}

	if (libdscp.secure(0, fd) != DSCP_OK) {
		return (RDR_ERROR);
	}
	return (RDR_OK);
}

/*
 * rdr_auth:
 *
 * Authenticate if a connection is really from the service
 * processor.  This is dependent upon functionality from
 * libdscp, so an attempt to load and use libdscp is made.
 *
 * Without libdscp, this function does nothing.
 */
static int
rdr_auth(struct sockaddr *addr, int len)
{
	if (use_libdscp != 0) {
		if ((load_libdscp(&libdscp) == 0) ||
		    (libdscp.auth(0, addr, len) != DSCP_OK)) {
			return (RDR_ERROR);
		}
	}

	return (RDR_OK);
}

/*
 * rdr_snd:
 *
 * Send a message in two stages. First the header is sent,
 * followed by the packed buffer containing the message
 * contents.
 */
static int
rdr_snd(int fd, rdr_msg_hdr_t *hdr, char *data, int data_sz, int timeout)
{
	int	err;


	/* sanity check */
	if (hdr == NULL) {
		return (RDR_ERROR);
	}

	/* ensure null pad bytes */
	hdr->pad_byte1 = 0;
	hdr->pad_byte2 = 0;

	/* initialize size information */
	hdr->data_length = data_sz;

	/* send message header */
	err = rdr_snd_raw(fd, (char *)hdr, RDR_MSG_HDR_SIZE, timeout);
	if (err != RDR_OK) {
		return (err);
	}

	/* check if more to send */
	if (data_sz == 0) {
		return (RDR_OK);
	}

	/* send message data */
	err = rdr_snd_raw(fd, data, data_sz, timeout);
	if (err != RDR_OK) {
		return (err);
	}

	return (RDR_OK);
}


/*
 * rdr_snd_raw:
 *
 * Send a raw buffer of information. This function handles
 * the low level details of the send operation.
 */
static int
rdr_snd_raw(int fd, char *msg, int data_sz, int timeout)
{
	int		err;
	int		num_bytes;
	int		bytes_left;
	char		*bufp;
	struct pollfd	pfd;


	bufp = (char *)msg;

	bytes_left = data_sz;

	pfd.fd = fd;
	pfd.events = POLLOUT;

	while (bytes_left > 0) {

		pfd.revents = 0;

		/* wait until we can send the data */
		if ((err = poll(&pfd, 1, timeout)) == -1) {

			/* poll was interrupted */
			if (errno == EINTR) {
				return (RDR_ABORTED);
			}

			return (RDR_ERROR);

		} else if (err == 0) {
			return (RDR_TIMEOUT);
		}

		/* ready to send data */
		if (pfd.revents & POLLOUT) {

			num_bytes = write(fd, bufp, bytes_left);

			if (num_bytes == -1) {

				/*
				 * Distinguish between an aborted
				 * session and other network errors.
				 */
				if (errno == EPIPE) {
					return (RDR_ABORTED);
				} else {
					return (RDR_NET_ERR);
				}
			}

			/* wrote 0 bytes, so operation was aborted */
			if (num_bytes == 0) {
				return (RDR_ABORTED);
			}

		} else {
			return (RDR_NET_ERR);
		}

		bytes_left -= num_bytes;
		bufp += num_bytes;
	}

	return (RDR_OK);
}


/*
 * rdr_rcv:
 *
 * Receive a message in two stages. First the header is
 * received, followed by the packed buffer containing the
 * message contents.
 */
static int
rdr_rcv(int fd, rdr_msg_hdr_t *hdr, char **data, int timeout)
{
	int	err;
	int	data_sz;
	char	hdr_buf[RDR_MSG_HDR_SIZE];
	char	*buf = NULL;


	/* sanity check */
	if (hdr == NULL) {
		return (RDR_ERROR);
	}

	/* receive the header */
	err = rdr_rcv_raw(fd, hdr_buf, RDR_MSG_HDR_SIZE, timeout);
	if (err != RDR_OK) {
		return (err);
	}

	/* verify that the data is good */
	/* LINTED Pointer Cast Alignment Warning */
	if (validate_header((rdr_msg_hdr_t *)hdr_buf) != RDR_OK) {
		return (RDR_MSG_INVAL);
	}

	/* LINTED Pointer Cast Alignment Warning */
	data_sz = ((rdr_msg_hdr_t *)hdr_buf)->data_length;

	buf = (char *)malloc(data_sz);
	if (!buf) {
		return (RDR_MEM_ALLOC);
	}

	if (data_sz != 0) {

		/* receive the rest of the message */
		err = rdr_rcv_raw(fd, buf, data_sz, timeout);
		if (err != RDR_OK) {
			free((void *)buf);
			return (err);
		}
	}

	/* copy out data */
	*data = buf;
	(void) memcpy(hdr, hdr_buf, RDR_MSG_HDR_SIZE);

	return (RDR_OK);
}


/*
 * rdr_rcv_raw:
 *
 * Receive a raw buffer of information. This function handles
 * the low level details of the receive operation.
 */
static int
rdr_rcv_raw(int fd, char *msg, int data_size, int timeout)
{
	int		num_bytes;
	int		err;
	int		bytes_left;
	char		*bufp;
	struct pollfd	pollfd;


	bufp = (char *)msg;
	bytes_left = data_size;

	pollfd.fd = fd;
	pollfd.events = POLLIN;

	while (bytes_left > 0) {

		errno = 0;
		pollfd.revents = 0;

		if ((err = poll(&pollfd, 1, timeout)) == -1) {

			/*
			 * In the DCA, if a session is aborted, SIGINT
			 * is delivered to all active sessions. This
			 * mistakenly causes all sessions waiting in
			 * the poll to be interrupted. So, if EINTR
			 * is returned, it is ignored. If another error
			 * occurs right away, the current session really
			 * was aborted. All other sessions won't encounter
			 * an error and will proceed normally.
			 */
			if ((errno == 0) || (errno == EINTR)) {
				continue;
			}

			return (RDR_ABORTED);

		} else if (err == 0) {
			return (RDR_TIMEOUT);
		}

		/* ready to receive data */
		if (pollfd.revents & POLLIN) {

			num_bytes = read(fd, bufp, bytes_left);

			if (num_bytes == -1) {

				/*
				 * Distinguish between an aborted
				 * session and other network errors.
				 */
				if (errno == ECONNRESET) {
					return (RDR_ABORTED);
				} else {
					return (RDR_NET_ERR);
				}
			}

			/* read 0 bytes, so operation was aborted */
			if (num_bytes == 0) {
				return (RDR_ABORTED);
			}

		} else {
			return (RDR_NET_ERR);
		}

		bytes_left -= num_bytes;
		bufp += num_bytes;
	}

	return (RDR_OK);
}


/*
 * validate_header:
 *
 * Perform a series of sanity checks on the header data that is
 * received. This gets called before the variable length data is
 * read in to make sure that the information in the header can
 * be trusted.
 */
static int
validate_header(rdr_msg_hdr_t *hdr)
{
	unsigned char	op;


	if (hdr == NULL) {
		return (RDR_ERROR);
	}

	op = hdr->message_opcode;

	/* validate opcode */
	if ((op < RDR_SES_REQ) || (op >= RDR_NUM_OPS)) {
		return (RDR_ERROR);
	}

	/* validate message size (and type) for op */
	switch (hdr->data_type) {

	case RDR_REQUEST:
		if (hdr->data_length > msg_sizes[op].req_max) {
			return (RDR_ERROR);
		}
		break;

	case RDR_REPLY:
		if (hdr->data_length > msg_sizes[op].reply_max) {
			return (RDR_ERROR);
		}
		break;

	default:
		/* invalid data type */
		return (RDR_ERROR);
	}

	/* all checks passed */
	return (RDR_OK);
}


/*
 * pack_ses_req_request:
 *
 * Handle packing a session request request message.
 */
static int
pack_ses_req_request(ses_req_params_t *params, char **buf, int *buf_size)
{
	char		*bufptr;
	int		locale_str_len;
	rdr_ses_req_t	ses_req;


	if ((params == NULL) || (buf == NULL) || (buf_size == NULL)) {
		return (RDR_ERROR);
	}

	/*
	 * Determine the size of the locale string
	 */
	if (params->locale_str != NULL) {
		locale_str_len = strlen(params->locale_str) + 1;
	} else {
		locale_str_len = 0;
	}

	/*
	 * Collect size info specific to the ses_req request message
	 * and allocate a buffer
	 */
	*buf_size = sizeof (rdr_ses_req_t);
	*buf_size += locale_str_len;

	*buf = (char *)malloc(*buf_size);
	if (*buf == NULL) {
		return (RDR_MEM_ALLOC);
	}

	/*
	 * Set fixed locale size label by name
	 */
	ses_req.locale_size = locale_str_len;

	/*
	 * Set variable information using memcpy
	 */
	bufptr = *buf;

	(void) memcpy(bufptr, &ses_req, sizeof (rdr_ses_req_t));
	bufptr += sizeof (rdr_ses_req_t);

	if (params->locale_str != NULL) {
		(void) memcpy(bufptr, params->locale_str, locale_str_len);
		bufptr += locale_str_len;
	}

	return (RDR_OK);
}


/*
 * unpack_ses_req_request:
 *
 * Handle unpacking a session request request message.
 */
static int
unpack_ses_req_request(ses_req_params_t *params, const char *buf)
{
	char		*bufptr;
	rdr_ses_req_t	ses_req_data;


	if ((params == NULL) || (buf == NULL)) {
		return (RDR_ERROR);
	}

	bufptr = (char *)buf;
	(void) memcpy(&ses_req_data, bufptr, sizeof (rdr_ses_req_t));
	bufptr += sizeof (rdr_ses_req_t);

	/*
	 * handle getting the locale string
	 */
	if (get_string_from_buf(&(params->locale_str),
	    ses_req_data.locale_size, bufptr)) {
		return (RDR_ERROR);
	}

	return (RDR_OK);
}


/*
 * pack_ses_req_reply:
 *
 * Handle packing a session request reply message.
 */
static int
pack_ses_req_reply(ses_req_params_t *params, char **buf, int *buf_size)
{
	rdr_ses_req_reply_t	ses_req_reply_data;


	if ((params == NULL) || (buf == NULL) || (buf_size == NULL)) {
		return (RDR_ERROR);
	}

	/*
	 * Collect size info specific to the session request reply
	 * message and allocate a buffer
	 */
	*buf_size = sizeof (rdr_ses_req_reply_t);

	*buf = (char *)malloc(*buf_size);
	if (*buf == NULL) {
		return (RDR_MEM_ALLOC);
	}

	/*
	 * Set fixed session identifier
	 */
	ses_req_reply_data.session_id = params->session_id;

	/*
	 * Copy information using memcpy
	 */
	(void) memcpy(*buf, &ses_req_reply_data, sizeof (rdr_ses_req_reply_t));

	return (RDR_OK);
}


/*
 * unpack_ses_req_request:
 *
 * Handle unpacking a session request reply message.
 */
static int
unpack_ses_req_reply(ses_req_params_t *params, const char *buf)
{
	rdr_ses_req_reply_t	*ses_req_reply_datap;


	if ((params == NULL) || (buf == NULL)) {
		return (RDR_ERROR);
	}

	/* LINTED Pointer Cast Alignment Warning */
	ses_req_reply_datap = (rdr_ses_req_reply_t *)buf;

	/*
	 * copy out the session information
	 */
	params->session_id = ses_req_reply_datap->session_id;

	return (RDR_OK);
}


/*
 * pack_change_state_request:
 *
 * Handle packing a change state request message.
 */
static int
pack_change_state_request(change_state_params_t *params, char **buf,
    int *buf_size)
{
	int				i;
	char				*bufptr;
	rdr_change_state_t		change_state_data;
	rdr_variable_message_info_t	var_msg_info;


	if ((params == NULL) || (buf == NULL) || (buf_size == NULL)) {
		return (RDR_ERROR);
	}

	(void) memset(&var_msg_info, 0, sizeof (rdr_variable_message_info_t));

	/*
	 * Set variable length fields and make a call to partially
	 * pack it.
	 */
	if (pack_ap_ids(params->num_ap_ids, params->ap_ids, &var_msg_info)) {
		cleanup_variable_ap_id_info(&var_msg_info);
		return (RDR_ERROR);
	}
	if (find_options_sizes(params->options, &var_msg_info)) {
		cleanup_variable_ap_id_info(&var_msg_info);
		return (RDR_ERROR);
	}

	/*
	 * Collect size info specific to the change_state request
	 * message and allocate a buffer
	 */
	*buf_size = sizeof (rdr_change_state_t);
	*buf_size += var_msg_info.ap_id_int_size;
	*buf_size += var_msg_info.ap_id_char_size;
	*buf_size += var_msg_info.options_strlen;
	*buf_size += var_msg_info.options_pad_sz;

	*buf = (char *)malloc(*buf_size);
	if (*buf == NULL) {
		cleanup_variable_ap_id_info(&var_msg_info);
		return (RDR_MEM_ALLOC);
	}

	/*
	 * Set fixed address labels by name
	 */
	change_state_data.num_ap_ids = params->num_ap_ids;
	change_state_data.ap_id_char_size = var_msg_info.ap_id_char_size;
	change_state_data.options_size = var_msg_info.options_strlen +
	    var_msg_info.options_pad_sz;

	if (params->confp != NULL) {
		change_state_data.confirm_callback_id =
		    (unsigned long)params->confp->confirm;
		change_state_data.confirm_appdata_ptr =
		    (unsigned long)params->confp->appdata_ptr;
	} else {
		change_state_data.confirm_callback_id = 0;
		change_state_data.confirm_appdata_ptr = 0;
	}
	if (params->msgp != NULL) {
		change_state_data.msg_callback_id =
		    (unsigned long)params->msgp->message_routine;
		change_state_data.msg_appdata_ptr =
		    (unsigned long)params->msgp->appdata_ptr;
	} else {
		change_state_data.msg_callback_id = 0;
		change_state_data.msg_appdata_ptr = 0;
	}

	change_state_data.flags = params->flags;
	change_state_data.timeval = params->timeval;
	change_state_data.state_change_cmd = params->state_change;
	if (params->errstring != NULL) {
		change_state_data.error_msg_ctl = RDR_GENERATE_ERR_MSGS;
	} else {
		change_state_data.error_msg_ctl = RDR_DONT_GENERATE_ERR_MSGS;
	}
	change_state_data.retries = params->retries;

	/*
	 * Set variable information using memcpy
	 */
	bufptr = *buf;

	(void) memcpy(bufptr, &change_state_data, sizeof (rdr_change_state_t));
	bufptr += sizeof (rdr_change_state_t);

	if (var_msg_info.ap_id_sizes != NULL) {
		(void) memcpy(bufptr, var_msg_info.ap_id_sizes,
		    var_msg_info.ap_id_int_size);
		bufptr += var_msg_info.ap_id_int_size;
	}

	if (var_msg_info.ap_id_chars != NULL) {
		(void) memcpy(bufptr, var_msg_info.ap_id_chars,
		    var_msg_info.ap_id_char_size);
		bufptr += var_msg_info.ap_id_char_size;
	}

	if (params->options != NULL) {
		(void) memcpy(bufptr, params->options,
		    var_msg_info.options_strlen);
		bufptr += var_msg_info.options_strlen;
		for (i = 0; i < var_msg_info.options_pad_sz; i++) {
			bufptr[i] = 0;
		}
		bufptr += var_msg_info.options_pad_sz;
	}

	cleanup_variable_ap_id_info(&var_msg_info);

	return (RDR_OK);
}


/*
 * unpack_change_state_request:
 *
 * Handle unpacking a change state request message.
 */
static int
unpack_change_state_request(change_state_params_t *params, const char *buf)
{
	char				*bufptr;
	rdr_variable_message_info_t	var_msg_info;
	rdr_change_state_t		change_state_data;


	if ((params == NULL) || (buf == NULL)) {
		return (RDR_ERROR);
	}

	(void) memset(&var_msg_info, 0, sizeof (rdr_variable_message_info_t));

	bufptr = (char *)buf;
	(void) memcpy(&change_state_data, bufptr, sizeof (rdr_change_state_t));
	bufptr += sizeof (rdr_change_state_t);

	/*
	 * handle getting the ap_ids
	 */
	var_msg_info.ap_id_char_size = change_state_data.ap_id_char_size;
	if (get_ap_ids_from_buf((char ***)&(params->ap_ids),
	    change_state_data.num_ap_ids, &var_msg_info, bufptr)) {
		return (RDR_ERROR);
	}
	bufptr += var_msg_info.ap_id_int_size;
	bufptr += var_msg_info.ap_id_char_size;

	/*
	 * handle getting the options
	 */
	if (get_string_from_buf(&(params->options),
	    change_state_data.options_size, bufptr)) {
		return (RDR_ERROR);
	}
	bufptr += change_state_data.options_size;

	/*
	 * Set fixed address labels by name
	 */
	params->state_change = (cfga_cmd_t)change_state_data.state_change_cmd;
	params->num_ap_ids = change_state_data.num_ap_ids;

	params->confp = (struct cfga_confirm *)
	    malloc(sizeof (struct cfga_confirm));
	if (params->confp == NULL) {
		return (RDR_MEM_ALLOC);
	}

	/* set params->confp->confirm using memcpy */
	(void) memcpy((void*)params->confp,
	    &(change_state_data.confirm_callback_id), sizeof (unsigned long));
	params->confp->appdata_ptr =
	    (void*)change_state_data.confirm_appdata_ptr;

	params->msgp = (struct cfga_msg *)malloc(sizeof (struct cfga_msg));
	if (params->msgp == NULL) {
		return (RDR_MEM_ALLOC);
	}

	/* set params->msgp->message_routine using memcpy */
	(void) memcpy((void*)params->msgp,
	    &(change_state_data.msg_callback_id), sizeof (unsigned long));
	params->msgp->appdata_ptr =
	    (void*)change_state_data.msg_appdata_ptr;

	if (change_state_data.error_msg_ctl == RDR_GENERATE_ERR_MSGS) {
		params->errstring = (char **)malloc(sizeof (char *));
		if (params->errstring == NULL) {
			return (RDR_MEM_ALLOC);
		}
		*(params->errstring) = NULL;
	} else {	/* error_msg_ctl == RDR_DONT_GENERATE_ERR_MSGS */
		params->errstring = NULL;
	}
	params->flags = change_state_data.flags;
	params->timeval = change_state_data.timeval;
	params->retries = change_state_data.retries;

	return (RDR_OK);
}


/*
 * pack_change_state_reply:
 *
 * Handle packing a change state reply message.
 */
static int
pack_change_state_reply(change_state_params_t *params, char **buf,
    int *buf_size)
{
	int				i;
	char				*bufptr;
	rdr_change_state_reply_t	change_state_data;
	rdr_variable_message_info_t	var_msg_info;


	(void) memset(&var_msg_info, 0, sizeof (rdr_variable_message_info_t));

	if ((params == NULL) || (buf == NULL) || (buf_size == NULL)) {
		return (RDR_ERROR);
	}

	/*
	 * Set variable length fields (size info)
	 */
	if (find_errstring_sizes(params->errstring, &var_msg_info)) {
		return (RDR_ERROR);
	}

	/*
	 * Collect size info specific to the change_state reply
	 * message and allocate a buffer
	 */
	*buf_size = sizeof (rdr_change_state_reply_t);
	*buf_size += var_msg_info.errstring_strlen;
	*buf_size += var_msg_info.errstring_pad_sz;

	*buf = (char *)malloc(*buf_size);
	if (*buf == NULL) {
		return (RDR_MEM_ALLOC);
	}

	/*
	 * Set fixed address labels by name
	 */
	change_state_data.errstring_size = var_msg_info.errstring_strlen +
	    var_msg_info.errstring_pad_sz;

	/*
	 * Set variable information using memcpy
	 */
	bufptr = *buf;

	(void) memcpy(bufptr, &change_state_data,
	    sizeof (rdr_change_state_reply_t));
	bufptr += sizeof (rdr_change_state_reply_t);

	if ((params->errstring != NULL) && (*(params->errstring) != NULL)) {
		(void) memcpy(bufptr, *(params->errstring),
		    var_msg_info.errstring_strlen);
		bufptr += var_msg_info.errstring_strlen;
		for (i = 0; i < var_msg_info.errstring_pad_sz; i++) {
			bufptr[i] = 0;
		}
		bufptr += var_msg_info.errstring_pad_sz;
	}

	return (RDR_OK);
}


/*
 * unpack_change_state_reply:
 *
 * Handle unpacking a change state reply message.
 */
static int
unpack_change_state_reply(change_state_params_t *params, const char *buf)
{
	char				*bufptr;
	rdr_change_state_reply_t	change_state_data;

	if ((params == NULL) || (buf == NULL)) {
		return (RDR_ERROR);
	}

	bufptr = (char *)buf;
	(void) memcpy(&change_state_data, bufptr,
	    sizeof (rdr_change_state_reply_t));
	bufptr += sizeof (rdr_change_state_reply_t);

	/*
	 * handle getting the errstring
	 */
	params->errstring = (char **)malloc(sizeof (char *));
	if (params->errstring == NULL) {
		return (RDR_MEM_ALLOC);
	}
	if (get_string_from_buf(params->errstring,
	    change_state_data.errstring_size, bufptr)) {
		return (RDR_ERROR);
	}
	bufptr += change_state_data.errstring_size;

	return (RDR_OK);
}


/*
 * pack_private_func_request:
 *
 * Handle packing a private function request message.
 */
static int
pack_private_func_request(private_func_params_t *params, char **buf,
    int *buf_size)
{
	int				i;
	char				*bufptr;
	rdr_private_func_t		private_func_data;
	rdr_variable_message_info_t	var_msg_info;


	if ((params == NULL) || (buf == NULL) || (buf_size == NULL)) {
		return (RDR_ERROR);
	}

	(void) memset(&var_msg_info, 0, sizeof (rdr_variable_message_info_t));

	/*
	 * Set variable length fields and make a call to partially
	 * pack it.
	 */
	if (pack_ap_ids(params->num_ap_ids, params->ap_ids, &var_msg_info)) {
		cleanup_variable_ap_id_info(&var_msg_info);
		return (RDR_ERROR);
	}
	if (find_options_sizes(params->options, &var_msg_info)) {
		cleanup_variable_ap_id_info(&var_msg_info);
		return (RDR_ERROR);
	}
	if (find_function_sizes(params->function, &var_msg_info)) {
		cleanup_variable_ap_id_info(&var_msg_info);
		return (RDR_ERROR);
	}

	/*
	 * Collect size info specific to the private_func request
	 * message and allocate a buffer
	 */
	*buf_size = sizeof (rdr_private_func_t);
	*buf_size += var_msg_info.ap_id_int_size;
	*buf_size += var_msg_info.ap_id_char_size;
	*buf_size += var_msg_info.options_strlen;
	*buf_size += var_msg_info.options_pad_sz;
	*buf_size += var_msg_info.function_strlen;
	*buf_size += var_msg_info.function_pad_sz;

	*buf = (char *)malloc(*buf_size);
	if (*buf == NULL) {
		cleanup_variable_ap_id_info(&var_msg_info);
		return (RDR_MEM_ALLOC);
	}

	/*
	 * Set fixed address labels by name
	 */
	private_func_data.num_ap_ids = params->num_ap_ids;
	private_func_data.ap_id_char_size = var_msg_info.ap_id_char_size;
	private_func_data.options_size = var_msg_info.options_strlen +
	    var_msg_info.options_pad_sz;
	private_func_data.function_size = var_msg_info.function_strlen +
	    var_msg_info.function_pad_sz;

	if (params->confp != NULL) {
		private_func_data.confirm_callback_id =
		    (unsigned long)params->confp->confirm;
		private_func_data.confirm_appdata_ptr =
		    (unsigned long)params->confp->appdata_ptr;
	} else {
		private_func_data.confirm_callback_id = 0;
		private_func_data.confirm_appdata_ptr = 0;
	}
	if (params->msgp != NULL) {
		private_func_data.msg_callback_id =
		    (unsigned long)params->msgp->message_routine;
		private_func_data.msg_appdata_ptr =
		    (unsigned long)params->msgp->appdata_ptr;
	} else {
		private_func_data.msg_callback_id = 0;
		private_func_data.msg_appdata_ptr = 0;
	}

	private_func_data.flags = params->flags;

	if (params->errstring != NULL) {
		private_func_data.error_msg_ctl = RDR_GENERATE_ERR_MSGS;
	} else {
		private_func_data.error_msg_ctl = RDR_DONT_GENERATE_ERR_MSGS;
	}

	/*
	 * Set variable information using memcpy
	 */
	bufptr = *buf;

	(void) memcpy(bufptr, &private_func_data, sizeof (rdr_private_func_t));
	bufptr += sizeof (rdr_private_func_t);

	if (var_msg_info.ap_id_sizes != NULL) {
		(void) memcpy(bufptr, var_msg_info.ap_id_sizes,
		    var_msg_info.ap_id_int_size);
		bufptr += var_msg_info.ap_id_int_size;
	}

	if (var_msg_info.ap_id_chars != NULL) {
		(void) memcpy(bufptr, var_msg_info.ap_id_chars,
		    var_msg_info.ap_id_char_size);
		bufptr += var_msg_info.ap_id_char_size;
	}

	if (params->options != NULL) {
		(void) memcpy(bufptr, params->options,
		    var_msg_info.options_strlen);
		bufptr += var_msg_info.options_strlen;
		for (i = 0; i < var_msg_info.options_pad_sz; i++) {
			bufptr[i] = 0;
		}
		bufptr += var_msg_info.options_pad_sz;
	}

	if (params->function != NULL) {
		(void) memcpy(bufptr, params->function,
		    var_msg_info.function_strlen);
		bufptr += var_msg_info.function_strlen;
		for (i = 0; i < var_msg_info.function_pad_sz; i++) {
			bufptr[i] = 0;
		}
		bufptr += var_msg_info.function_pad_sz;
	}

	cleanup_variable_ap_id_info(&var_msg_info);

	return (RDR_OK);
}


/*
 * unpack_private_func_request:
 *
 * Handle unpacking a private function request message.
 */
static int
unpack_private_func_request(private_func_params_t *params, const char *buf)
{
	char				*bufptr;
	rdr_variable_message_info_t	var_msg_info;
	rdr_private_func_t		private_func_data;


	(void) memset(&var_msg_info, 0, sizeof (rdr_variable_message_info_t));

	if ((params == NULL) || (buf == NULL)) {
		return (RDR_ERROR);
	}

	bufptr = (char *)buf;
	(void) memcpy(&private_func_data, bufptr, sizeof (rdr_private_func_t));
	bufptr += sizeof (rdr_private_func_t);

	/*
	 * handle getting the ap_ids
	 */
	var_msg_info.ap_id_char_size = private_func_data.ap_id_char_size;
	if (get_ap_ids_from_buf((char ***)&(params->ap_ids),
	    private_func_data.num_ap_ids, &var_msg_info, bufptr)) {
		return (RDR_ERROR);
	}
	bufptr += var_msg_info.ap_id_int_size;
	bufptr += var_msg_info.ap_id_char_size;

	/*
	 * handle getting the options and function
	 */
	if (get_string_from_buf(&(params->options),
	    private_func_data.options_size, bufptr)) {
		return (RDR_ERROR);
	}
	bufptr += private_func_data.options_size;

	if (get_string_from_buf(&(params->function),
	    private_func_data.function_size, bufptr)) {
		return (RDR_ERROR);
	}
	bufptr += private_func_data.function_size;

	/*
	 * Set fixed address labels by name
	 */
	params->num_ap_ids = private_func_data.num_ap_ids;

	params->confp = (struct cfga_confirm *)
	    malloc(sizeof (struct cfga_confirm));
	if (params->confp == NULL) {
		return (RDR_MEM_ALLOC);
	}

	/* set params->confp->confirm using memcpy */
	(void) memcpy((void*)params->confp,
	    &(private_func_data.confirm_callback_id), sizeof (unsigned long));
	params->confp->appdata_ptr =
	    (void*)private_func_data.confirm_appdata_ptr;

	params->msgp = (struct cfga_msg *)malloc(sizeof (struct cfga_msg));
	if (params->msgp == NULL) {
		return (RDR_MEM_ALLOC);
	}

	/* set params->msgp->message_routine using memcpy */
	(void) memcpy((void*)params->msgp,
	    &(private_func_data.msg_callback_id), sizeof (unsigned long));
	params->msgp->appdata_ptr =
	    (void*)private_func_data.msg_appdata_ptr;

	if (private_func_data.error_msg_ctl == RDR_GENERATE_ERR_MSGS) {
		params->errstring = (char **)malloc(sizeof (char *));
		if (params->errstring == NULL) {
			return (RDR_MEM_ALLOC);
		}
		*(params->errstring) = NULL;
	} else {	/* error_msg_ctl == RDR_DONT_GENERATE_ERR_MSGS */
		params->errstring = NULL;
	}
	params->flags = private_func_data.flags;

	return (RDR_OK);
}


/*
 * pack_private_func_reply:
 *
 * Handle packing a private function reply message.
 */
static int
pack_private_func_reply(private_func_params_t *params, char **buf,
    int *buf_size)
{
	int				i;
	char				*bufptr;
	rdr_private_func_reply_t	private_func_data;
	rdr_variable_message_info_t	var_msg_info;


	(void) memset(&var_msg_info, 0, sizeof (rdr_variable_message_info_t));

	if ((params == NULL) || (buf == NULL) || (buf_size == NULL)) {
		return (RDR_ERROR);
	}

	/*
	 * Set variable length fields (size info)
	 */
	if (find_errstring_sizes(params->errstring, &var_msg_info)) {
		return (RDR_ERROR);
	}

	/*
	 * Collect size info specific to the private_func reply
	 * message and allocate a buffer
	 */
	*buf_size = sizeof (rdr_private_func_reply_t);
	*buf_size += var_msg_info.errstring_strlen;
	*buf_size += var_msg_info.errstring_pad_sz;

	*buf = (char *)malloc(*buf_size);
	if (*buf == NULL) {
		return (RDR_MEM_ALLOC);
	}

	/*
	 * Set fixed address labels by name
	 */
	private_func_data.errstring_size = var_msg_info.errstring_strlen +
	    var_msg_info.errstring_pad_sz;

	/*
	 * Set variable information using memcpy
	 */
	bufptr = *buf;

	(void) memcpy(bufptr, &private_func_data,
	    sizeof (rdr_private_func_reply_t));
	bufptr += sizeof (rdr_private_func_reply_t);
	if ((params->errstring != NULL) && (*(params->errstring) != NULL)) {
		(void) memcpy(bufptr, *(params->errstring),
		    var_msg_info.errstring_strlen);
		bufptr += var_msg_info.errstring_strlen;
		for (i = 0; i < var_msg_info.errstring_pad_sz; i++) {
			bufptr[i] = 0;
		}
		bufptr += var_msg_info.errstring_pad_sz;
	}

	return (RDR_OK);
}


/*
 * unpack_private_func_reply:
 *
 * Handle unpacking a private function reply message.
 */
static int
unpack_private_func_reply(private_func_params_t *params, const char *buf)
{
	char				*bufptr;
	rdr_private_func_reply_t	private_func_data;

	if ((params == NULL) || (buf == NULL)) {
		return (RDR_ERROR);
	}

	bufptr = (char *)buf;
	(void) memcpy(&private_func_data, bufptr,
	    sizeof (rdr_private_func_reply_t));
	bufptr += sizeof (rdr_private_func_reply_t);

	/*
	 * handle getting the errstring
	 */
	params->errstring = (char **)malloc(sizeof (char *));
	if (params->errstring == NULL) {
		return (RDR_MEM_ALLOC);
	}
	if (get_string_from_buf(params->errstring,
	    private_func_data.errstring_size, bufptr)) {
		return (RDR_ERROR);
	}
	bufptr += private_func_data.errstring_size;

	return (RDR_OK);
}


/*
 * pack_test_request:
 *
 * Handle packing a test request message.
 */
static int
pack_test_request(test_params_t *params, char **buf, int *buf_size)
{
	int				i;
	char				*bufptr;
	rdr_test_t			test_data;
	rdr_variable_message_info_t	var_msg_info;


	if ((params == NULL) || (buf == NULL) || (buf_size == NULL)) {
		return (RDR_ERROR);
	}

	(void) memset(&var_msg_info, 0, sizeof (rdr_variable_message_info_t));

	/*
	 * Set variable length fields and make a call to partially
	 * pack it.
	 */
	if (pack_ap_ids(params->num_ap_ids, params->ap_ids, &var_msg_info)) {
		cleanup_variable_ap_id_info(&var_msg_info);
		return (RDR_ERROR);
	}
	if (find_options_sizes(params->options, &var_msg_info)) {
		cleanup_variable_ap_id_info(&var_msg_info);
		return (RDR_ERROR);
	}

	/*
	 * Collect size info specific to the test request
	 * message and allocate a buffer
	 */
	*buf_size = sizeof (rdr_test_t);
	*buf_size += var_msg_info.ap_id_int_size;
	*buf_size += var_msg_info.ap_id_char_size;
	*buf_size += var_msg_info.options_strlen;
	*buf_size += var_msg_info.options_pad_sz;

	*buf = (char *)malloc(*buf_size);
	if (*buf == NULL) {
		cleanup_variable_ap_id_info(&var_msg_info);
		return (RDR_MEM_ALLOC);
	}

	/*
	 * Set fixed address labels by name
	 */
	test_data.num_ap_ids = params->num_ap_ids;
	test_data.ap_id_char_size = var_msg_info.ap_id_char_size;
	test_data.options_size = var_msg_info.options_strlen +
	    var_msg_info.options_pad_sz;

	if (params->msgp != NULL) {
		test_data.msg_callback_id =
		    (unsigned long)params->msgp->message_routine;
		test_data.msg_appdata_ptr =
		    (unsigned long)params->msgp->appdata_ptr;
	} else {
		test_data.msg_callback_id = 0;
		test_data.msg_appdata_ptr = 0;
	}

	test_data.flags = params->flags;

	if (params->errstring != NULL) {
		test_data.error_msg_ctl = RDR_GENERATE_ERR_MSGS;
	} else {
		test_data.error_msg_ctl = RDR_DONT_GENERATE_ERR_MSGS;
	}

	/*
	 * Set variable information using memcpy
	 */
	bufptr = *buf;

	(void) memcpy(bufptr, &test_data, sizeof (rdr_test_t));
	bufptr += sizeof (rdr_test_t);

	if (var_msg_info.ap_id_sizes != NULL) {
		(void) memcpy(bufptr, var_msg_info.ap_id_sizes,
		    var_msg_info.ap_id_int_size);
		bufptr += var_msg_info.ap_id_int_size;
	}

	if (var_msg_info.ap_id_chars != NULL) {
		(void) memcpy(bufptr, var_msg_info.ap_id_chars,
		    var_msg_info.ap_id_char_size);
		bufptr += var_msg_info.ap_id_char_size;
	}

	if (params->options != NULL) {
		(void) memcpy(bufptr, params->options,
		    var_msg_info.options_strlen);
		bufptr += var_msg_info.options_strlen;
		for (i = 0; i < var_msg_info.options_pad_sz; i++) {
			bufptr[i] = 0;
		}
		bufptr += var_msg_info.options_pad_sz;
	}

	cleanup_variable_ap_id_info(&var_msg_info);

	return (RDR_OK);
}


/*
 * unpack_test_request:
 *
 * Handle unpacking a test request message.
 */
static int
unpack_test_request(test_params_t *params, const char *buf)
{
	char				*bufptr;
	rdr_variable_message_info_t	var_msg_info;
	rdr_test_t			test_data;


	if ((params == NULL) || (buf == NULL)) {
		return (RDR_ERROR);
	}

	(void) memset(&var_msg_info, 0, sizeof (rdr_variable_message_info_t));

	bufptr = (char *)buf;
	(void) memcpy(&test_data, bufptr, sizeof (rdr_test_t));
	bufptr += sizeof (rdr_test_t);

	/*
	 * handle getting the ap_ids
	 */
	var_msg_info.ap_id_char_size = test_data.ap_id_char_size;
	if (get_ap_ids_from_buf((char ***)&(params->ap_ids),
	    test_data.num_ap_ids, &var_msg_info, bufptr)) {
		return (RDR_ERROR);
	}
	bufptr += var_msg_info.ap_id_int_size;
	bufptr += var_msg_info.ap_id_char_size;

	/*
	 * handle getting the options
	 */
	if (get_string_from_buf(&(params->options),
	    test_data.options_size, bufptr)) {
		return (RDR_ERROR);
	}
	bufptr += test_data.options_size;

	/*
	 * Set fixed address labels by name
	 */
	params->num_ap_ids = test_data.num_ap_ids;

	params->msgp = (struct cfga_msg *)malloc(sizeof (struct cfga_msg));
	if (params->msgp == NULL) {
		return (RDR_MEM_ALLOC);
	}

	/* set params->msgp->message_routine using memcpy */
	(void) memcpy((void*)params->msgp,
	    &(test_data.msg_callback_id), sizeof (unsigned long));
	params->msgp->appdata_ptr =
	    (void*)test_data.msg_appdata_ptr;

	if (test_data.error_msg_ctl == RDR_GENERATE_ERR_MSGS) {
		params->errstring = (char **)malloc(sizeof (char *));
		if (params->errstring == NULL) {
			return (RDR_MEM_ALLOC);
		}
		*(params->errstring) = NULL;
	} else {	/* error_msg_ctl == RDR_DONT_GENERATE_ERR_MSGS */
		params->errstring = NULL;
	}
	params->flags = test_data.flags;

	return (RDR_OK);
}


/*
 * pack_test_reply:
 *
 * Handle packing a test reply message.
 */
static int
pack_test_reply(test_params_t *params, char **buf, int *buf_size)
{
	int				i;
	char				*bufptr;
	rdr_test_reply_t		test_data;
	rdr_variable_message_info_t	var_msg_info;


	if ((params == NULL) || (buf == NULL) || (buf_size == NULL)) {
		return (RDR_ERROR);
	}

	(void) memset(&var_msg_info, 0, sizeof (rdr_variable_message_info_t));

	/*
	 * Set variable length fields (size info)
	 */
	if (find_errstring_sizes(params->errstring, &var_msg_info)) {
		return (RDR_ERROR);
	}

	/*
	 * Collect size info specific to the test reply
	 * message and allocate a buffer
	 */
	*buf_size = sizeof (rdr_test_reply_t);
	*buf_size += var_msg_info.errstring_strlen;
	*buf_size += var_msg_info.errstring_pad_sz;

	*buf = (char *)malloc(*buf_size);
	if (*buf == NULL) {
		return (RDR_MEM_ALLOC);
	}

	/*
	 * Set fixed address labels by name
	 */
	test_data.errstring_size = var_msg_info.errstring_strlen +
	    var_msg_info.errstring_pad_sz;

	/*
	 * Set variable information using memcpy
	 */
	bufptr = *buf;

	(void) memcpy(bufptr, &test_data, sizeof (rdr_test_reply_t));
	bufptr += sizeof (rdr_test_reply_t);
	if ((params->errstring != NULL) && (*(params->errstring) != NULL)) {
		(void) memcpy(bufptr, *(params->errstring),
		    var_msg_info.errstring_strlen);
		bufptr += var_msg_info.errstring_strlen;
		for (i = 0; i < var_msg_info.errstring_pad_sz; i++) {
			bufptr[i] = 0;
		}
		bufptr += var_msg_info.errstring_pad_sz;
	}

	return (RDR_OK);
}


/*
 * unpack_test_reply:
 *
 * Handle unpacking a test reply message.
 */
static int
unpack_test_reply(test_params_t *params, const char *buf)
{
	char			*bufptr;
	rdr_test_reply_t	test_data;


	if ((params == NULL) || (buf == NULL)) {
		return (RDR_ERROR);
	}

	bufptr = (char *)buf;
	(void) memcpy(&test_data, bufptr, sizeof (rdr_test_reply_t));
	bufptr += sizeof (rdr_test_reply_t);

	/*
	 * handle getting the errstring
	 */
	params->errstring = (char **)malloc(sizeof (char *));
	if (params->errstring == NULL) {
		return (RDR_MEM_ALLOC);
	}
	if (get_string_from_buf(params->errstring,
	    test_data.errstring_size, bufptr)) {
		return (RDR_ERROR);
	}
	bufptr += test_data.errstring_size;

	return (RDR_OK);
}


/*
 * pack_list_ext_request:
 *
 * Handle packing a list request message.
 */
static int
pack_list_ext_request(list_ext_params_t *params, char **buf, int *buf_size)
{
	int				i;
	char				*bufptr;
	rdr_list_ext_t			list_ext_data;
	rdr_variable_message_info_t	var_msg_info;


	if ((params == NULL) || (buf == NULL) || (buf_size == NULL)) {
		return (RDR_ERROR);
	}

	(void) memset(&var_msg_info, 0, sizeof (rdr_variable_message_info_t));

	/*
	 * Set variable length fields and make a call to partially
	 * pack it.
	 */
	if (pack_ap_ids(params->num_ap_ids, params->ap_ids, &var_msg_info)) {
		cleanup_variable_ap_id_info(&var_msg_info);
		return (RDR_ERROR);
	}
	if (find_options_sizes(params->options, &var_msg_info)) {
		cleanup_variable_ap_id_info(&var_msg_info);
		return (RDR_ERROR);
	}
	if (find_listopts_sizes(params->listopts, &var_msg_info)) {
		cleanup_variable_ap_id_info(&var_msg_info);
		return (RDR_ERROR);
	}


	/*
	 * Collect size info specific to the list_ext request
	 * message and allocate a buffer
	 */
	*buf_size = sizeof (rdr_list_ext_t);
	*buf_size += var_msg_info.ap_id_int_size;
	*buf_size += var_msg_info.ap_id_char_size;
	*buf_size += var_msg_info.options_strlen;
	*buf_size += var_msg_info.options_pad_sz;
	*buf_size += var_msg_info.listopts_strlen;
	*buf_size += var_msg_info.listopts_pad_sz;

	*buf = (char *)malloc(*buf_size);
	if (*buf == NULL) {
		cleanup_variable_ap_id_info(&var_msg_info);
		return (RDR_MEM_ALLOC);
	}

	/*
	 * Set fixed address labels by name
	 */
	list_ext_data.num_ap_ids = params->num_ap_ids;
	list_ext_data.ap_id_char_size = var_msg_info.ap_id_char_size;
	list_ext_data.options_size = var_msg_info.options_strlen +
	    var_msg_info.options_pad_sz;
	list_ext_data.listopts_size = var_msg_info.listopts_strlen +
	    var_msg_info.listopts_pad_sz;
	if (params->errstring != NULL) {
		list_ext_data.error_msg_ctl = RDR_GENERATE_ERR_MSGS;
	} else {
		list_ext_data.error_msg_ctl = RDR_DONT_GENERATE_ERR_MSGS;
	}
	if ((params->num_ap_ids != 0) || (params->ap_ids != NULL)) {
		list_ext_data.list_msg_ctl = RDR_LIST_ONLY_PARAM_APS;
	} else {
		list_ext_data.list_msg_ctl = RDR_LIST_ALL_APS;
	}
	list_ext_data.flags = params->flags;
	list_ext_data.permissions = params->permissions;

	/*
	 * Set variable information using memcpy
	 */
	bufptr = *buf;

	(void) memcpy(bufptr, &list_ext_data, sizeof (rdr_list_ext_t));
	bufptr += sizeof (rdr_list_ext_t);

	if (var_msg_info.ap_id_sizes != NULL) {
		(void) memcpy(bufptr, var_msg_info.ap_id_sizes,
		    var_msg_info.ap_id_int_size);
		bufptr += var_msg_info.ap_id_int_size;
	}

	if (var_msg_info.ap_id_chars != NULL) {
		(void) memcpy(bufptr, var_msg_info.ap_id_chars,
		    var_msg_info.ap_id_char_size);
		bufptr += var_msg_info.ap_id_char_size;
	}

	if (params->options != NULL) {
		(void) memcpy(bufptr, params->options,
		    var_msg_info.options_strlen);
		bufptr += var_msg_info.options_strlen;
		for (i = 0; i < var_msg_info.options_pad_sz; i++) {
			bufptr[i] = 0;
		}
		bufptr += var_msg_info.options_pad_sz;
	}

	if (params->listopts != NULL) {
		(void) memcpy(bufptr, params->listopts,
		    var_msg_info.listopts_strlen);
		bufptr += var_msg_info.listopts_strlen;
		for (i = 0; i < var_msg_info.listopts_pad_sz; i++) {
			bufptr[i] = 0;
		}
		bufptr += var_msg_info.listopts_pad_sz;
	}

	cleanup_variable_ap_id_info(&var_msg_info);

	return (RDR_OK);
}


/*
 * unpack_list_ext_request:
 *
 * Handle unpacking a list request message.
 */
static int
unpack_list_ext_request(list_ext_params_t *params, const char *buf)
{
	char				*bufptr;
	rdr_variable_message_info_t	var_msg_info;
	rdr_list_ext_t			list_ext_data;


	if ((params == NULL) || (buf == NULL)) {
		return (RDR_ERROR);
	}

	(void) memset(&var_msg_info, 0, sizeof (rdr_variable_message_info_t));

	bufptr = (char *)buf;
	(void) memcpy(&list_ext_data, bufptr, sizeof (rdr_list_ext_t));
	bufptr += sizeof (rdr_list_ext_t);

	/*
	 * handle getting the ap_ids
	 */
	var_msg_info.ap_id_char_size = list_ext_data.ap_id_char_size;
	if (get_ap_ids_from_buf(&(params->ap_ids), list_ext_data.num_ap_ids,
	    &var_msg_info, bufptr)) {
		return (RDR_ERROR);
	}
	bufptr += var_msg_info.ap_id_int_size;
	bufptr += var_msg_info.ap_id_char_size;

	/*
	 * handle getting the options
	 */
	if (get_string_from_buf(&(params->options),
	    list_ext_data.options_size, bufptr)) {
		return (RDR_ERROR);
	}
	bufptr += list_ext_data.options_size;

	/*
	 * handle getting the listopts
	 */
	if (get_string_from_buf(&(params->listopts),
	    list_ext_data.listopts_size, bufptr)) {
		return (RDR_ERROR);
	}
	bufptr += list_ext_data.listopts_size;

	/*
	 * Set fixed address labels by name
	 */
	params->num_ap_ids = list_ext_data.num_ap_ids;

	params->ap_id_list = (rdr_list_t **)malloc(sizeof (rdr_list_t *));
	if (params->ap_id_list == NULL) {
		return (RDR_MEM_ALLOC);
	}
	*(params->ap_id_list) = NULL;

	params->nlist = (int *)malloc(sizeof (int));
	if (params->nlist == NULL) {
		return (RDR_MEM_ALLOC);
	}
	if (list_ext_data.error_msg_ctl == RDR_GENERATE_ERR_MSGS) {
		params->errstring = (char **)malloc(sizeof (char *));
		if (params->errstring == NULL) {
			return (RDR_MEM_ALLOC);
		}
		*(params->errstring) = NULL;
	} else {	/* error_msg_ctl == RDR_DONT_GENERATE_ERR_MSGS */
		params->errstring = NULL;
	}
	params->flags = list_ext_data.flags;
	params->permissions = list_ext_data.permissions;

	return (RDR_OK);
}


/*
 * pack_list_ext_reply:
 *
 * Handle packing a list reply message.
 */
static int
pack_list_ext_reply(list_ext_params_t *params, char **buf, int *buf_size)
{
	int				i;
	char				*bufptr;
	rdr_list_ext_reply_t		list_ext_data;
	rdr_variable_message_info_t	var_msg_info;
	int				list_data_size;


	(void) memset(&var_msg_info, 0, sizeof (rdr_variable_message_info_t));

	if ((params == NULL) || (buf == NULL) || (buf_size == NULL)) {
		return (RDR_ERROR);
	}

	/*
	 * Set variable length fields (size info)
	 */
	if (find_errstring_sizes(params->errstring, &var_msg_info)) {
		return (RDR_ERROR);
	}

	if (params->nlist == NULL) {
		list_data_size = 0;
	} else {
		list_data_size = *(params->nlist) * sizeof (rdr_list_t);
	}

	/*
	 * Collect size info specific to the list_ext reply
	 * message and allocate a buffer
	 */
	*buf_size = sizeof (rdr_list_ext_reply_t);
	*buf_size += list_data_size;
	*buf_size += var_msg_info.errstring_strlen;
	*buf_size += var_msg_info.errstring_pad_sz;

	*buf = (char *)malloc(*buf_size);
	if (*buf == NULL) {
		return (RDR_MEM_ALLOC);
	}

	/*
	 * Set fixed address labels by name
	 */
	list_ext_data.num_ap_ids = (params->nlist) ? *(params->nlist) : 0;
	list_ext_data.errstring_size = var_msg_info.errstring_strlen +
	    var_msg_info.errstring_pad_sz;

	/*
	 * Set variable information using memcpy
	 */
	bufptr = *buf;

	(void) memcpy(bufptr, &list_ext_data, sizeof (rdr_list_ext_reply_t));
	bufptr += sizeof (rdr_list_ext_reply_t);

	if ((params->ap_id_list != NULL) && (*(params->ap_id_list) != NULL)) {
		(void) memcpy(bufptr, *(params->ap_id_list), list_data_size);
		bufptr += list_data_size;
	} else if (list_data_size) {
		/*
		 * Something is out of sync. We were expecting
		 * some data to copy, but instead we found a
		 * NULL pointer.
		 */
		(void) free((void *)*buf);
		*buf = NULL;
		return (RDR_ERROR);
	}

	if ((params->errstring != NULL) && (*(params->errstring) != NULL)) {
		(void) memcpy(bufptr, *(params->errstring),
		    var_msg_info.errstring_strlen);
		bufptr += var_msg_info.errstring_strlen;
		for (i = 0; i < var_msg_info.errstring_pad_sz; i++) {
			bufptr[i] = 0;
		}
		bufptr += var_msg_info.errstring_pad_sz;
	}

	return (RDR_OK);
}


/*
 * unpack_list_ext_reply:
 *
 * Handle unpacking a list reply message.
 */
static int
unpack_list_ext_reply(list_ext_params_t *params, const char *buf)
{
	int			list_data_size;
	char			*bufptr;
	rdr_list_ext_reply_t	list_ext_data;


	if ((params == NULL) || (buf == NULL)) {
		return (RDR_ERROR);
	}

	bufptr = (char *)buf;
	(void) memcpy(&list_ext_data, bufptr, sizeof (rdr_list_ext_reply_t));
	bufptr += sizeof (rdr_list_ext_reply_t);

	/*
	 * handle getting the ap_id rcfga_list_data_t's.
	 */
	if (list_ext_data.num_ap_ids > 0) {
		params->nlist = (int *)malloc(sizeof (int));
		if (params->nlist == NULL) {
			return (RDR_MEM_ALLOC);
		}
		*(params->nlist) = list_ext_data.num_ap_ids;
		params->ap_id_list = (rdr_list_t **)
		    malloc(sizeof (rdr_list_t *));
		if (params->ap_id_list == NULL) {
			return (RDR_MEM_ALLOC);
		}
		*(params->ap_id_list) = (rdr_list_t *)
		    malloc(sizeof (rdr_list_t) * list_ext_data.num_ap_ids);
		if (*(params->ap_id_list) == NULL) {
			return (RDR_MEM_ALLOC);
		}
		list_data_size = list_ext_data.num_ap_ids * sizeof (rdr_list_t);
		(void) memcpy(*(params->ap_id_list), bufptr, list_data_size);
		bufptr += list_data_size;
	}

	/*
	 * handle getting the errstring
	 */
	params->errstring = (char **)malloc(sizeof (char *));
	if (params->errstring == NULL) {
		return (RDR_MEM_ALLOC);
	}
	if (get_string_from_buf(params->errstring,
	    list_ext_data.errstring_size, bufptr)) {
		return (RDR_ERROR);
	}
	bufptr += list_ext_data.errstring_size;

	return (RDR_OK);
}


/*
 * pack_help_request:
 *
 * Handle packing a help request message.
 */
static int
pack_help_request(help_params_t *params, char **buf, int *buf_size)
{
	int				i;
	char				*bufptr;
	rdr_help_t			help_data;
	rdr_variable_message_info_t	var_msg_info;


	(void) memset(&var_msg_info, 0, sizeof (rdr_variable_message_info_t));

	if ((params == NULL) || (buf == NULL) || (buf_size == NULL)) {
		return (RDR_ERROR);
	}

	/*
	 * Set variable length fields and make a call to partially
	 * pack it.
	 */
	if (pack_ap_ids(params->num_ap_ids, params->ap_ids, &var_msg_info)) {
		cleanup_variable_ap_id_info(&var_msg_info);
		return (RDR_ERROR);
	}
	if (find_options_sizes(params->options, &var_msg_info)) {
		cleanup_variable_ap_id_info(&var_msg_info);
		return (RDR_ERROR);
	}

	/*
	 * Collect size info specific to the help request message and
	 * and allocate a buffer
	 */
	*buf_size = sizeof (rdr_help_t);
	*buf_size += var_msg_info.ap_id_int_size;
	*buf_size += var_msg_info.ap_id_char_size;
	*buf_size += var_msg_info.options_strlen;
	*buf_size += var_msg_info.options_pad_sz;

	*buf = (char *)malloc(*buf_size);
	if (*buf == NULL) {
		cleanup_variable_ap_id_info(&var_msg_info);
		return (RDR_MEM_ALLOC);
	}

	/*
	 * Set fixed address labels by name
	 */
	help_data.num_ap_ids = params->num_ap_ids;
	help_data.ap_id_char_size = var_msg_info.ap_id_char_size;
	help_data.options_size = var_msg_info.options_strlen +
	    var_msg_info.options_pad_sz;

	if (params->msgp != NULL) {
		help_data.msg_callback_id =
		    (unsigned long)params->msgp->message_routine;
		help_data.msg_appdata_ptr =
		    (unsigned long)params->msgp->appdata_ptr;
	} else {
		help_data.msg_callback_id = 0;
		help_data.msg_appdata_ptr = 0;
	}

	help_data.flags = params->flags;

	/*
	 * Set variable information using memcpy
	 */
	bufptr = *buf;

	(void) memcpy(bufptr, &help_data, sizeof (rdr_help_t));
	bufptr += sizeof (rdr_help_t);

	if (var_msg_info.ap_id_sizes != NULL) {
		(void) memcpy(bufptr, var_msg_info.ap_id_sizes,
		    var_msg_info.ap_id_int_size);
		bufptr += var_msg_info.ap_id_int_size;
	}

	if (var_msg_info.ap_id_chars != NULL) {
		(void) memcpy(bufptr, var_msg_info.ap_id_chars,
		    var_msg_info.ap_id_char_size);
		bufptr += var_msg_info.ap_id_char_size;
	}

	if (params->options != NULL) {
		(void) memcpy(bufptr, params->options,
		    var_msg_info.options_strlen);
		bufptr += var_msg_info.options_strlen;
		for (i = 0; i < var_msg_info.options_pad_sz; i++) {
			bufptr[i] = 0;
		}
		bufptr += var_msg_info.options_pad_sz;
	}

	cleanup_variable_ap_id_info(&var_msg_info);

	return (RDR_OK);
}


/*
 * unpack_help_request:
 *
 * Handle unpacking a help request message.
 */
static int
unpack_help_request(help_params_t *params, const char *buf)
{
	char				*bufptr;
	rdr_variable_message_info_t	var_msg_info;
	rdr_help_t			help_data;


	if ((params == NULL) || (buf == NULL)) {
		return (RDR_ERROR);
	}

	(void) memset(&var_msg_info, 0, sizeof (rdr_variable_message_info_t));

	bufptr = (char *)buf;
	(void) memcpy(&help_data, bufptr, sizeof (rdr_help_t));
	bufptr += sizeof (rdr_help_t);

	/*
	 * handle getting the ap_ids
	 */
	var_msg_info.ap_id_char_size = help_data.ap_id_char_size;
	if (get_ap_ids_from_buf((char ***)&(params->ap_ids),
	    help_data.num_ap_ids, &var_msg_info, bufptr)) {
		return (RDR_ERROR);
	}
	bufptr += var_msg_info.ap_id_int_size;
	bufptr += var_msg_info.ap_id_char_size;

	/*
	 * handle getting the options
	 */
	if (get_string_from_buf(&(params->options),
	    help_data.options_size, bufptr)) {
		return (RDR_ERROR);
	}
	bufptr += help_data.options_size;

	/*
	 * Set fixed address labels by name
	 */
	params->num_ap_ids = help_data.num_ap_ids;

	params->msgp = (struct cfga_msg *)malloc(sizeof (struct cfga_msg));
	if (params->msgp == NULL) {
		return (RDR_MEM_ALLOC);
	}

	/* set params->msgp->message_routine using memcpy */
	(void) memcpy((void*)params->msgp, &(help_data.msg_callback_id),
	    sizeof (unsigned long));

	params->msgp->appdata_ptr = (void*)help_data.msg_appdata_ptr;
	params->flags = help_data.flags;

	return (RDR_OK);
}


/*
 * pack_ap_id_cmp_request:
 *
 * Handle packing an attachment point comparison request message.
 */
static int
pack_ap_id_cmp_request(ap_id_cmp_params_t *params, char **buf, int *buf_size)
{
	int			i;
	char			*bufptr;
	rdr_ap_id_cmp_t		ap_id_cmp_data;
	int			ap_id1_strlen;
	int			ap_id1_pad_sz;
	int			ap_id2_strlen;
	int			ap_id2_pad_sz;


	if ((params == NULL) || (buf == NULL) || (buf_size == NULL)) {
		return (RDR_ERROR);
	}

	/*
	 * Set variable length fields and make a call to partially
	 * pack it.
	 */
	if (params->ap_log_id1 != NULL) {
		ap_id1_strlen = strlen(params->ap_log_id1) + 1;
		ap_id1_pad_sz = RDR_ALIGN_64_BIT -
		    (ap_id1_strlen % RDR_ALIGN_64_BIT);
	} else {
		ap_id1_strlen = 0;
		ap_id1_pad_sz = 0;
	}

	if (params->ap_log_id2 != NULL) {
		ap_id2_strlen = strlen(params->ap_log_id2) + 1;
		ap_id2_pad_sz = RDR_ALIGN_64_BIT -
		    (ap_id2_strlen % RDR_ALIGN_64_BIT);
	} else {
		ap_id2_strlen = 0;
		ap_id2_pad_sz = 0;
	}

	/*
	 * Collect size info specific to the ap id compare request
	 * message and allocate a buffer
	 */
	*buf_size = sizeof (rdr_ap_id_cmp_t);
	*buf_size += ap_id1_strlen;
	*buf_size += ap_id1_pad_sz;
	*buf_size += ap_id2_strlen;
	*buf_size += ap_id2_pad_sz;

	*buf = (char *)malloc(*buf_size);
	if (*buf == NULL) {
		return (RDR_MEM_ALLOC);
	}

	/*
	 * Set fixed address labels by name
	 */
	ap_id_cmp_data.ap_id1_size = ap_id1_strlen + ap_id1_pad_sz;
	ap_id_cmp_data.ap_id2_size = ap_id2_strlen + ap_id2_pad_sz;


	/*
	 * Set variable information using memcpy
	 */
	bufptr = *buf;

	(void) memcpy(bufptr, &ap_id_cmp_data, sizeof (rdr_ap_id_cmp_t));
	bufptr += sizeof (rdr_ap_id_cmp_t);

	if (params->ap_log_id1 != NULL) {
		(void) memcpy(bufptr, params->ap_log_id1, ap_id1_strlen);
		bufptr += ap_id1_strlen;
		for (i = 0; i < ap_id1_pad_sz; i++) {
			bufptr[i] = 0;
		}
		bufptr += ap_id1_pad_sz;
	}

	if (params->ap_log_id2 != NULL) {
		(void) memcpy(bufptr, params->ap_log_id2, ap_id2_strlen);
		bufptr += ap_id2_strlen;
		for (i = 0; i < ap_id2_pad_sz; i++) {
			bufptr[i] = 0;
		}
		bufptr += ap_id2_pad_sz;
	}

	return (RDR_OK);
}


/*
 * unpack_ap_id_cmp_request:
 *
 * Handle unpacking an attachment point comparison request message.
 */
static int
unpack_ap_id_cmp_request(ap_id_cmp_params_t *params, const char *buf)
{
	char			*bufptr;
	rdr_ap_id_cmp_t		ap_id_cmp_data;


	if ((params == NULL) || (buf == NULL)) {
		return (RDR_ERROR);
	}

	bufptr = (char *)buf;
	(void) memcpy(&ap_id_cmp_data, bufptr, sizeof (rdr_ap_id_cmp_t));
	bufptr += sizeof (rdr_ap_id_cmp_t);

	/*
	 * handle getting the cmp ap ids
	 */
	if (get_string_from_buf(&(params->ap_log_id1),
	    ap_id_cmp_data.ap_id1_size, bufptr)) {
		return (RDR_ERROR);
	}
	bufptr += ap_id_cmp_data.ap_id1_size;

	if (get_string_from_buf(&(params->ap_log_id2),
	    ap_id_cmp_data.ap_id2_size, bufptr)) {
		return (RDR_ERROR);
	}
	bufptr += ap_id_cmp_data.ap_id2_size;

	return (RDR_OK);
}


/*
 * pack_abort_cmd_request:
 *
 * Handle packing an abort request message.
 */
static int
pack_abort_cmd_request(abort_cmd_params_t *params, char **buf, int *buf_size)
{
	rdr_abort_cmd_t		abort_cmd_data;


	if ((params == NULL) || (buf == NULL) || (buf_size == NULL)) {
		return (RDR_ERROR);
	}

	/*
	 * Collect size info specific to the abort cmd request
	 * message and allocate a buffer
	 */
	*buf_size = sizeof (rdr_abort_cmd_t);

	*buf = (char *)malloc(*buf_size);
	if (*buf == NULL) {
		return (RDR_MEM_ALLOC);
	}

	/*
	 * Set fixed session identifier
	 */
	abort_cmd_data.session_id = params->session_id;

	/*
	 * Copy information using memcpy
	 */
	(void) memcpy(*buf, &abort_cmd_data, sizeof (rdr_abort_cmd_t));

	return (RDR_OK);
}


/*
 * unpack_abort_cmd_request:
 *
 * Handle unpacking an abort request message.
 */
static int
unpack_abort_cmd_request(abort_cmd_params_t *params, const char *buf)
{
	rdr_abort_cmd_t		*abort_cmd_datap;


	if ((params == NULL) || (buf == NULL)) {
		return (RDR_ERROR);
	}

	/* LINTED Pointer Cast Alignment Warning */
	abort_cmd_datap = (rdr_abort_cmd_t *)buf;

	/*
	 * copy out the session information
	 */

	params->session_id = abort_cmd_datap->session_id;

	return (RDR_OK);
}


/*
 * pack_confirm_request:
 *
 * Handle packing a confirm callback request.
 */
static int
pack_confirm_request(confirm_callback_params_t *params, char **buf,
    int *buf_size)
{
	int				i;
	char				*bufptr;
	rdr_confirm_callback_t		confirm_callback_data;
	int				message_strlen;
	int				message_pad_sz;


	if ((params == NULL) || (buf == NULL) || (buf_size == NULL)) {
		return (RDR_ERROR);
	}

	/*
	 * Set variable length fields and make a call to partially
	 * pack it.
	 */
	if (params->message != NULL) {
		message_strlen = strlen(params->message) + 1;
		message_pad_sz = RDR_ALIGN_64_BIT -
		    (message_strlen % RDR_ALIGN_64_BIT);
	} else {
		message_strlen = 0;
		message_pad_sz = 0;
	}


	/*
	 * Collect size info specific to the confirm callback request
	 * message and allocate a buffer
	 */
	*buf_size = sizeof (rdr_confirm_callback_t);
	*buf_size += message_strlen;
	*buf_size += message_pad_sz;

	*buf = (char *)malloc(*buf_size);
	if (*buf == NULL) {
		return (RDR_MEM_ALLOC);
	}

	/*
	 * Set fixed address labels by name
	 */
	if (params->confp != NULL) {
		confirm_callback_data.confirm_callback_id =
		    (unsigned long)params->confp->confirm;
		confirm_callback_data.appdata_ptr =
		    (unsigned long)params->confp->appdata_ptr;
	} else {
		confirm_callback_data.confirm_callback_id = 0;
		confirm_callback_data.appdata_ptr = 0;
	}
	confirm_callback_data.message_size = message_strlen + message_pad_sz;

	/*
	 * Set variable information using memcpy
	 */
	bufptr = *buf;
	(void) memcpy(bufptr, &confirm_callback_data,
	    sizeof (rdr_confirm_callback_t));
	bufptr += sizeof (rdr_confirm_callback_t);

	if (params->message != NULL) {
		(void) memcpy(bufptr, params->message, message_strlen);
		bufptr += message_strlen;
		for (i = 0; i < message_pad_sz; i++) {
			bufptr[i] = 0;
		}
		bufptr += message_pad_sz;
	}

	return (RDR_OK);
}


/*
 * unpack_confirm_request:
 *
 * Handle unpacking a confirm callback request.
 */
static int
unpack_confirm_request(confirm_callback_params_t *params, const char *buf)
{
	char				*bufptr;
	rdr_confirm_callback_t		confirm_callback_data;


	if ((params == NULL) || (buf == NULL)) {
		return (RDR_ERROR);
	}

	bufptr = (char *)buf;
	(void) memcpy(&confirm_callback_data, bufptr,
	    sizeof (rdr_confirm_callback_t));
	bufptr += sizeof (rdr_confirm_callback_t);

	/*
	 * handle getting the message text
	 */
	if (get_string_from_buf(&(params->message),
	    confirm_callback_data.message_size, bufptr)) {
		return (RDR_ERROR);
	}
	bufptr += confirm_callback_data.message_size;

	/*
	 * Set fixed address labels by name
	 */
	params->confp = (struct cfga_confirm *)
	    malloc(sizeof (struct cfga_confirm));
	if (params->confp == NULL) {
		return (RDR_MEM_ALLOC);
	}

	/* set params->confp->confirm using memcpy */
	(void) memcpy((void*)params->confp,
	    &(confirm_callback_data.confirm_callback_id),
	    sizeof (unsigned long));

	params->confp->appdata_ptr =
	    (void*)confirm_callback_data.appdata_ptr;

	return (RDR_OK);
}


/*
 * pack_confirm_reply:
 *
 * Handle packing a confirm callback reply.
 */
static int
pack_confirm_reply(confirm_callback_params_t *params, char **buf, int *buf_size)
{
	char				*bufptr;
	rdr_confirm_callback_reply_t	confirm_callback_data;


	if ((params == NULL) || (buf == NULL) || (buf_size == NULL)) {
		return (RDR_ERROR);
	}

	/*
	 * Collect size info specific to the confirm callback reply
	 * message and allocate a buffer
	 */
	*buf_size = sizeof (confirm_callback_params_t);
	*buf = (char *)malloc(*buf_size);
	if (*buf == NULL) {
		return (RDR_MEM_ALLOC);
	}

	/*
	 * Set fixed address labels by name
	 */
	if (params->confp != NULL) {
		confirm_callback_data.confirm_callback_id =
		    (unsigned long)params->confp->confirm;
		confirm_callback_data.appdata_ptr =
		    (unsigned long)params->confp->appdata_ptr;
	} else {
		confirm_callback_data.confirm_callback_id = 0;
		confirm_callback_data.appdata_ptr = 0;
	}
	confirm_callback_data.response = params->response;

	/*
	 * Set variable information using memcpy
	 */
	bufptr = *buf;

	(void) memcpy(bufptr, &confirm_callback_data,
	    sizeof (rdr_confirm_callback_reply_t));

	return (RDR_OK);
}


/*
 * unpack_confirm_reply:
 *
 * Handle unpacking a confirm callback reply.
 */
static int
unpack_confirm_reply(confirm_callback_params_t *params, const char *buf)
{
	char				*bufptr;
	rdr_confirm_callback_reply_t	confirm_callback_data;

	if ((params == NULL) || (buf == NULL)) {
		return (RDR_ERROR);
	}

	bufptr = (char *)buf;
	(void) memcpy(&confirm_callback_data, bufptr,
	    sizeof (rdr_confirm_callback_reply_t));
	bufptr += sizeof (confirm_callback_params_t);

	/*
	 * Set fixed address labels by name
	 */
	params->confp = (struct cfga_confirm *)
	    malloc(sizeof (struct cfga_confirm));
	if (params->confp == NULL) {
		return (RDR_MEM_ALLOC);
	}

	/* set params->confp->confirm using memcpy */
	(void) memcpy((void*)params->confp,
	    &(confirm_callback_data.confirm_callback_id),
	    sizeof (unsigned long));

	params->confp->appdata_ptr =
	    (void*)confirm_callback_data.appdata_ptr;
	params->response = confirm_callback_data.response;

	return (RDR_OK);
}


/*
 * pack_message_request:
 *
 * Handle packing a message callback request.
 */
static int
pack_message_request(msg_callback_params_t *params, char **buf, int *buf_size)
{
	int			i;
	char			*bufptr;
	rdr_msg_callback_t	msg_callback_data;
	int			message_strlen;
	int			message_pad_sz;

	if ((params == NULL) || (buf == NULL) || (buf_size == NULL)) {
		return (RDR_ERROR);
	}

	/*
	 * Set variable length fields and make a call to partially
	 * pack it.
	 */
	if (params->message != NULL) {
		message_strlen = strlen(params->message) + 1;
		message_pad_sz = RDR_ALIGN_64_BIT -
		    (message_strlen % RDR_ALIGN_64_BIT);
	} else {
		message_strlen = 0;
		message_pad_sz = 0;
	}


	/*
	 * Collect size info specific to the message callback request
	 * message and allocate a buffer
	 */
	*buf_size = sizeof (rdr_msg_callback_t);
	*buf_size += message_strlen;
	*buf_size += message_pad_sz;

	*buf = (char *)malloc(*buf_size);
	if (*buf == NULL) {
		return (RDR_MEM_ALLOC);
	}

	/*
	 * Set fixed address labels by name
	 */
	if (params->msgp != NULL) {
		msg_callback_data.msg_callback_id =
		    (unsigned long)params->msgp->message_routine;
		msg_callback_data.appdata_ptr =
		    (unsigned long)params->msgp->appdata_ptr;
	} else {
		msg_callback_data.msg_callback_id = 0;
		msg_callback_data.appdata_ptr = 0;
	}
	msg_callback_data.message_size = message_strlen + message_pad_sz;

	/*
	 * Set variable information using memcpy
	 */
	bufptr = *buf;

	(void) memcpy(bufptr, &msg_callback_data, sizeof (rdr_msg_callback_t));
	bufptr += sizeof (rdr_msg_callback_t);

	if (params->message != NULL) {
		(void) memcpy(bufptr, params->message, message_strlen);
		bufptr += message_strlen;
		for (i = 0; i < message_pad_sz; i++) {
			bufptr[i] = 0;
		}
		bufptr += message_pad_sz;
	}

	return (RDR_OK);
}


/*
 * unpack_message_request:
 *
 * Handle unpacking a message callback request.
 */
static int
unpack_message_request(msg_callback_params_t *params, const char *buf)
{
	char			*bufptr;
	rdr_msg_callback_t	msg_callback_data;

	if ((params == NULL) || (buf == NULL)) {
		return (RDR_ERROR);
	}

	bufptr = (char *)buf;
	(void) memcpy(&msg_callback_data, bufptr, sizeof (rdr_msg_callback_t));
	bufptr += sizeof (rdr_msg_callback_t);

	/*
	 * handle getting the message text
	 */
	if (get_string_from_buf(&(params->message),
	    msg_callback_data.message_size, bufptr)) {
		return (RDR_ERROR);
	}
	bufptr += msg_callback_data.message_size;

	/*
	 * Set fixed address labels by name
	 */
	params->msgp = (struct cfga_msg *)malloc(sizeof (struct cfga_msg));
	if (params->msgp == NULL) {
		return (RDR_MEM_ALLOC);
	}

	/* set params->msgp->message_routine using memcpy */
	(void) memcpy((void*)params->msgp, &(msg_callback_data.msg_callback_id),
	    sizeof (unsigned long));

	params->msgp->appdata_ptr = (void*)msg_callback_data.appdata_ptr;

	return (RDR_OK);
}

/*
 * pack_rsrc_info_request:
 *
 * Handle packing a resource info request.
 */
static int
pack_rsrc_info_request(rsrc_info_params_t *params, char **buf, int *buf_size)
{
	char				*bufptr;
	rdr_rsrc_info_t			rsrc_info_data;
	rdr_variable_message_info_t	var_msg_info;


	if ((params == NULL) || (buf == NULL) || (buf_size == NULL)) {
		return (RDR_ERROR);
	}

	(void) memset(&var_msg_info, 0, sizeof (rdr_variable_message_info_t));

	/*
	 * Set variable length fields and make a call to partially
	 * pack it.
	 */
	if (pack_ap_ids(params->num_ap_ids, params->ap_ids, &var_msg_info)) {
		cleanup_variable_ap_id_info(&var_msg_info);
		return (RDR_ERROR);
	}

	/*
	 * Collect size info specific to the resource info request
	 * message and allocate a buffer.
	 */
	*buf_size = sizeof (rdr_rsrc_info_t);
	*buf_size += var_msg_info.ap_id_int_size;
	*buf_size += var_msg_info.ap_id_char_size;

	*buf = (char *)malloc(*buf_size);
	if (*buf == NULL) {
		return (RDR_MEM_ALLOC);
	}

	/*
	 * Set fixed address labels by name.
	 */
	rsrc_info_data.num_ap_ids = params->num_ap_ids;
	rsrc_info_data.ap_id_char_size = var_msg_info.ap_id_char_size;
	rsrc_info_data.flags = params->flags;

	/*
	 * Set variable information using memcpy.
	 */
	bufptr = *buf;

	(void) memcpy(bufptr, &rsrc_info_data, sizeof (rdr_rsrc_info_t));
	bufptr += sizeof (rdr_rsrc_info_t);

	if (var_msg_info.ap_id_sizes != NULL) {
		(void) memcpy(bufptr, var_msg_info.ap_id_sizes,
		    var_msg_info.ap_id_int_size);
		bufptr += var_msg_info.ap_id_int_size;
	}

	if (var_msg_info.ap_id_chars != NULL) {
		(void) memcpy(bufptr, var_msg_info.ap_id_chars,
		    var_msg_info.ap_id_char_size);
		bufptr += var_msg_info.ap_id_char_size;
	}

	cleanup_variable_ap_id_info(&var_msg_info);

	return (RDR_OK);
}


/*
 * unpack_rsrc_info_request:
 *
 * Handle unpacking a resource info request message.
 */
static int
unpack_rsrc_info_request(rsrc_info_params_t *params, const char *buf)
{
	char				*bufptr;
	rdr_variable_message_info_t	var_msg_info;
	rdr_rsrc_info_t			rsrc_info_data;


	if ((params == NULL) || (buf == NULL)) {
		return (RDR_ERROR);
	}

	(void) memset(&var_msg_info, 0, sizeof (rdr_variable_message_info_t));

	bufptr = (char *)buf;
	(void) memcpy(&rsrc_info_data, bufptr, sizeof (rdr_rsrc_info_t));
	bufptr += sizeof (rdr_rsrc_info_t);

	/*
	 * Handle getting the ap_ids.
	 */
	var_msg_info.ap_id_char_size = rsrc_info_data.ap_id_char_size;
	if (get_ap_ids_from_buf(&(params->ap_ids), rsrc_info_data.num_ap_ids,
	    &var_msg_info, bufptr)) {
		return (RDR_ERROR);
	}
	bufptr += var_msg_info.ap_id_int_size;
	bufptr += var_msg_info.ap_id_char_size;

	/*
	 * Set fixed address labels by name.
	 */
	params->num_ap_ids = rsrc_info_data.num_ap_ids;
	params->flags = rsrc_info_data.flags;

	return (RDR_OK);
}


/*
 * pack_rsrc_info_reply:
 *
 * Handle packing a resource info reply message.
 */
static int
pack_rsrc_info_reply(rsrc_info_params_t *params, char **buf, int *buf_size,
    int encoding)
{
	char				*bufptr;
	rdr_rsrc_info_reply_t		rsrc_info_data;
	int				pack_status;
	caddr_t				rsrc_info_bufp = NULL;
	size_t				rsrc_info_size;


	if ((params == NULL) || (buf == NULL) || (buf_size == NULL)) {
		return (RDR_ERROR);
	}

	/*
	 * Pack snapshot handle data.
	 */
	pack_status = ri_pack(params->hdl, &rsrc_info_bufp, &rsrc_info_size,
	    encoding);
	if (pack_status != 0) {
		return (RDR_ERROR);
	}

	/*
	 * Collect size info specific to the rsrc_info reply message
	 * and allocate a buffer.
	 */
	*buf_size = sizeof (rdr_rsrc_info_reply_t);
	*buf_size += rsrc_info_size;

	*buf = (char *)malloc(*buf_size);
	if (*buf == NULL) {
		free(rsrc_info_bufp);
		return (RDR_MEM_ALLOC);
	}

	/*
	 * Set fixed address labels by name.
	 */
	rsrc_info_data.packed_hdl_size = rsrc_info_size;

	/*
	 * Set variable information using memcpy.
	 */
	bufptr = *buf;

	(void) memcpy(bufptr, &rsrc_info_data, sizeof (rdr_rsrc_info_reply_t));
	bufptr += sizeof (rdr_rsrc_info_reply_t);

	if (rsrc_info_bufp) {
		(void) memcpy(bufptr, rsrc_info_bufp, rsrc_info_size);
		free(rsrc_info_bufp);
	}

	return (RDR_OK);
}


/*
 * unpack_rsrc_info_reply:
 *
 * Handle unpacking a resource info reply message.
 */
static int
unpack_rsrc_info_reply(rsrc_info_params_t *params, const char *buf)
{
	int			unpack_status;
	char			*bufptr;
	rdr_rsrc_info_reply_t	rsrc_info_data;


	if ((params == NULL) || (buf == NULL)) {
		return (RDR_ERROR);
	}

	bufptr = (char *)buf;
	(void) memcpy(&rsrc_info_data, bufptr, sizeof (rdr_rsrc_info_reply_t));
	bufptr += sizeof (rdr_rsrc_info_reply_t);

	/*
	 * Unpack buf into resource info handle.
	 */
	unpack_status = ri_unpack(bufptr, rsrc_info_data.packed_hdl_size,
	    &params->hdl);

	return ((unpack_status == 0) ? RDR_OK : RDR_ERROR);
}


/*
 * pack_ap_ids:
 *
 * Pack a list of attachment point identifiers into a single buffer.
 * This buffer is stored in the specified rdr_variable_message_info_t
 * and is padded to be 64-bit aligned.
 */
static int
pack_ap_ids(int num_ap_ids, char *const *ap_ids,
    rdr_variable_message_info_t *var_msg_info)
{
	int	i;
	int	ap_id_pad_sz;
	char	*bufptr;


	if (var_msg_info == NULL) {
		return (RDR_ERROR);
	}

	/*
	 * NULL is a valid value for ap_ids in the list_ext
	 * case. For list_ext, no specified attachment points
	 * indicates that _all_ attachment points should be
	 * displayed. However, if ap_ids is NULL, num_ap_ids
	 * should be 0.
	 */
	if ((ap_ids == NULL) && (num_ap_ids != 0)) {
		num_ap_ids = 0;
	}

	var_msg_info->ap_id_int_size = sizeof (int) * num_ap_ids;
	if (num_ap_ids > 0) {
		var_msg_info->ap_id_sizes = (int *)malloc(sizeof (int) *
		    var_msg_info->ap_id_int_size);
		if (var_msg_info->ap_id_sizes == NULL) {
			return (RDR_MEM_ALLOC);
		}
	}
	for (i = 0; i < num_ap_ids; i++) {
		if (ap_ids[i] != NULL) {
			var_msg_info->ap_id_sizes[i] = strlen(ap_ids[i]) + 1;
			var_msg_info->ap_id_char_size +=
			    var_msg_info->ap_id_sizes[i];
		}
	}
	if (var_msg_info->ap_id_char_size > 0) {
		ap_id_pad_sz = RDR_ALIGN_64_BIT -
		    (var_msg_info->ap_id_char_size % RDR_ALIGN_64_BIT);
		var_msg_info->ap_id_char_size += ap_id_pad_sz;
		var_msg_info->ap_id_chars = (char *)
		    malloc(var_msg_info->ap_id_char_size);
		if (var_msg_info->ap_id_chars == NULL) {
			return (RDR_MEM_ALLOC);
		}

		bufptr = var_msg_info->ap_id_chars;
		for (i = 0; i < num_ap_ids; i++) {
			(void) memcpy(bufptr, ap_ids[i],
			    var_msg_info->ap_id_sizes[i]);
			bufptr += var_msg_info->ap_id_sizes[i];
		}
		for (i = 0; i < ap_id_pad_sz; i++) {
			bufptr[i] = 0;
		}
	} else {
		ap_id_pad_sz = 0;
	}

	return (RDR_OK);
}


/*
 * unpack_ap_ids:
 *
 * Unpack a buffer containing a concatenation of a list of
 * attachment point identifiers. The resulting list of strings
 * are stored in an array in the specified rdr_variable_message_info_t.
 */
static int
unpack_ap_ids(int num_ap_ids, char **ap_ids, const char *buf,
    rdr_variable_message_info_t *var_msg_info)
{
	int	i;
	int	ap_id_size;
	int	chars_copied;
	char	*bufptr;


	if ((ap_ids == NULL) || (buf == NULL) || (var_msg_info == NULL)) {
		return (RDR_ERROR);
	}
	bufptr = (char *)buf;

	var_msg_info->ap_id_int_size = sizeof (int) * num_ap_ids;
	if (num_ap_ids > 0) {
		var_msg_info->ap_id_sizes = (int *)
		    malloc(sizeof (int) * var_msg_info->ap_id_int_size);
		if (var_msg_info->ap_id_sizes == NULL) {
			return (RDR_MEM_ALLOC);
		}
		(void) memcpy(var_msg_info->ap_id_sizes, bufptr,
		    var_msg_info->ap_id_int_size);
	}
	bufptr += var_msg_info->ap_id_int_size;

	chars_copied = 0;
	for (i = 0; i < num_ap_ids; i++) {
		ap_id_size = var_msg_info->ap_id_sizes[i];
		if (ap_id_size <= 0) {
			continue;
		}
		if ((chars_copied + ap_id_size) >
		    var_msg_info->ap_id_char_size) {
			return (RDR_ERROR);
		}
		ap_ids[i] = (char *)malloc(ap_id_size);
		if (ap_ids[i] == NULL) {
			return (RDR_MEM_ALLOC);
		}
		(void) memcpy(ap_ids[i], bufptr, ap_id_size);
		bufptr += ap_id_size;
		chars_copied += ap_id_size;
	}
	return (RDR_OK);
}


/*
 * find_options_sizes:
 *
 * Determine the size of a specified option string. The information
 * is stored in the specified rdr_variable_message_info_t.
 */
static int
find_options_sizes(char *options, rdr_variable_message_info_t *var_msg_info)
{
	if (var_msg_info == NULL) {
		return (RDR_ERROR);
	}
	if (options != NULL) {
		var_msg_info->options_strlen = strlen(options) + 1;
		var_msg_info->options_pad_sz = RDR_ALIGN_64_BIT -
		    (var_msg_info->options_strlen % RDR_ALIGN_64_BIT);
	} else {
		var_msg_info->options_strlen = 0;
		var_msg_info->options_pad_sz = 0;
	}
	return (RDR_OK);
}


/*
 * find_listopts_sizes:
 *
 * Determine the size of a specified list option string. The information
 * is stored in the specified rdr_variable_message_info_t.
 */
static int
find_listopts_sizes(char *listopts, rdr_variable_message_info_t *var_msg_info)
{
	if (var_msg_info == NULL) {
		return (RDR_ERROR);
	}
	if (listopts != NULL) {
		var_msg_info->listopts_strlen = strlen(listopts) + 1;
		var_msg_info->listopts_pad_sz = RDR_ALIGN_64_BIT -
		    (var_msg_info->listopts_strlen % RDR_ALIGN_64_BIT);
	} else {
		var_msg_info->listopts_strlen = 0;
		var_msg_info->listopts_pad_sz = 0;
	}
	return (RDR_OK);
}


/*
 * find_function_size:
 *
 * Determine the size of a specified private function string. The
 * information is stored in the specified rdr_variable_message_info_t.
 */
static int
find_function_sizes(char *function, rdr_variable_message_info_t *var_msg_info)
{
	if (var_msg_info == NULL) {
		return (RDR_ERROR);
	}
	if (function != NULL) {
		var_msg_info->function_strlen = strlen(function) + 1;
		var_msg_info->function_pad_sz = RDR_ALIGN_64_BIT -
		    (var_msg_info->function_strlen % RDR_ALIGN_64_BIT);
	} else {
		var_msg_info->function_strlen = 0;
		var_msg_info->function_pad_sz = 0;
	}
	return (RDR_OK);
}


/*
 * find_errstring_sizes:
 *
 * Determine the size of a specified error string. The information
 * is stored in the specified rdr_variable_message_info_t.
 */
static int
find_errstring_sizes(char **errstring,
    rdr_variable_message_info_t *var_msg_info)
{
	if ((errstring != NULL) && (*errstring != NULL)) {
		var_msg_info->errstring_strlen = strlen(*errstring) + 1;
		var_msg_info->errstring_pad_sz = RDR_ALIGN_64_BIT -
		    (var_msg_info->errstring_strlen % RDR_ALIGN_64_BIT);
	} else {
		var_msg_info->errstring_strlen = 0;
		var_msg_info->errstring_pad_sz = 0;
	}
	return (RDR_OK);
}


/*
 * get_ap_ids_from_buf:
 *
 * Unpack a buffer containing a concatenation of a list of attachment
 * point identifiers. An appropriately sized buffer is allocated and
 * the resulting list of strings are stored in an array in the specified
 * rdr_variable_message_info_t.
 */
static int
get_ap_ids_from_buf(char ***ap_id_ptr, int num_ap_ids,
    rdr_variable_message_info_t *var_msg_info, const char *buf)
{
	if ((ap_id_ptr == NULL) || (buf == NULL) || (var_msg_info == NULL)) {
		return (RDR_ERROR);
	}
	if (num_ap_ids > 0) {
		*ap_id_ptr = (char **)malloc(sizeof (char *) * num_ap_ids);
		if (*ap_id_ptr == NULL) {
			return (RDR_MEM_ALLOC);
		}
		if (unpack_ap_ids(num_ap_ids, *ap_id_ptr, buf, var_msg_info)) {
			cleanup_variable_ap_id_info(var_msg_info);
			return (RDR_ERROR);
		}

	} else if (num_ap_ids < 0) {
		return (RDR_ERROR);
	}

	cleanup_variable_ap_id_info(var_msg_info);

	return (RDR_OK);
}


/*
 * get_string_from_buf:
 *
 * Copy a string to a new buffer. Memory is allocated for the
 * new buffer and the original string is copied to the new buffer.
 * This is primarily used when a string is located in a packed
 * buffer that will eventually get deallocated.
 */
static int
get_string_from_buf(char **stringptr, int strsize, const char *buf)
{
	if (buf == NULL) {
		return (RDR_ERROR);
	}

	/*
	 * A stringptr of NULL is a valid value. The errstring param
	 * in an rconfig_xxx call is valid and is passed to this
	 * function. For example, see errstring in the call to this
	 * function in unpack_change_state_reply.
	 */
	if (stringptr != NULL) {
		if (strsize > 0) {
			*stringptr = (char *)malloc(strsize);
			if (*stringptr == NULL) {
				return (RDR_MEM_ALLOC);
			}
			(void) memcpy(*stringptr, buf, strsize);
		} else if (strsize == 0) {
			*stringptr = NULL;
		} else if (strsize < 0) {
			*stringptr = NULL;
			return (RDR_ERROR);
		}
	}
	return (RDR_OK);
}


/*
 * cleanup_ap_ids:
 *
 * Deallocate the specified array of attachment point identifiers.
 */
static int
cleanup_ap_ids(int num_ap_ids, char ** ap_ids)
{
	int	i;

	if (ap_ids == NULL) {
		return (RDR_ERROR);
	}
	for (i = 0; i < num_ap_ids; i++) {
		if (ap_ids[i] != NULL) {
			free((void *)ap_ids[i]);
			ap_ids[i] = NULL;
		}
	}
	return (RDR_OK);
}


/*
 * cleanup_errstring:
 *
 * Deallocate the specified error string.
 */
static int
cleanup_errstring(char **errstring)
{
	if (errstring) {
		if (*errstring) {
			free((void *)*errstring);
		}
		free((void *)errstring);
		errstring = NULL;
	}

	return (RDR_OK);
}


/*
 * cleanup_variable_ap_id_info:
 *
 * Deallocate the ap_id information from the specified
 * rdr_variable_message_info_t.
 */
static void
cleanup_variable_ap_id_info(rdr_variable_message_info_t *var_msg_info)
{
	if (var_msg_info != NULL) {
		if (var_msg_info->ap_id_sizes != NULL) {
			free((void *)var_msg_info->ap_id_sizes);
			var_msg_info->ap_id_sizes = NULL;
		}
		if (var_msg_info->ap_id_chars != NULL) {
			free((void *)var_msg_info->ap_id_chars);
			var_msg_info->ap_id_chars = NULL;
		}
	}
}

/*
 * load_libdscp:
 *
 * Try to dynamically link with libdscp.
 *
 * Returns:	0 if libdscp not available,
 *		1 if libdscp is available.
 */
static int
load_libdscp(libdscp_t *libdscp)
{
	int		len;
	void		*lib;
	static char	platform[100];
	static char	pathname[MAXPATHLEN];

	/*
	 * Only try to load libdscp once.  Use the saved
	 * status in the libdscp interface to know the
	 * results of previous attempts.
	 */
	if (libdscp->status == LIBDSCP_AVAILABLE) {
		return (1);
	}
	if (libdscp->status == LIBDSCP_UNAVAILABLE) {
		return (0);
	}

	/*
	 * Construct a platform specific pathname for libdscp.
	 */
	len = sysinfo(SI_PLATFORM, platform, sizeof (platform));
	if ((len < 0) || (len > sizeof (platform))) {
		return (0);
	}
	len = snprintf(pathname, MAXPATHLEN, LIBDSCP_PATH, platform);
	if (len >= MAXPATHLEN) {
		libdscp->status = LIBDSCP_UNAVAILABLE;
		return (0);
	}

	/*
	 * Try dynamically loading libdscp.
	 */
	if ((lib = dlopen(pathname, RTLD_LAZY)) == NULL) {
		libdscp->status = LIBDSCP_UNAVAILABLE;
		return (0);
	}

	/*
	 * Try to resolve all the symbols.
	 */
	libdscp->bind = (int (*)(int, int, int))dlsym(lib, LIBDSCP_BIND);
	libdscp->secure = (int (*)(int, int))dlsym(lib, LIBDSCP_SECURE);
	libdscp->auth = (int (*)(int, struct sockaddr *, int))dlsym(lib,
	    LIBDSCP_AUTH);

	if ((libdscp->bind == NULL) ||
	    (libdscp->secure == NULL) ||
	    (libdscp->auth == NULL)) {
		(void) dlclose(lib);
		libdscp->status = LIBDSCP_UNAVAILABLE;
		return (0);
	}

	/*
	 * Success.
	 * Update the status to indicate libdscp is available.
	 */
	libdscp->status = LIBDSCP_AVAILABLE;
	return (1);
}