xref: /titanic_51/usr/src/lib/libslp/clib/SLPOpen.c (revision 7c478bd95313f5f23a4c958a745db2134aa03244)

/*
 * 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) 1999 by Sun Microsystems, Inc.
 * All rights reserved.
 */

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

#include <stdio.h>
#include <stdlib.h>
#include <thread.h>
#include <synch.h>
#include <syslog.h>
#include <arpa/inet.h>
#include <slp-internal.h>
#include <slp_net_utils.h>

SLPError SLPOpen(const char *pcLang, SLPBoolean isAsync, SLPHandle *phSLP) {
	slp_handle_impl_t *hp;

	if (!pcLang || !phSLP) {
		return (SLP_PARAMETER_BAD);
	}

	/* allocate the handle */
	if (!(hp = malloc(sizeof (*hp)))) {
		slp_err(LOG_CRIT, 0, "SLPOpen", "out of memory");
		return (SLP_MEMORY_ALLOC_FAILED);
	}

	/* initialize outcall synchronization */
	hp->pending_outcall = SLP_FALSE;
	(void) mutex_init(&(hp->outcall_lock), NULL, NULL);
	(void) cond_init(&(hp->outcall_cv), NULL, NULL);
	hp->close_on_end = SLP_FALSE;
	hp->consumer_tid = 0;

	/* locale property overrides argument */
	if (!(hp->locale = SLPGetProperty(SLP_CONFIG_LOCALE))) {
		hp->locale = pcLang;
	}
	/* Make sure the language string is under our ownership */
	if (!(hp->locale = strdup(hp->locale))) {
		free(hp);
		slp_err(LOG_CRIT, 0, "SLPOpen", "out of memory");
		return (SLP_MEMORY_ALLOC_FAILED);
	}

	hp->cancel = 0;

	/* Asynchronous operation? */
	if (isAsync)
		hp->async = SLP_TRUE;
	else
		hp->async = SLP_FALSE;

	/* TCP vars -- these are NULL until actually needed */
	hp->tcp_lock = NULL;
	hp->tcp_wait = NULL;
	hp->tcp_ref_cnt = 0;

	/* Consumer / Producer pipe */
	hp->q = NULL;

	/* Interface info, loaded on demand */
	hp->ifinfo = NULL;

	/* force multicast, false by default */
	hp->force_multicast = SLP_FALSE;

	/* internal call, false by default */
	hp->internal_call = SLP_FALSE;

	*phSLP = hp;
	return (SLP_OK);
}

void slp_cleanup_handle(slp_handle_impl_t *hp) {
	/* free the handle */
	if (hp->tcp_lock) free(hp->tcp_lock);
	if (hp->tcp_wait) free(hp->tcp_wait);
	if (hp->ifinfo) {
		slp_free_ifinfo(hp->ifinfo);
		free(hp->ifinfo);
	}
	free((void *) hp->locale);
	free(hp);
}

void SLPClose(SLPHandle hSLP) {
	slp_handle_impl_t *hp = (slp_handle_impl_t *)hSLP;

	if (!hSLP) {
		return;
	}

	/*
	 * If an outcall is pending on this handle:
	 *   If we are being called from a callback resulting
	 *   from the outcall associated with this handle or
	 *   if close_on_end has already been set:
	 *	just set close on end and return -- the cleanup
	 *	will be done when the outcall is finished.
	 *   else
	 *	wait on the outcall cv for the outcall to complete
	 * Proceed with cleanup
	 */
	(void) mutex_lock(&(hp->outcall_lock));
	if (hp->pending_outcall) {
	    /* end the consumer thread */
	    /* this will also kill the producer thread and close net */
	    hp->cancel = 1;
	    if (hp->q) {
		if (slp_enqueue_at_head(hp->q, NULL) != SLP_OK) {
		    goto cleanup;
		}
	    }

	    if (thr_self() == hp->consumer_tid || hp->close_on_end) {
		/* SLPClose called from callback */
		hp->close_on_end = SLP_TRUE;
		(void) mutex_unlock(&(hp->outcall_lock));
		return;
	    }
	    /* else not called from callback; wait for outcall to end */
	    while (hp->pending_outcall) {
		(void) cond_wait(&(hp->outcall_cv), &(hp->outcall_lock));
	    }
	}
	(void) mutex_unlock(&(hp->outcall_lock));

cleanup:
	slp_cleanup_handle(hp);
}