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

/*
 * Traverses /etc/dfs/sharetab in order to find shared file systems
 */

#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include <errno.h>
#include <thread.h>
#include <synch.h>
#include "libfsmgt.h"
#include <sharefs/share.h>
#include "sharetab.h"

#define	SECMODES 5

/*
 * Private variables
 */
static mutex_t	sharetab_lock = DEFAULTMUTEX;

/*
 * Private method declarations
 */
fs_sharelist_t	*create_sharelist_entry(struct share *sharetab_entry,
					int *errp);

/*
 * Public methods
 */

void
fs_free_share_list(fs_sharelist_t *headp)
{
	fs_sharelist_t	*tmp;

	while (headp != NULL) {
		tmp = headp->next;
		free(headp->path);
		free(headp->resource);
		free(headp->fstype);
		free(headp->options);
		free(headp->description);
		headp->next = NULL;
		free(headp);

		headp = tmp;
	}
}

/*
 * Get a linked list of all the shares on the system from /etc/dfs/dfstab
 */
fs_sharelist_t *
fs_get_share_list(int *errp)
{
	fs_sharelist_t	*newp;
	fs_sharelist_t	*headp;
	fs_sharelist_t	*tailp;
	FILE		*fp;

	headp = NULL;
	tailp = NULL;

	if ((fp = fopen(SHARETAB, "r")) != NULL) {
		struct share	*sharetab_entry;

		(void) mutex_lock(&sharetab_lock);
		while (getshare(fp, &sharetab_entry) > 0) {

			newp = create_sharelist_entry(sharetab_entry, errp);
			if (newp == NULL) {
				/*
				 * Out of memory
				 */
				fs_free_share_list(headp);
				(void) mutex_unlock(&sharetab_lock);
				(void) fclose(fp);
				return (NULL);
			}

			if (headp == NULL) {
				headp = newp;
				tailp = newp;
			} else {
				tailp->next = newp;
				tailp = newp;
			}

		} /* while (getshare(fp, &sharetab_entry) != 0) */
		(void) mutex_unlock(&sharetab_lock);
		(void) fclose(fp);
	} else {
		*errp = errno;
	} /* if ((fp = fopen(SHARETAB, "r")) != NULL) */

	/*
	 * Caller must free the mount list
	 */
	return (headp);
} /* fs_get_share_list */


/*
 * fs_parse_opts_for_sec_modes
 * Get an array of strings of all the security modes of the option string.
 *
 * char *cmd - The option string from the share command.
 * int *count - pointer to the number of elements in the returned array.
 * int *error - error pointer for returning any errors.
 */
char **
fs_parse_opts_for_sec_modes(char *cmd, int *count, int *error)
{
	char *temp_str;
	char **secstringarray;
	char *strptr;

	*count = 0;
	strptr = strdup(cmd);
	if (strptr == NULL) {
		*error = ENOMEM;
		return (NULL);
	}

	temp_str = strptr;

	secstringarray =
	    (char **)calloc((size_t)SECMODES, (size_t)(sizeof (char *)));
	if (secstringarray == NULL) {
		*error = ENOMEM;
		return (NULL);
	}

	if (strstr(strptr, "sec=") != NULL) {
		char *next_str;
		next_str = strptr;

		while (next_str != NULL) {
			next_str = strstr(strptr, "sec=");
			if (next_str != NULL) {
				if (strncmp(strptr, "sec=", 4) != 0) {
					*(next_str - 1) = '\0';
				}
				strptr = next_str;
				next_str = strstr(strptr + 4, "sec=");
				if (next_str != NULL) {
					*(next_str - 1) = '\0';
				}
				secstringarray[*count] = strdup(strptr);
				if (secstringarray[*count] == NULL) {
					*error = ENOMEM;
					if (*count > 0) {
						fileutil_free_string_array(
						    secstringarray, *count);
					} else {
						free(secstringarray);
					}
					free(temp_str);
					return (NULL);
				}
				strptr = next_str;
				(*count)++;
			}
		}
	} else {
		secstringarray[*count] = strdup(temp_str);
		if (secstringarray[*count] == NULL) {
			*error = ENOMEM;
			if (*count > 0) {
				fileutil_free_string_array(
				    secstringarray, *count);
			} else {
				free(secstringarray);
			}
			free(temp_str);
			return (NULL);
		}
		(*count)++;
	}
	free(temp_str);
	return (secstringarray);
}

/*
 * fs_create_array_from_accesslist
 * Takes the colon seperated access list parses the list into an array
 * containing all the elements of the list. The array created is returned
 * and count is set to the number of elements in the array.
 *
 * char *access_list - The string containing the colon sperated access list.
 * int *count - Will contain the number of elements in the array.
 * int *err - any errors encountered.
 */
char **
fs_create_array_from_accesslist(char *access_list, int *count, int *err)
{
	char *delimiter = ":";
	char *server_string;
	char **list_array = NULL;
	char *list_copy;

	*count = 0;
	if (access_list != NULL) {
		list_copy = strdup(access_list);
		if (list_copy != NULL) {
			server_string = strtok(list_copy, delimiter);
			if (server_string != NULL) {
				while (server_string != NULL) {
					if (!fileutil_add_string_to_array(
					    &list_array, server_string, count,
					    err)) {
						fileutil_free_string_array(
						    list_array, *count);
						free(list_copy);
						goto return_err;
					}
					server_string =
					    strtok(NULL, delimiter);
				}
			} else {
				list_array =
				    (char **)calloc(((*count) + 1),
				    sizeof (char *));
				if (list_array == NULL) {
					*err = ENOMEM;
					free(list_copy);
					goto return_err;
				}
				list_array[*count] = strdup(access_list);
				if (list_array[*count] == NULL) {
					*err = ENOMEM;
					free(list_array);
					list_array = NULL;
					goto return_err;
				}
				(*count)++;
			}
			free(list_copy);
		} else {
			*err = ENOMEM;
		}
	}
return_err:
	return (list_array);
} /* fs_create_array_from_accesslist */


/*
 * Private Methods
 */

fs_sharelist_t *
create_sharelist_entry(struct share *sharetab_entry, int *errp)
{

	fs_sharelist_t	*newp;

	newp = (fs_sharelist_t *)calloc((size_t)1,
	    (size_t)sizeof (fs_sharelist_t));

	if (newp == NULL) {
		/*
		 * Out of memory
		 */
		*errp = errno;
		return (NULL);
	}

	newp->path = strdup(sharetab_entry->sh_path);
	if (newp->path == NULL) {
		/*
		 * Out of memory
		 */
		*errp = errno;
		fs_free_share_list(newp);
		return (NULL);
	}

	newp->resource = strdup(sharetab_entry->sh_res);
	if (newp->path == NULL) {
		/*
		 * Out of memory
		 */
		*errp = errno;
		fs_free_share_list(newp);
		return (NULL);
	}

	newp->fstype = strdup(sharetab_entry->sh_fstype);
	if (newp->fstype == NULL) {
		/*
		 * Out of memory
		 */
		*errp = errno;
		fs_free_share_list(newp);
		return (NULL);
	}

	newp->options = strdup(sharetab_entry->sh_opts);
	if (newp->options == NULL) {
		/*
		 * Out of memory
		 */
		*errp = errno;
		fs_free_share_list(newp);
		return (NULL);
	}

	newp->description = strdup(sharetab_entry->sh_descr);
	if (newp->description == NULL) {
		/*
		 * Out of memory
		 */
		*errp = errno;
		fs_free_share_list(newp);
		return (NULL);
	}
	newp->next = NULL;

	return (newp);
} /* create_sharelist_entry */