OpenSolaris_b135/lib/libdhcpsvc/private/private.c
/*
* 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
*/
/*
* Copyright (c) 2001 by Sun Microsystems, Inc.
* All rights reserved.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
/*
* This module contains the private layer API.
*/
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/param.h>
#include <libelf.h>
#include <gelf.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <dlfcn.h>
#include <glob.h>
#include <fcntl.h>
#include <libinetutil.h>
#include <dhcp_svc_public.h>
#include <dhcp_svc_private.h>
/*
* Threading notes for private layer consumers:
*
* The handles returned from open_dd() may be shared across multiple
* threads with no adverse side effects. However, it's up to that consumer
* to ensure that all threads have finished using an instance before
* closing the instance or removing the container it's referencing.
* Phrased differently:
*
* * Consumers must ensure all threads sharing a handle are
* finished before calling close_dd().
*
* * Consumers must ensure all threads referencing a container are
* closed before calling remove_dd().
*/
static boolean_t validate_dd_entry(dsvc_handle_t, const void *, boolean_t);
static int synch_init(dsvc_handle_t, const char *, uint_t);
static void synch_fini(dsvc_handle_t);
/*
* Order here should match the function array in <dhcp_svc_private.h>
*/
static char *funcnames[] = {
"status", "version", "mklocation",
"list_dt", "open_dt", "close_dt", "remove_dt",
"lookup_dt", "add_dt", "modify_dt", "delete_dt",
"list_dn", "open_dn", "close_dn", "remove_dn",
"lookup_dn", "add_dn", "modify_dn", "delete_dn"
};
extern dsvc_synch_ops_t dsvcd_synch_ops;
/*
* Retrieve the current version associated with the datastore named by
* `resource' and store in `converp'. One might think we could do this via
* a simple readlink(2), but on internal release builds $(ROOTLINKS)
* installs using hardlinks, not symlinks. For this reason and to make it
* harder for us to be fooled, we'll dredge up the actual soname through
* ELF. Close your eyes, it's gonna get ugly.
*/
static int
get_conver(const char *resource, int *converp)
{
int elf_fd;
int i;
GElf_Shdr gelf_shdr;
GElf_Dyn gelf_dyn;
Elf_Scn *elf_scn = NULL;
Elf *elf_file;
Elf_Data *elf_data;
char *soname = NULL;
char path[MAXPATHLEN];
(void) snprintf(path, sizeof (path), "%s%s/%s_%s.so", DHCP_CONFOPT_ROOT,
DSVC_MODULE_DIR, DSVC_PUBLIC_PREFIX, resource);
elf_fd = open(path, O_RDONLY);
if (elf_fd == -1)
return (DSVC_MODULE_ERR);
if (elf_version(EV_CURRENT) == EV_NONE) {
(void) close(elf_fd);
return (DSVC_INTERNAL);
}
elf_file = elf_begin(elf_fd, ELF_C_READ, NULL);
if (elf_file == NULL || elf_kind(elf_file) != ELF_K_ELF) {
(void) close(elf_fd);
return (DSVC_INTERNAL);
}
while ((elf_scn = elf_nextscn(elf_file, elf_scn)) != NULL) {
if (gelf_getshdr(elf_scn, &gelf_shdr) == 0)
continue;
if (gelf_shdr.sh_type != SHT_DYNAMIC)
continue;
elf_data = elf_getdata(elf_scn, NULL);
if (elf_data == NULL)
continue;
i = 0;
do {
(void) gelf_getdyn(elf_data, i++, &gelf_dyn);
if (gelf_dyn.d_tag == DT_SONAME)
soname = elf_strptr(elf_file, gelf_shdr.sh_link,
gelf_dyn.d_un.d_ptr);
} while (gelf_dyn.d_tag != DT_NULL && soname == NULL);
}
if (soname == NULL || sscanf(soname, "%*[^.].so.%d", converp) != 1) {
(void) elf_end(elf_file);
(void) close(elf_fd);
return (DSVC_MODULE_ERR);
}
(void) elf_end(elf_file);
(void) close(elf_fd);
return (DSVC_SUCCESS);
}
/*
* Unload a public datastore module.
*/
static int
unload_public_module(void **instance, dsvc_splapi_t *api)
{
static dsvc_splapi_t null_api;
if (dlclose(*instance) != 0)
return (DSVC_MODULE_UNLOAD_ERR);
*instance = NULL;
*api = null_api;
return (DSVC_SUCCESS);
}
/*
* Load public datastore module. Validates version of module. Returns
* instance of opened module, and populates the api argument with the
* function addresses exporting the API.
*/
static int
load_public_module(dsvc_datastore_t *ddp, void **instance, dsvc_splapi_t *api)
{
int i, v;
dsvc_splfuncp_t configure;
char path[MAXPATHLEN];
(void) snprintf(path, sizeof (path), "%s%s/%s_%s.so", DHCP_CONFOPT_ROOT,
DSVC_MODULE_DIR, DSVC_PUBLIC_PREFIX, ddp->d_resource);
if (ddp->d_conver != DSVC_CUR_CONVER)
(void) snprintf(path, sizeof (path), "%s.%d", path,
ddp->d_conver);
*instance = dlopen(path, RTLD_LAZY|RTLD_GROUP|RTLD_WORLD);
if (*instance == NULL)
return (DSVC_MODULE_LOAD_ERR);
/*
* No requirement to duplicate the names - we can always reference
* the same set.
*/
api->version = (dsvc_splfuncp_t)dlsym(*instance, "version");
if (api->version == NULL || api->version(&v) != DSVC_SUCCESS ||
v != DSVC_PUBLIC_VERSION) {
(void) unload_public_module(instance, api);
return (DSVC_MODULE_VERSION);
}
configure = (dsvc_splfuncp_t)dlsym(*instance, "configure");
if (configure != NULL) {
if (configure(ddp->d_config) != DSVC_SUCCESS) {
(void) unload_public_module(instance, api);
return (DSVC_MODULE_CFG_ERR);
}
}
for (i = 0; i < DSVC_NSPLFUNCS; i++) {
if ((((dsvc_splfuncp_t *)api)[i] =
(dsvc_splfuncp_t)dlsym(*instance, funcnames[i])) == NULL) {
(void) unload_public_module(instance, api);
return (DSVC_MODULE_ERR);
}
}
/*
* Caller requested the current version; fill in what that current
* version is.
*/
if (ddp->d_conver == DSVC_CUR_CONVER) {
int error;
error = get_conver(ddp->d_resource, &ddp->d_conver);
if (error != DSVC_SUCCESS) {
(void) unload_public_module(instance, api);
return (error);
}
}
return (DSVC_SUCCESS);
}
/*
* Return a dynamically-allocated null-terminated list of the available
* modules stored in the module directory. A count of the available
* modules is stored in the num argument. Caller is responsible for
* freeing the list.
*/
int
enumerate_dd(char ***modules, int *nump)
{
int i, retval;
char *ptr;
glob_t globbuf;
char globpat[MAXPATHLEN];
if (modules == NULL || nump == NULL)
return (DSVC_INVAL);
(void) snprintf(globpat, sizeof (globpat), "%s%s/%s_*\\.so",
DHCP_CONFOPT_ROOT, DSVC_MODULE_DIR, DSVC_PUBLIC_PREFIX);
retval = glob(globpat, GLOB_NOSORT, NULL, &globbuf);
if (retval != 0) {
globfree(&globbuf);
switch (retval) {
case GLOB_NOMATCH:
*nump = 0;
*modules = NULL;
return (DSVC_SUCCESS);
case GLOB_NOSPACE:
return (DSVC_NO_MEMORY);
default:
return (DSVC_INTERNAL);
}
}
*modules = calloc(globbuf.gl_pathc, sizeof (char **));
if (*modules == NULL) {
globfree(&globbuf);
return (DSVC_NO_MEMORY);
}
for (i = 0; i < globbuf.gl_pathc; i++) {
ptr = strrchr(globbuf.gl_pathv[i], '/');
if (ptr == NULL)
ptr = globbuf.gl_pathv[i];
else
ptr++;
(*modules)[i] = malloc(strlen(ptr) + 1);
if ((*modules)[i] == NULL) {
while (i--)
free((*modules)[i]);
free(modules);
globfree(&globbuf);
return (DSVC_NO_MEMORY);
}
(void) sscanf(ptr, "%*[^_]_%[^.]", (*modules)[i]);
}
globfree(&globbuf);
*nump = i;
return (DSVC_SUCCESS);
}
/*
* Check the status of the underlying service supporting the data store.
* Caller is responsible for freeing any dynamically allocated arguments.
*/
int
status_dd(dsvc_datastore_t *ddp)
{
void *instance;
dsvc_splapi_t api;
int error;
error = load_public_module(ddp, &instance, &api);
if (error != DSVC_SUCCESS)
return (error);
error = api.status(ddp->d_location);
(void) unload_public_module(&instance, &api);
return (error);
}
/*
* Create within the data store the "location" where containers will be
* stored.
*/
int
mklocation_dd(dsvc_datastore_t *ddp)
{
void *instance;
dsvc_splapi_t api;
int error;
error = load_public_module(ddp, &instance, &api);
if (error != DSVC_SUCCESS)
return (error);
error = api.mklocation(ddp->d_location);
(void) unload_public_module(&instance, &api);
return (error);
}
/*
* Return a list of the current container objects of type 'type' located at
* 'location' in listppp. Return the number of list elements in 'count'.
*/
int
list_dd(dsvc_datastore_t *ddp, dsvc_contype_t type, char ***listppp,
uint_t *count)
{
void *instance;
dsvc_splapi_t api;
int error;
error = load_public_module(ddp, &instance, &api);
if (error != DSVC_SUCCESS)
return (error);
if (type == DSVC_DHCPTAB)
error = api.list_dt(ddp->d_location, listppp, count);
else
error = api.list_dn(ddp->d_location, listppp, count);
(void) unload_public_module(&instance, &api);
return (error);
}
/*
* Creates or opens the DHCP container of type called name within the
* specific datastore referenced by ddp, and returns a handle to this
* container in the handp argument. New containers are created with
* the identity of the caller. Caller is responsible for freeing any
* dynamically allocated arguments. The returned handle instance must
* be released by calling close_dd().
*/
int
open_dd(dsvc_handle_t *handp, dsvc_datastore_t *ddp, dsvc_contype_t type,
const char *name, uint_t flags)
{
int error;
dsvc_handle_t hp;
*handp = NULL;
if (type == DSVC_DHCPNETWORK && name == NULL)
return (DSVC_INVAL);
if (flags & DSVC_CREATE && (flags & DSVC_WRITE) == 0)
return (DSVC_INVAL);
if ((hp = calloc(1, sizeof (struct dsvc_handle))) == NULL)
return (DSVC_NO_MEMORY);
if (type == DSVC_DHCPNETWORK) {
hp->d_conid.c_net.s_addr = ntohl(inet_addr(name));
if (hp->d_conid.c_net.s_addr == INADDR_BROADCAST) {
free(hp);
return (DSVC_INVAL);
}
get_netmask4(&hp->d_conid.c_net, &hp->d_conid.c_mask);
}
error = load_public_module(ddp, &hp->d_instance, &hp->d_api);
if (error != DSVC_SUCCESS) {
free(hp);
return (error);
}
hp->d_type = type;
hp->d_desc.d_conver = ddp->d_conver;
hp->d_desc.d_resource = strdup(ddp->d_resource);
hp->d_desc.d_location = strdup(ddp->d_location);
if (hp->d_desc.d_resource == NULL || hp->d_desc.d_location == NULL) {
error = DSVC_NO_MEMORY;
goto error;
}
/*
* Initialize the synchronization strategy (may not be any).
*/
error = synch_init(hp, name, flags);
if (error != DSVC_SUCCESS)
goto error;
if (type == DSVC_DHCPTAB)
error = hp->d_api.open_dt(&hp->d_hand, ddp->d_location, flags);
else
error = hp->d_api.open_dn(&hp->d_hand, ddp->d_location, flags,
&hp->d_conid.c_net, &hp->d_conid.c_mask);
if (error != DSVC_SUCCESS) {
if (hp->d_synch != NULL)
synch_fini(hp);
goto error;
}
*handp = hp;
return (DSVC_SUCCESS);
error:
(void) unload_public_module(&hp->d_instance, &hp->d_api);
free(hp->d_desc.d_resource);
free(hp->d_desc.d_location);
free(hp);
return (error);
}
/*
* Remove DHCP container called name of type within the specific datastore
* referenced by ddp. Caller is responsible for freeing any dynamically
* allocated arguments.
*/
int
remove_dd(dsvc_datastore_t *ddp, dsvc_contype_t type, const char *name)
{
void *instance;
int error;
dsvc_splapi_t api;
struct in_addr ip, mask;
if (type != DSVC_DHCPTAB) {
if ((ip.s_addr = inet_addr(name)) == INADDR_BROADCAST)
return (DSVC_INVAL);
ip.s_addr = ntohl(ip.s_addr);
get_netmask4(&ip, &mask);
}
error = load_public_module(ddp, &instance, &api);
if (error != DSVC_SUCCESS)
return (error);
/* remove the DHCP container */
if (type == DSVC_DHCPTAB)
error = api.remove_dt(ddp->d_location);
else
error = api.remove_dn(ddp->d_location, &ip, &mask);
(void) unload_public_module(&instance, &api);
return (error);
}
/*
* Delete the handle instance referenced by hand. Frees hand if the close
* operation was successful. NOTE: Caller is responsible for synchronizing
* multiple threads such that close_dd() is called when all consuming
* threads have exited.
*/
int
close_dd(dsvc_handle_t *handp)
{
int error;
if (handp == NULL || DSVC_HANDLE_INVAL(*handp))
return (DSVC_INVAL);
if ((*handp)->d_type == DSVC_DHCPTAB)
error = (*handp)->d_api.close_dt(&((*handp)->d_hand));
else
error = (*handp)->d_api.close_dn(&((*handp)->d_hand));
if (error == DSVC_SUCCESS) {
error = unload_public_module(&(*handp)->d_instance,
&(*handp)->d_api);
if ((*handp)->d_synch != NULL)
synch_fini(*handp);
free((*handp)->d_desc.d_resource);
free((*handp)->d_desc.d_location);
free(*handp);
*handp = NULL;
}
return (error);
}
/*
* Searches hand container for records that match the query described by
* the combination of query and targetp. If the partial field is true, then
* lookup operations that have located some records but are unable to
* complete entirely are allowed. The query argument consists of 2 fields,
* each 16 bits long. The lower 16 bits selects which fields in the targetp
* record are to be considered in the query. The upper 16 bits identifies
* whether a particular field value must match (bit set) or not match (bit
* clear). Unused bits in both 16 bit fields must be 0. The count argument
* specifies the maximum number of matching records to return. A count
* value of -1 requests that all matching records be returned. recordsp is
* set to point to the resulting list of records; if recordsp is NULL then
* no records are actually returned. Note that these records are
* dynamically allocated, thus the caller is responsible for freeing them.
* The number of records found is returned in nrecordsp; a value of 0 means
* that no records matched the query.
*/
int
lookup_dd(dsvc_handle_t hand, boolean_t partial, uint_t query,
int count, const void *targetp, void **recordsp, uint_t *nrecordsp)
{
uint_t mask = 0;
int error;
void *unlock_cookie;
int (*lookup)();
if (targetp == NULL || nrecordsp == NULL || DSVC_HANDLE_INVAL(hand))
return (DSVC_INVAL);
if (hand->d_type == DSVC_DHCPTAB) {
mask = (uint_t)~DT_QALL;
lookup = hand->d_api.lookup_dt;
} else {
mask = (uint_t)~DN_QALL;
lookup = hand->d_api.lookup_dn;
}
/* validate query */
if (((query & 0xffff) & mask) || ((query >> 16) & mask))
return (DSVC_INVAL);
/*
* XXX: need to validate the `targetp' -- what a mess cuz only the
* fields lit in `query' need to be valid.
*/
if (hand->d_synch != NULL) {
error = DSVC_SYNCH_RDLOCK(hand->d_synch, &unlock_cookie);
if (error != DSVC_SUCCESS)
return (error);
}
error = lookup(hand->d_hand, partial, query, count, targetp, recordsp,
nrecordsp);
if (hand->d_synch != NULL)
(void) DSVC_SYNCH_UNLOCK(hand->d_synch, unlock_cookie);
return (error);
}
/*
* Frees the record pointed to by entryp.
*/
void
free_dd(dsvc_handle_t hand, void *entryp)
{
if (DSVC_HANDLE_INVAL(hand) || entryp == NULL)
return;
if (hand->d_type == DSVC_DHCPTAB)
free_dtrec((dt_rec_t *)entryp);
else
free_dnrec((dn_rec_t *)entryp);
}
/*
* Frees the list of records pointed to by listp.
*/
void
free_dd_list(dsvc_handle_t hand, void *listp)
{
if (DSVC_HANDLE_INVAL(hand) || listp == NULL)
return;
if (hand->d_type == DSVC_DHCPTAB)
free_dtrec_list((dt_rec_list_t *)listp);
else
free_dnrec_list((dn_rec_list_t *)listp);
}
/*
* Add the record newp to the DHCP container hand. newp's update signature
* will be updated by the public layer module doing the update. Caller is
* responsible for freeing newp if it was dynamically allocated.
*/
int
add_dd_entry(dsvc_handle_t hand, void *newp)
{
int error;
void *unlock_cookie;
if (DSVC_HANDLE_INVAL(hand))
return (DSVC_INVAL);
if (!validate_dd_entry(hand, newp, B_FALSE))
return (DSVC_INVAL);
if (hand->d_synch != NULL) {
error = DSVC_SYNCH_WRLOCK(hand->d_synch, &unlock_cookie);
if (error != DSVC_SUCCESS)
return (error);
}
if (hand->d_type == DSVC_DHCPTAB)
error = hand->d_api.add_dt(hand->d_hand, newp);
else
error = hand->d_api.add_dn(hand->d_hand, newp);
if (hand->d_synch != NULL)
(void) DSVC_SYNCH_UNLOCK(hand->d_synch, unlock_cookie);
return (error);
}
/*
* Modify the record origp with the record newp in the DHCP container hand.
* newp's update signature will be updated by the public layer module doing
* the update. Caller is responsible for freeing origp and/or newp if they
* were dynamically allocated.
*/
int
modify_dd_entry(dsvc_handle_t hand, const void *origp, void *newp)
{
int error;
void *unlock_cookie;
if (DSVC_HANDLE_INVAL(hand))
return (DSVC_INVAL);
if (!validate_dd_entry(hand, origp, B_TRUE))
return (DSVC_INVAL);
if (!validate_dd_entry(hand, newp, B_FALSE))
return (DSVC_INVAL);
if (hand->d_synch != NULL) {
error = DSVC_SYNCH_WRLOCK(hand->d_synch, &unlock_cookie);
if (error != DSVC_SUCCESS)
return (error);
}
if (hand->d_type == DSVC_DHCPTAB)
error = hand->d_api.modify_dt(hand->d_hand, origp, newp);
else
error = hand->d_api.modify_dn(hand->d_hand, origp, newp);
if (hand->d_synch != NULL)
(void) DSVC_SYNCH_UNLOCK(hand->d_synch, unlock_cookie);
return (error);
}
/*
* Deletes the record referred to by entryp from the DHCP container hand.
* Caller is responsible for freeing entryp if it was dynamically
* allocated.
*/
int
delete_dd_entry(dsvc_handle_t hand, void *entryp)
{
int error;
void *unlock_cookie;
if (DSVC_HANDLE_INVAL(hand))
return (DSVC_INVAL);
if (!validate_dd_entry(hand, entryp, B_TRUE))
return (DSVC_INVAL);
if (hand->d_synch != NULL) {
error = DSVC_SYNCH_WRLOCK(hand->d_synch, &unlock_cookie);
if (error != DSVC_SUCCESS)
return (error);
}
if (hand->d_type == DSVC_DHCPTAB)
error = hand->d_api.delete_dt(hand->d_hand, entryp);
else
error = hand->d_api.delete_dn(hand->d_hand, entryp);
if (hand->d_synch != NULL)
(void) DSVC_SYNCH_UNLOCK(hand->d_synch, unlock_cookie);
return (error);
}
/*
* Validate that the DHCP network record `dn' is correctly formed; returns
* B_TRUE if it is, B_FALSE if it's not. If `justkey' is set, then only
* validate the key.
*/
static boolean_t
validate_dnrec(dsvc_handle_t hand, const dn_rec_t *dn, boolean_t justkey)
{
/* CIP must be on container's network */
if (hand->d_conid.c_net.s_addr !=
(dn->dn_cip.s_addr & hand->d_conid.c_mask.s_addr))
return (B_FALSE);
if (justkey)
return (B_TRUE);
if (dn->dn_cid_len < 1 || dn->dn_cid_len > DN_MAX_CID_LEN)
return (B_FALSE);
if ((dn->dn_flags & ~DN_FALL) != 0)
return (B_FALSE);
return (B_TRUE);
}
/*
* Validate that the dhcptab record `dt' is correctly formed; returns
* B_TRUE if it is, B_FALSE if it's not. If `justkey' is set, then only
* validate the key.
*/
/* ARGSUSED */
static boolean_t
validate_dtrec(dsvc_handle_t hand, const dt_rec_t *dt, boolean_t justkey)
{
return (dt->dt_type == DT_SYMBOL || dt->dt_type == DT_MACRO);
}
/*
* Validate that a DHCP record of type `hand->d_type' is correctly formed;
* returns B_TRUE if it is, B_FALSE if it's not. If `justkey' is set, then
* only validate the key.
*/
static boolean_t
validate_dd_entry(dsvc_handle_t hand, const void *entryp, boolean_t justkey)
{
if (entryp == NULL)
return (B_FALSE);
if (hand->d_type == DSVC_DHCPTAB)
return (validate_dtrec(hand, (dt_rec_t *)entryp, justkey));
else if (hand->d_type == DSVC_DHCPNETWORK)
return (validate_dnrec(hand, (dn_rec_t *)entryp, justkey));
return (B_FALSE);
}
/*
* Get the type of synchronization needed for this module and store in
* `synchtypep'. Returns a DSVC_* code. This function is exported so that
* dsvclockd(1M) can use it.
*/
int
module_synchtype(dsvc_datastore_t *ddp, dsvc_synchtype_t *synchtypep)
{
void *instance;
dsvc_splapi_t api;
dsvc_synchtype_t *dsvc_synchtypep;
if (load_public_module(ddp, &instance, &api) != DSVC_SUCCESS)
return (DSVC_INTERNAL);
dsvc_synchtypep = dlsym(instance, "dsvc_synchtype");
if (dsvc_synchtypep != NULL)
*synchtypep = *dsvc_synchtypep;
else
*synchtypep = DSVC_SYNCH_NONE;
(void) unload_public_module(&instance, &api);
return (DSVC_SUCCESS);
}
/*
* Initialize private-layer synchronization on handle `hand' for container
* `conname'; `flags' is the same flags passed into open_dd(). If there's
* no synchronization needed, always succeeds. Returns a DSVC_* code.
*/
int
synch_init(dsvc_handle_t hand, const char *conname, uint_t flags)
{
dsvc_synchtype_t synchtype;
dsvc_synch_t *sp;
int error;
int (*mkloctoken)(const char *, char *, size_t);
error = module_synchtype(&hand->d_desc, &synchtype);
if (error != DSVC_SUCCESS)
return (error);
if (synchtype == DSVC_SYNCH_NONE)
return (DSVC_SUCCESS);
sp = malloc(sizeof (dsvc_synch_t));
if (sp == NULL)
return (DSVC_NO_MEMORY);
sp->s_conname = strdup(conname);
if (sp->s_conname == NULL) {
free(sp);
return (DSVC_NO_MEMORY);
}
sp->s_nonblock = flags & DSVC_NONBLOCK;
sp->s_datastore = &hand->d_desc;
mkloctoken = (int (*)())dlsym(hand->d_instance, "mkloctoken");
if (mkloctoken == NULL) {
(void) strlcpy(sp->s_loctoken, sp->s_datastore->d_location,
sizeof (sp->s_loctoken));
} else {
error = mkloctoken(sp->s_datastore->d_location, sp->s_loctoken,
sizeof (sp->s_loctoken));
if (error != DSVC_SUCCESS) {
free(sp->s_conname);
free(sp);
return (error);
}
}
/*
* The only synchtype supported is DSVC_SYNCH_DSVCD; if this
* changes, we'll need to enhance this.
*/
assert((synchtype & DSVC_SYNCH_STRATMASK) == DSVC_SYNCH_DSVCD);
sp->s_ops = &dsvcd_synch_ops;
error = DSVC_SYNCH_INIT(sp, synchtype & DSVC_SYNCH_FLAGMASK);
if (error != DSVC_SUCCESS) {
free(sp->s_conname);
free(sp);
return (error);
}
hand->d_synch = sp;
return (DSVC_SUCCESS);
}
/*
* Finish using private-layer synchronization on handle `hand'.
*/
void
synch_fini(dsvc_handle_t hand)
{
DSVC_SYNCH_FINI(hand->d_synch);
free(hand->d_synch->s_conname);
free(hand->d_synch);
hand->d_synch = NULL;
}