/*

 * 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.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*

 * core library for common functions across all config store types

 * and file systems to be exported. This includes legacy dfstab/sharetab

 * parsing. Need to eliminate XML where possible.

 */

#include <stdio.h>

#include <string.h>

#include <ctype.h>

#include <unistd.h>

#include <limits.h>

#include <errno.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <libxml/parser.h>

#include <libxml/tree.h>

#include "libshare.h"

#include "libshare_impl.h"

#include <fcntl.h>

#include <sys/stat.h>

#include <grp.h>

#include <limits.h>

#include <sys/param.h>

#include <signal.h>

#include <libintl.h>

#include "sharetab.h"

#define	DFSTAB_NOTICE_LINES	5

static char *notice[DFSTAB_NOTICE_LINES] =	{

	"# Do not modify this file directly.\n",

	"# Use the sharemgr(1m) command for all share management\n",

	"# This file is reconstructed and only maintained for backward\n",

	"# compatibility. Configuration lines could be lost.\n",

	"#\n"

};

#define	STRNCAT(x, y, z)	(xmlChar *)strncat((char *)x, (char *)y, z)

/* will be much smaller, but this handles bad syntax in the file */

#define	MAXARGSFORSHARE	256

/* used internally only */

typedef

struct sharelist {

    struct sharelist *next;

    int   persist;

    char *path;

    char *resource;

    char *fstype;

    char *options;

    char *description;

    char *group;

    char *origline;

    int lineno;

} xfs_sharelist_t;

static void parse_dfstab(sa_handle_t, char *, xmlNodePtr);

extern char *get_token(char *);

static void dfs_free_list(xfs_sharelist_t *);

/* prototypes */

void getlegacyconfig(sa_handle_t, char *, xmlNodePtr *);

extern sa_share_t _sa_add_share(sa_group_t, char *, int, int *);

extern sa_group_t _sa_create_group(sa_handle_impl_t, char *);

static void outdfstab(FILE *, xfs_sharelist_t *);

extern int _sa_remove_optionset(sa_optionset_t);

extern int set_node_share(void *, char *, char *);

extern void set_node_attr(void *, char *, char *);

/*

 * sablocksigs(*sigs)

 *

 * block important signals for a critical region. Arg is a pointer to

 * a sigset_t that is used later for the unblock.

 */

void

sablocksigs(sigset_t *sigs)

{

	sigset_t new;

	if (sigs != NULL) {

	    (void) sigprocmask(SIG_BLOCK, NULL, &new);

	    (void) sigaddset(&new, SIGHUP);

	    (void) sigaddset(&new, SIGINT);

	    (void) sigaddset(&new, SIGQUIT);

	    (void) sigaddset(&new, SIGTSTP);

	    (void) sigprocmask(SIG_SETMASK, &new, sigs);

	}

}

/*

 * saunblocksigs(*sigs)

 *

 * unblock previously blocked signals from the sigs arg.

 */

void

saunblocksigs(sigset_t *sigs)

{

	if (sigs != NULL)

	    (void) sigprocmask(SIG_SETMASK, sigs, NULL);

}

/*

 * alloc_sharelist()

 *

 * allocator function to return an zfs_sharelist_t

 */

static xfs_sharelist_t *

alloc_sharelist()

{

	xfs_sharelist_t *item;

	item = (xfs_sharelist_t *)malloc(sizeof (xfs_sharelist_t));

	if (item != NULL)

	    (void) memset(item, '\0', sizeof (xfs_sharelist_t));

	return (item);

}

/*

 * fix_notice(list)

 *

 * Look at the beginning of the current /etc/dfs/dfstab file and add

 * the do not modify notice if it doesn't exist.

 */

static xfs_sharelist_t *

fix_notice(xfs_sharelist_t *list)

{

	xfs_sharelist_t *item, *prev;

	int i;

	if (list == NULL) {

	    /* zero length dfstab */

	    list = alloc_sharelist();

	    if (list == NULL)

		return (NULL);

	    list->description = strdup("#\n");

	}

	if (list->path == NULL && list->description != NULL &&

	    strcmp(list->description, notice[0]) != 0) {

	    for (prev = NULL, i = 0; i < DFSTAB_NOTICE_LINES; i++) {

		item = alloc_sharelist();

		if (item != NULL) {

		    item->description = strdup(notice[i]);

		    if (prev == NULL) {

			item->next = list;

			prev = item;

			list = item;

		    } else {

			item->next = prev->next;

			prev->next = item;

			prev = item;

		    }

		}

	    }

	}

	return (list);

}

