Permalink
Switch branches/tags
Nothing to show
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
338 lines (291 sloc) 7.78 KB
/*
* 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 2015 Nexenta Systems, Inc. All rights reserved.
*/
/*
* Copyright 2007 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include <syslog.h>
#include <sys/param.h>
#include <rpc/rpc.h>
#include <sys/stat.h>
#include <netconfig.h>
#include <netdir.h>
#include <sys/file.h>
#include <sys/time.h>
#include <sys/errno.h>
#include <sys/resource.h>
#include <rpcsvc/mount.h>
#include <sys/pathconf.h>
#include <sys/systeminfo.h>
#include <sys/utsname.h>
#include <signal.h>
#include <locale.h>
#include <unistd.h>
#include <thread.h>
#include <sharefs/share.h>
#include "../lib/sharetab.h"
#include "mountd.h"
struct cache_entry {
char *cache_host;
time_t cache_time;
int cache_belong;
char **cache_grl;
int cache_grc;
struct cache_entry *cache_next;
};
static struct cache_entry *cache_head;
#define VALID_TIME 60 /* seconds */
static rwlock_t cache_lock; /* protect the cache chain */
static void cache_free(struct cache_entry *entry);
static int cache_check(char *host, char **grl, int grc, int *belong);
static void cache_enter(char *host, char **grl, int grc, int belong);
void
netgroup_init()
{
(void) rwlock_init(&cache_lock, USYNC_THREAD, NULL);
}
/*
* Check whether any of the hostnames in clnames are
* members (or non-members) of the netgroups in glist.
* Since the innetgr lookup is rather expensive, the
* result is cached. The cached entry is valid only
* for VALID_TIME seconds. This works well because
* typically these lookups occur in clusters when
* a client is mounting.
*
* Note that this routine establishes a host membership
* in a list of netgroups - we've no idea just which
* netgroup in the list it is a member of.
*
* glist is a character array containing grc strings
* representing netgroup names (optionally prefixed
* with '-'). Each string is ended with '\0' and
* followed immediately by the next string.
*/
int
netgroup_check(struct nd_hostservlist *clnames, char *glist, int grc)
{
char **grl;
char *gr;
int nhosts = clnames->h_cnt;
char *host0, *host;
int i, j, n;
int response;
int belong = 0;
static char *domain;
if (domain == NULL) {
int ssize;
domain = exmalloc(SYS_NMLN);
ssize = sysinfo(SI_SRPC_DOMAIN, domain, SYS_NMLN);
if (ssize > SYS_NMLN) {
free(domain);
domain = exmalloc(ssize);
ssize = sysinfo(SI_SRPC_DOMAIN, domain, ssize);
}
/* Check for error in syscall or NULL domain name */
if (ssize <= 1) {
syslog(LOG_ERR, "No default domain set");
return (0);
}
}
grl = calloc(grc, sizeof (char *));
if (grl == NULL)
return (0);
for (i = 0, gr = glist; i < grc && !belong; ) {
/*
* If the netgroup name has a '-' prepended
* then a match of this name implies a failure
* instead of success.
*/
response = (*gr != '-') ? 1 : 0;
/*
* Subsequent names with or without a '-' (but no mix)
* can be grouped together for a single check.
*/
for (n = 0; i < grc; i++, n++, gr += strlen(gr) + 1) {
if ((response && *gr == '-') ||
(!response && *gr != '-'))
break;
grl[n] = response ? gr : gr + 1;
}
host0 = clnames->h_hostservs[0].h_host;
/*
* If not in cache check the netgroup for each
* of the hosts names (usually just one).
* Enter the result into the cache.
*/
if (!cache_check(host0, grl, n, &belong)) {
for (j = 0; j < nhosts && !belong; j++) {
host = clnames->h_hostservs[j].h_host;
if (__multi_innetgr(n, grl,
1, &host,
0, NULL,
1, &domain))
belong = 1;
}
cache_enter(host0, grl, n, belong);
}
}
free(grl);
return (belong ? response : 0);
}
/*
* Free a cache entry and all entries
* further down the chain since they
* will also be expired.
*/
static void
cache_free(struct cache_entry *entry)
{
struct cache_entry *ce, *next;
int i;
for (ce = entry; ce; ce = next) {
if (ce->cache_host)
free(ce->cache_host);
for (i = 0; i < ce->cache_grc; i++)
if (ce->cache_grl[i])
free(ce->cache_grl[i]);
if (ce->cache_grl)
free(ce->cache_grl);
next = ce->cache_next;
free(ce);
}
}
/*
* Search the entries in the cache chain looking
* for an entry with a matching hostname and group
* list. If a match is found then return the "belong"
* value which may be 1 or 0 depending on whether the
* client is a member of the list or not. This is
* both a positive and negative cache.
*
* Cache entries have a validity of VALID_TIME seconds.
* If we find an expired entry then blow away the entry
* and the rest of the chain since entries further down
* the chain will be expired too because we always add
* new entries to the head of the chain.
*/
static int
cache_check(char *host, char **grl, int grc, int *belong)
{
struct cache_entry *ce, *prev;
time_t timenow = time(NULL);
int i;
(void) rw_rdlock(&cache_lock);
for (ce = cache_head; ce; ce = ce->cache_next) {
/*
* If we find a stale entry, there can't
* be any valid entries from here on.
* Acquire a write lock, search the chain again
* and delete the stale entry and all following
* entries.
*/
if (timenow > ce->cache_time) {
(void) rw_unlock(&cache_lock);
(void) rw_wrlock(&cache_lock);
for (prev = NULL, ce = cache_head; ce;
prev = ce, ce = ce->cache_next)
if (timenow > ce->cache_time)
break;
if (ce != NULL) {
if (prev)
prev->cache_next = NULL;
else
cache_head = NULL;
cache_free(ce);
}
(void) rw_unlock(&cache_lock);
return (0);
}
if (ce->cache_grc != grc)
continue; /* no match */
if (strcasecmp(host, ce->cache_host) != 0)
continue; /* no match */
for (i = 0; i < grc; i++)
if (strcasecmp(ce->cache_grl[i], grl[i]) != 0)
break; /* no match */
if (i < grc)
continue;
*belong = ce->cache_belong;
(void) rw_unlock(&cache_lock);
return (1);
}
(void) rw_unlock(&cache_lock);
return (0);
}
/*
* Put a new entry in the cache chain by
* prepending it to the front.
* If there isn't enough memory then just give up.
*/
static void
cache_enter(char *host, char **grl, int grc, int belong)
{
struct cache_entry *entry;
int i;
entry = malloc(sizeof (*entry));
if (entry == NULL)
return;
(void) memset((caddr_t)entry, 0, sizeof (*entry));
entry->cache_host = strdup(host);
if (entry->cache_host == NULL) {
cache_free(entry);
return;
}
entry->cache_time = time(NULL) + VALID_TIME;
entry->cache_belong = belong;
entry->cache_grl = malloc(grc * sizeof (char *));
if (entry->cache_grl == NULL) {
cache_free(entry);
return;
}
for (i = 0; i < grc; i++) {
entry->cache_grl[i] = strdup(grl[i]);
if (entry->cache_grl[i] == NULL) {
entry->cache_grc = i;
cache_free(entry);
return;
}
}
entry->cache_grc = grc;
(void) rw_wrlock(&cache_lock);
entry->cache_next = cache_head;
cache_head = entry;
(void) rw_unlock(&cache_lock);
}
/*
* Full cache flush
*/
void
netgrp_cache_flush(void)
{
(void) rw_wrlock(&cache_lock);
cache_free(cache_head);
cache_head = NULL;
(void) rw_unlock(&cache_lock);
}