/*
 * 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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <stdlib.h>
#include <strings.h>
#include <unistd.h>
#include <stddef.h>
#include <sys/types.h>
#include <sys/socket.h>
#include "libilb.h"
#include "libilb_impl.h"

enum which_tbl {
	show_nat = 1,
	show_persist
};

/* The common function to show kernel info. */
static ilb_status_t ilb_show_info(ilb_handle_t, char *, size_t *, boolean_t *,
    enum which_tbl);

/*
 * To get the ILB NAT table.
 *
 * buf: The buffer to return the NAT table entries.
 * num: The caller sets it to the number of ilb_nat_info_t entries buf can
 *      hold.  On return, it contains the actual number of entries put in buf.
 * end: The caller sets it to B_TRUE if it only wants at most num entries to
 *      be returned.  The transaction to ilbd will be termianted when this
 *      call returns.
 *      The caller sets it to B_FALSE if it intends to get the whole table.
 *      If the whole table has more than num entries, the caller can call
 *      this function again to retrieve the rest of the table.
 *      On return, end is set to B_TRUE if end of table is reached; B_FALSE
 *      if there are still remaining entries.
 */
ilb_status_t
ilb_show_nat(ilb_handle_t h, ilb_nat_info_t buf[], size_t *num,
    boolean_t *end)
{
	return (ilb_show_info(h, (char *)buf, num, end, show_nat));
}

/*
 * To get the ILB persistent entry table.
 *
 * buf: The buffer to return the persistent table entries.
 * num: The caller sets it to the number of ilb_persist_info_t entries buf can
 *      hold.  On return, it contains the actual number of entries put in buf.
 * end: The caller sets it to B_TRUE if it only wants at most num entries to
 *      be returned.  The transaction to ilbd will be termianted when this
 *      call returns.
 *      The caller sets it to B_FALSE if it intends to get the whole table.
 *      If the whole table has more than num entries, the caller can call
 *      this function again to retrieve the rest of the table.
 *      On return, end is set to B_TRUE if end of table is reached; B_FALSE
 *      if there are still remaining entries.
 */
ilb_status_t
ilb_show_persist(ilb_handle_t h, ilb_persist_info_t buf[], size_t *num,
    boolean_t *end)
{
	return (ilb_show_info(h, (char *)buf, num, end, show_persist));
}

/*
 * The function doing the work...  The tbl parameter determines whith table
 * to show.
 */
static ilb_status_t
ilb_show_info(ilb_handle_t h, char *buf, size_t *num, boolean_t *end,
    enum which_tbl tbl)
{
	ilb_comm_t	*req, *rbuf;
	ilb_show_info_t	*req_si, *tmp_si;
	size_t		reqsz, rbufsz, tmp_rbufsz, cur_num;
	size_t		entry_sz;
	ilb_status_t	rc;

	if (*num == 0)
		return (ILB_STATUS_EINVAL);

	reqsz = sizeof (ilb_comm_t) + sizeof (ilb_show_info_t);
	if ((req = malloc(reqsz)) == NULL)
		return (ILB_STATUS_ENOMEM);
	req_si = (ilb_show_info_t *)&req->ic_data;

	/*
	 * Need to allocate a receive buffer and then copy the buffer
	 * content to the passed in buf.  The reason is that the
	 * communication to ilbd is message based and the protocol
	 * includes a header in the reply.  We need to remove this header
	 * from the message, hence the copying...
	 */
	if (tbl == show_nat)
		entry_sz = sizeof (ilb_nat_info_t);
	else
		entry_sz = sizeof (ilb_persist_info_t);
	rbufsz = *num * entry_sz + sizeof (ilb_comm_t) +
	    sizeof (ilb_show_info_t);
	if ((rbuf = malloc(rbufsz)) == NULL) {
		free(req);
		return (ILB_STATUS_ENOMEM);
	}

	if (tbl == show_nat)
		req->ic_cmd = ILBD_SHOW_NAT;
	else
		req->ic_cmd = ILBD_SHOW_PERSIST;
	req->ic_flags = 0;
	req_si->sn_num = *num;
	cur_num = 0;

	do {
		tmp_rbufsz = rbufsz;
		rc = i_ilb_do_comm(h, req, reqsz, rbuf, &tmp_rbufsz);
		if (rc != ILB_STATUS_OK)
			goto out;
		if (rbuf->ic_cmd != ILBD_CMD_OK) {
			rc = *(ilb_status_t *)&rbuf->ic_data;
			goto out;
		}

		tmp_si = (ilb_show_info_t *)&rbuf->ic_data;

		cur_num += tmp_si->sn_num;
		bcopy(&tmp_si->sn_data, buf, tmp_si->sn_num * entry_sz);
		buf += tmp_si->sn_num * entry_sz;

		/*
		 * Buffer is filled, regardless of this is the end of table or
		 * not, we need to stop.
		 */
		if (cur_num == *num)
			break;
		/* Try to fill in the rest. */
		req_si->sn_num = *num - cur_num;
	} while (!(rbuf->ic_flags & ILB_COMM_END));

	*num = cur_num;

	/* End of transaction, let the caller know. */
	if (rbuf->ic_flags & ILB_COMM_END) {
		*end = B_TRUE;
	} else {
		/* The user wants to terminate the transaction */
		if (*end) {
			req->ic_flags = ILB_COMM_END;
			tmp_rbufsz = rbufsz;
			rc = i_ilb_do_comm(h, req, reqsz, rbuf, &tmp_rbufsz);
		}
	}
out:
	free(req);
	free(rbuf);
	return (rc);
}