/*

 * getdfstab(dfs)

 *

 * Returns an zfs_sharelist_t list of lines from the dfstab file

 * pointed to by the FILE pointer dfs. Each entry is parsed and the

 * original line is also preserved. Used in parsing and updating the

 * dfstab file.

 */

static xfs_sharelist_t *

getdfstab(FILE *dfs)

{

	char buff[_POSIX_ARG_MAX]; /* reasonable size given syntax of share */

	char *bp;

	char *token;

	char *args[MAXARGSFORSHARE];

	int argc;

	int c;

	static int line = 0;

	xfs_sharelist_t *item = NULL, *first = NULL, *last;

	if (dfs != NULL) {

	    first = NULL;

	    line = 0;

	    while (fgets(buff, sizeof (buff), dfs) != NULL) {

		line++;

		bp = buff;

		if (buff[0] == '#') {

		    item = alloc_sharelist();

		    if (item != NULL) {

			/* if no path, then comment */

			item->lineno = line;

			item->description = strdup(buff);

			if (first == NULL) {

			    first = item;

			    last = item;

			} else {

			    last->next = item;

			    last = item;

			}

		    } else {

			break;

		    }

		    continue;

		} else if (buff[0] == '\n') {

		    continue;

		}

		optind = 1;

		item = alloc_sharelist();

		if (item == NULL) {

		    break;

		} else if (first == NULL) {

		    first = item;

		    last = item;

		} else {

		    last->next = item;

		    last = item;

		}

		item->lineno = line;

		item->origline = strdup(buff);

		(void) get_token(NULL); /* reset to new pointers */

		argc = 0;

		while ((token = get_token(bp)) != NULL) {

		    if (argc < MAXARGSFORSHARE) {

			args[argc++] = token;

		    }

		}

		while ((c = getopt(argc, args, "F:o:d:pg:")) != -1) {

		    switch (c) {

		    case 'p':

			item->persist = 1;

			break;

		    case 'F':

			item->fstype = strdup(optarg);

			break;

		    case 'o':

			item->options = strdup(optarg);

			break;

		    case 'd':

			item->description = strdup(optarg);

			break;

		    case 'g':

			item->group = strdup(optarg);

			break;

		    default:

			break;

		    }

		}

		if (optind < argc) {

		    item->path = strdup(args[optind]);

		    optind++;

		    if (optind < argc) {

			char *resource;

			char *optgroup;

			/* resource and/or groupname */

			resource = args[optind];

			optgroup = strchr(resource, '@');

			if (optgroup != NULL) {

			    *optgroup++ = '\0';

			}

			if (optgroup != NULL)

			    item->group = strdup(optgroup);

			if (resource != NULL && strlen(resource) > 0)

			    item->resource = strdup(resource);

		    }

		}

		if (item != NULL && item->fstype == NULL) {

		    item->fstype = strdup("nfs"); /* this is the default */

		}

	    }

	}

	first = fix_notice(first);

	return (first);

}

/*

 * finddfsentry(list, path)

 *

 * Look for path in the zfs_sharelist_t list and return the entry if it

 * exists.

 */

static xfs_sharelist_t *

finddfsentry(xfs_sharelist_t *list, char *path)

{

	xfs_sharelist_t *item;

	for (item = list; item != NULL; item = item->next) {

	    if (item->path != NULL && strcmp(item->path, path) == 0)

		return (item);

	}

	return (NULL);

}

/*

 * remdfsentry(list, path, proto)

 *

 * Remove the specified path (with protocol) from the list. This will

 * remove it from dfstab when the file is rewritten.

 */

static xfs_sharelist_t *

remdfsentry(xfs_sharelist_t *list, char *path, char *proto)

{

	xfs_sharelist_t *item, *prev = NULL;

	for (item = prev = list; item != NULL; item = item->next) {

	    /* skip comment entry but don't lose it */

	    if (item->path == NULL) {

		prev = item;

		continue;

	    }

	    /* if proto is NULL, remove all protocols */

	    if (proto == NULL || (strcmp(item->path, path) == 0 &&

		(item->fstype != NULL && strcmp(item->fstype, proto) == 0)))

		break;

	    if (item->fstype == NULL &&

		(proto == NULL || strcmp(proto, "nfs") == 0))

		break;

	    prev = item;

	}

	if (item != NULL) {

	    if (item == prev) {

		list = item->next; /* this must be the first one */

	    } else {

		prev->next = item->next;

	    }

	    item->next = NULL;

	    dfs_free_list(item);

	}

	return (list);

}

/*

 * remdfsline(list, line)

 *

 * Remove the line specified from the list.

 */

static xfs_sharelist_t *

remdfsline(xfs_sharelist_t *list, char *line)

