/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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
 */
/*
 * replica.c
 *
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * Parse replicated server lists of the form:
 *
 *	host1:/path1,host2,host3,host4:/path2,host5:/path3
 *
 * into an array containing its constituent parts:
 *
 *	host1	/path1
 *	host2	/path2
 *	host3	/path2
 *	host4	/path2
 *	host5	/path3
 * where a server could also be represented in form of literal address
 * and in case it is an IPv6 literal address it will be enclosed in
 * square brackets [IPv6 Literal address]
 * Problems indicated by null return; they will be memory allocation
 * errors worthy of an error message unless count == -1, which means
 * a parse error.
 */

#include <stdio.h>
#include <malloc.h>
#include <string.h>
#include <strings.h>
#include <sys/types.h>
#include <errno.h>
#include "replica.h"

void
free_replica(struct replica *list, int count)
{
	int i;

	for (i = 0; i < count; i++) {
		if (list[i].host)
			free(list[i].host);
		if (list[i].path)
			free(list[i].path);
	}
	free(list);
}

struct replica *
parse_replica(char *special, int *count)
{
	struct replica *list = NULL;
	char *root, *special2;
	char *proot, *x, *y;
	int scount, v6addr, i;
	int found_colon = 0;

	*count = 0;
	scount = 0;
	v6addr = 0;
	root = special2 = strdup(special);
	proot = root;

	while (root) {
		switch (*root) {
		case '[':
			if ((root != special2) && (*(root -1) != ',')) {
				root++;
				break;
			}
			y = strchr(root, ']');
			if (!y) {
				root++;
				break;
			}
			if ((*(y + 1) != ',') && (*(y + 1) != ':')) {
				root = y + 1;
				break;
			}
			/*
			 * Found a v6 Literal Address, so set "v6addr"
			 * and grab the address and store it in the list
			 * under "host part".
			 */
			proot = root + 1;
			root = y + 1;
			v6addr = 1;
			if ((list = realloc(list, (*count + 1) *
			    sizeof (struct replica))) == NULL)
				goto bad;
			bzero(&list[(*count)++], sizeof (struct replica));
			*y = '\0';
			list[*count-1].host = strdup(proot);
			if (!list[*count-1].host)
				goto bad;
			break;
		case ':':
			*root = '\0';
			x = root + 1;
			/*
			 * Find comma (if present), which bounds the path.
			 * The comma implies that the user is trying to
			 * specify failover syntax if another colon follows.
			 */
			if (((y = strchr(x, ',')) != NULL) &&
			    (strchr((y + 1), ':'))) {
				root = y + 1;
				*y = '\0';
			} else {
				found_colon = 1;
				root = NULL;
			}
			/*
			 * If "v6addr" is set, unset it, and since the "host
			 * part" is already taken care of, skip to the "path
			 * path" part.
			 */
			if (v6addr == 1)
				v6addr = 0;
			else {
				if ((list = realloc(list, (*count + 1) *
				    sizeof (struct replica))) == NULL)
					goto bad;
				bzero(&list[(*count)++],
				    sizeof (struct replica));
				list[*count-1].host = strdup(proot);
				if (!list[*count-1].host)
					goto bad;
				proot = root;

			}
			for (i = scount; i < *count; i++) {
				list[i].path = strdup(x);
				if (!list[i].path)
					goto bad;
			}
			scount = i;
			proot = root;
			if (y)
				*y = ',';
			break;
		case ',':
			/*
			 * If "v6addr" is set, unset it and continue
			 * else grab the address and store it in the list
			 * under "host part".
			 */
			if (v6addr == 1) {
				v6addr = 0;
				proot = ++root;
			} else {
				*root = '\0';
				root++;
				if ((list = realloc(list, (*count + 1) *
				    sizeof (struct replica))) == NULL)
					goto bad;
				bzero(&list[(*count)++],
				    sizeof (struct replica));
				list[*count-1].host = strdup(proot);
				if (!list[*count-1].host)
					goto bad;
				proot = root;
				*(root - 1) = ',';
			}
			break;
		default:
			if (*root == '\0')
				root = NULL;
			else
				root++;
		}
	}
	if (found_colon) {
		free(special2);
		return (list);
	}
bad:
	if (list)
		free_replica(list, *count);
	if (!found_colon)
		*count = -1;
	free(special2);
	return (NULL);
}