{

	xfs_sharelist_t *item, *prev = NULL;

	for (item = prev = list; item != NULL; item = item->next) {

	    /* skip comment entry but don't lose it */

	    if (item->path == NULL) {

		prev = item;

		continue;

	    }

	    if (strcmp(item->origline, line) == 0) {

		break;

	    }

	    prev = item;

	}

	if (item != NULL) {

	    if (item == prev) {

		list = item->next; /* this must be the first one */

	    } else {

		prev->next = item->next;

	    }

	    item->next = NULL;

	    dfs_free_list(item);

	}

	return (list);

}

/*

 * adddfsentry(list, share, proto)

 *

 * Add an entry to the dfstab list for share (relative to proto). This

 * is used to update dfstab for legacy purposes.

 */

static xfs_sharelist_t *

adddfsentry(xfs_sharelist_t *list, sa_share_t share, char *proto)

{

	xfs_sharelist_t *item, *tmp;

	sa_group_t parent;

	char *groupname;

	item = alloc_sharelist();

	if (item != NULL) {

	    parent = sa_get_parent_group(share);

	    groupname = sa_get_group_attr(parent, "name");

	    if (strcmp(groupname, "default") == 0) {

		sa_free_attr_string(groupname);

		groupname = NULL;

	    }

	    item->path = sa_get_share_attr(share, "path");

	    item->resource = sa_get_share_attr(share, "resource");

	    item->group = groupname;

	    item->fstype = strdup(proto);

	    item->options = sa_proto_legacy_format(proto, share, 1);

	    if (item->options != NULL && strlen(item->options) == 0) {

		free(item->options);

		item->options = NULL;

	    }

	    item->description = sa_get_share_description(share);

	    if (item->description != NULL && strlen(item->description) == 0) {

		sa_free_share_description(item->description);

		item->description = NULL;

	    }

	    if (list == NULL) {

		list = item;

	    } else {

		for (tmp = list; tmp->next != NULL; tmp = tmp->next)

		    /* do nothing */;

		tmp->next = item;

	    }

	}

	return (list);

}

/*

 * outdfstab(dfstab, list)

 *

 * Output the list to dfstab making sure the file is truncated.

 * Comments and errors are preserved.

 */

static void

outdfstab(FILE *dfstab, xfs_sharelist_t *list)

{

	xfs_sharelist_t *item;

	(void) ftruncate(fileno(dfstab), 0);

	for (item = list; item != NULL; item = item->next) {

	    if (item->path != NULL) {

		if (*item->path == '/')

		    (void) fprintf(dfstab, "share %s%s%s%s%s%s%s %s%s%s%s%s\n",

			    (item->fstype != NULL) ? "-F " : "",

			    (item->fstype != NULL) ? item->fstype : "",

			    (item->options != NULL) ? " -o " : "",

			    (item->options != NULL) ? item->options : "",

			    (item->description != NULL) ? " -d \"" : "",

			    (item->description != NULL) ?

				item->description : "",

			    (item->description != NULL) ? "\"" : "",

			    item->path,

			    ((item->resource != NULL) ||

				(item->group != NULL)) ? " " : "",

			    (item->resource != NULL) ? item->resource : "",

			    item->group != NULL ? "@" : "",

			    item->group != NULL ? item->group : "");

		else

		    (void) fprintf(dfstab, "%s", item->origline);

	    } else {

		if (item->description != NULL) {

		    (void) fprintf(dfstab, "%s", item->description);

		} else {

		    (void) fprintf(dfstab, "%s", item->origline);

		}

	    }

	}

}

/*

 * open_dfstab(file)

 *

 * Open the specified dfstab file. If the owner/group/perms are wrong,

 * fix them.

 */

static FILE *

open_dfstab(char *file)

{

	struct group *grp;

	struct group group;

	char *buff;

	int grsize;

	FILE *dfstab;

	dfstab = fopen(file, "r+");

	if (dfstab == NULL) {

	    dfstab = fopen(file, "w+");

	}

	if (dfstab != NULL) {

		grsize = sysconf(_SC_GETGR_R_SIZE_MAX);

		buff = malloc(grsize);

		if (buff != NULL)

		    grp = getgrnam_r(SA_DEFAULT_FILE_GRP, &group, buff, grsize);

		else

		    grp = getgrnam(SA_DEFAULT_FILE_GRP); /* take the risk */

		(void) fchmod(fileno(dfstab), 0644);

		(void) fchown(fileno(dfstab), 0,

				grp != NULL ? grp->gr_gid : 3);

		if (buff != NULL)

		    free(buff);

		rewind(dfstab);

	}

	return (dfstab);

}