diff --git a/lib/evs.c b/lib/evs.c
index 50a4e6d8..067ad763 100644
--- a/lib/evs.c
+++ b/lib/evs.c
@@ -1,566 +1,563 @@
 /*
  * vi: set autoindent tabstop=4 shiftwidth=4 :
 
  * Copyright (c) 2004-2005 MontaVista Software, Inc.
  * Copyright (c) 2006-2007, 2009 Red Hat, Inc.
  *
  * All rights reserved.
  *
  * Author: Steven Dake (sdake@redhat.com)
  *
  * This software licensed under BSD license, the text of which follows:
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are met:
  *
  * - Redistributions of source code must retain the above copyright notice,
  *   this list of conditions and the following disclaimer.
  * - Redistributions in binary form must reproduce the above copyright notice,
  *   this list of conditions and the following disclaimer in the documentation
  *   and/or other materials provided with the distribution.
  * - Neither the name of the MontaVista Software, Inc. nor the names of its
  *   contributors may be used to endorse or promote products derived from this
  *   software without specific prior written permission.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * Provides an extended virtual synchrony API using the corosync executive
  */
 
 #include <config.h>
 
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <errno.h>
 
 #include <qb/qbipcc.h>
 
 #include <corosync/corotypes.h>
 #include <corosync/corodefs.h>
 #include <corosync/hdb.h>
 
 #include <corosync/evs.h>
 #include <corosync/ipc_evs.h>
 
 #include "util.h"
 
 struct evs_inst {
 	qb_ipcc_connection_t *c;
 	int finalize;
 	evs_callbacks_t callbacks;
 	void *context;
 };
 
 DECLARE_HDB_DATABASE (evs_handle_t_db,NULL);
 
 /*
  * Clean up function for an evt instance (saEvtInitialize) handle
  */
 
 
 /**
  * @defgroup evs_coroipcc The extended virtual synchrony passthrough API
  * @ingroup coroipcc
  *
  * @{
  */
 /**
  * test
  * @param handle The handle of evs initialize
  * @param callbacks The callbacks for evs_initialize
  * @returns EVS_OK
  */
 evs_error_t evs_initialize (
 	evs_handle_t *handle,
 	evs_callbacks_t *callbacks)
 {
 	cs_error_t error;
 	struct evs_inst *evs_inst;
 
 	error = hdb_error_to_cs(hdb_handle_create (&evs_handle_t_db, sizeof (struct evs_inst), handle));
 	if (error != CS_OK) {
 		goto error_no_destroy;
 	}
 
 	error = hdb_error_to_cs(hdb_handle_get (&evs_handle_t_db, *handle, (void *)&evs_inst));
 	if (error != CS_OK) {
 		goto error_destroy;
 	}
 
 	evs_inst->c = qb_ipcc_connect ("evs", IPC_REQUEST_SIZE);
 	if (evs_inst->c == NULL) {
 		error = qb_to_cs_error(-errno);
 		goto error_put_destroy;
 	}
-	if (error != EVS_OK) {
-		goto error_put_destroy;
-	}
 
 	if (callbacks) {
 		memcpy (&evs_inst->callbacks, callbacks, sizeof (evs_callbacks_t));
 	}
 
 	hdb_handle_put (&evs_handle_t_db, *handle);
 
 	return (CS_OK);
 
 error_put_destroy:
 	hdb_handle_put (&evs_handle_t_db, *handle);
 error_destroy:
 	hdb_handle_destroy (&evs_handle_t_db, *handle);
 error_no_destroy:
 	return (error);
 }
 
 evs_error_t evs_finalize (
 	evs_handle_t handle)
 {
 	struct evs_inst *evs_inst;
 	cs_error_t error;
 
 	error = hdb_error_to_cs(hdb_handle_get (&evs_handle_t_db, handle, (void *)&evs_inst));
 	if (error != CS_OK) {
 		return (error);
 	}
 
 	/*
 	 * Another thread has already started finalizing
 	 */
 	if (evs_inst->finalize) {
 		hdb_handle_put (&evs_handle_t_db, handle);
 		return (EVS_ERR_BAD_HANDLE);
 	}
 
 	evs_inst->finalize = 1;
 
 	qb_ipcc_disconnect (evs_inst->c);
 
 	hdb_handle_destroy (&evs_handle_t_db, handle);
 
 	hdb_handle_put (&evs_handle_t_db, handle);
 
 	return (EVS_OK);
 }
 
 evs_error_t evs_fd_get (
 	evs_handle_t handle,
 	int *fd)
 {
 	cs_error_t error;
 	struct evs_inst *evs_inst;
 
 	error = hdb_error_to_cs(hdb_handle_get (&evs_handle_t_db, handle, (void *)&evs_inst));
 	if (error != CS_OK) {
 		return (error);
 	}
 
 	qb_ipcc_fd_get (evs_inst->c, fd);
 
 	hdb_handle_put (&evs_handle_t_db, handle);
 
 	return (CS_OK);
 }
 
 evs_error_t evs_context_get (
 	evs_handle_t handle,
 	void **context)
 {
 	cs_error_t error;
 	struct evs_inst *evs_inst;
 
 	error = hdb_error_to_cs (hdb_handle_get (&evs_handle_t_db, handle, (void *)&evs_inst));
 	if (error != CS_OK) {
 		return (error);
 	}
 
 	*context = evs_inst->context;
 
 	hdb_handle_put (&evs_handle_t_db, handle);
 
 	return (CS_OK);
 }
 
 cs_error_t evs_context_set (
 	evs_handle_t handle,
 	void *context)
 {
 	cs_error_t error;
 	struct evs_inst *evs_inst;
 
 	error = hdb_error_to_cs (hdb_handle_get (&evs_handle_t_db, handle, (void *)&evs_inst));
 	if (error != CS_OK) {
 		return (error);
 	}
 
 	evs_inst->context = context;
 
 	hdb_handle_put (&evs_handle_t_db, handle);
 
 	return (CS_OK);
 }
 
 evs_error_t evs_dispatch (
 	evs_handle_t handle,
 	cs_dispatch_flags_t dispatch_types)
 {
 	int timeout = -1;
 	cs_error_t error;
 	int cont = 1; /* always continue do loop except when set to 0 */
 	struct evs_inst *evs_inst;
 	struct res_evs_confchg_callback *res_evs_confchg_callback;
 	struct res_evs_deliver_callback *res_evs_deliver_callback;
 	evs_callbacks_t callbacks;
 	struct qb_ipc_response_header *dispatch_data;
 	char dispatch_buf[IPC_DISPATCH_SIZE];
 
 	error = hdb_error_to_cs(hdb_handle_get (&evs_handle_t_db, handle, (void *)&evs_inst));
 	if (error != CS_OK) {
 		return (error);
 	}
 
 	/*
 	 * Timeout instantly for CS_DISPATCH_ONE or CS_DISPATCH_ALL and
 	 * wait indefinately for CS_DISPATCH_BLOCKING
 	 */
 	if (dispatch_types == EVS_DISPATCH_ALL) {
 		timeout = 0;
 	}
 
 	dispatch_data = (struct qb_ipc_response_header *)dispatch_buf;
 	do {
 		error = qb_to_cs_error(qb_ipcc_event_recv (
 			evs_inst->c,
 			dispatch_buf,
 			IPC_DISPATCH_SIZE,
 			timeout));
 		if (error == CS_ERR_BAD_HANDLE) {
 			error = CS_OK;
 			goto error_put;
 		}
 		if (error == CS_ERR_TRY_AGAIN) {
 			error = CS_OK;
 			if (dispatch_types == CPG_DISPATCH_ALL) {
 				break; /* exit do while cont is 1 loop */
 			} else {
 				continue; /* next poll */
 			}
 		}
 		if (error != CS_OK) {
 			goto error_put;
 		}
 
 		/*
 		 * Make copy of callbacks, message data, unlock instance, and call callback
 		 * A risk of this dispatch method is that the callback routines may
 		 * operate at the same time that evsFinalize has been called.
 		*/
 		memcpy (&callbacks, &evs_inst->callbacks, sizeof (evs_callbacks_t));
 
 		/*
 		 * Dispatch incoming message
 		 */
 		switch (dispatch_data->id) {
 		case MESSAGE_RES_EVS_DELIVER_CALLBACK:
 			if (callbacks.evs_deliver_fn == NULL) {
 				break;
 			}
 
 			res_evs_deliver_callback = (struct res_evs_deliver_callback *)dispatch_data;
 			callbacks.evs_deliver_fn (
 				handle,
 				res_evs_deliver_callback->local_nodeid,
 				&res_evs_deliver_callback->msg,
 				res_evs_deliver_callback->msglen);
 			break;
 
 		case MESSAGE_RES_EVS_CONFCHG_CALLBACK:
 			if (callbacks.evs_confchg_fn == NULL) {
 				break;
 			}
 
 			res_evs_confchg_callback = (struct res_evs_confchg_callback *)dispatch_data;
 			callbacks.evs_confchg_fn (
 				handle,
 				res_evs_confchg_callback->member_list,
 				res_evs_confchg_callback->member_list_entries,
 				res_evs_confchg_callback->left_list,
 				res_evs_confchg_callback->left_list_entries,
 				res_evs_confchg_callback->joined_list,
 				res_evs_confchg_callback->joined_list_entries,
 				NULL);
 			break;
 
 		default:
 			error = CS_ERR_LIBRARY;
 			goto error_put;
 			break;
 		}
 
 		/*
 		 * Determine if more messages should be processed
 		 */
 		if (dispatch_types == CS_DISPATCH_ONE) {
 			cont = 0;
 		}
 	} while (cont);
 
 error_put:
 	hdb_handle_put (&evs_handle_t_db, handle);
 	return (error);
 }
 
 evs_error_t evs_join (
     evs_handle_t handle,
     const struct evs_group *groups,
     size_t group_entries)
 {
 	evs_error_t error;
 	struct evs_inst *evs_inst;
 	struct iovec iov[2];
 	struct req_lib_evs_join req_lib_evs_join;
 	struct res_lib_evs_join res_lib_evs_join;
 
 	error = hdb_error_to_cs(hdb_handle_get (&evs_handle_t_db, handle, (void *)&evs_inst));
 	if (error != EVS_OK) {
 		return (error);
 	}
 
 	req_lib_evs_join.header.size = sizeof (struct req_lib_evs_join) +
 		(group_entries * sizeof (struct evs_group));
 	req_lib_evs_join.header.id = MESSAGE_REQ_EVS_JOIN;
 	req_lib_evs_join.group_entries = group_entries;
 
 	iov[0].iov_base = (void *)&req_lib_evs_join;
 	iov[0].iov_len = sizeof (struct req_lib_evs_join);
 	iov[1].iov_base = (void*) groups; /* cast away const */
 	iov[1].iov_len = (group_entries * sizeof (struct evs_group));
 
 	error = qb_to_cs_error(qb_ipcc_sendv_recv (evs_inst->c, iov, 2,
 		&res_lib_evs_join, sizeof (struct res_lib_evs_join), -1));
 
 	if (error != CS_OK) {
 		goto error_exit;
 	}
 
 	error = res_lib_evs_join.header.error;
 
 error_exit:
 	hdb_handle_put (&evs_handle_t_db, handle);
 
 	return (error);
 }
 
 evs_error_t evs_leave (
     evs_handle_t handle,
     const struct evs_group *groups,
     size_t group_entries)
 {
 	evs_error_t error;
 	struct evs_inst *evs_inst;
 	struct iovec iov[2];
 	struct req_lib_evs_leave req_lib_evs_leave;
 	struct res_lib_evs_leave res_lib_evs_leave;
 
 	error = hdb_error_to_cs(hdb_handle_get (&evs_handle_t_db, handle, (void *)&evs_inst));
 	if (error != CS_OK) {
 		return (error);
 	}
 
 	req_lib_evs_leave.header.size = sizeof (struct req_lib_evs_leave) +
 		(group_entries * sizeof (struct evs_group));
 	req_lib_evs_leave.header.id = MESSAGE_REQ_EVS_LEAVE;
 	req_lib_evs_leave.group_entries = group_entries;
 
 	iov[0].iov_base = (void *)&req_lib_evs_leave;
 	iov[0].iov_len = sizeof (struct req_lib_evs_leave);
 	iov[1].iov_base = (void *) groups; /* cast away const */
 	iov[1].iov_len = (group_entries * sizeof (struct evs_group));
 
 	error = qb_to_cs_error(qb_ipcc_sendv_recv (evs_inst->c, iov, 2,
 		&res_lib_evs_leave, sizeof (struct res_lib_evs_leave), -1));
 
 	if (error != CS_OK) {
 		goto error_exit;
 	}
 
 	error = res_lib_evs_leave.header.error;
 
 error_exit:
 	hdb_handle_put (&evs_handle_t_db, handle);
 
 	return (error);
 }
 
 evs_error_t evs_mcast_joined (
 	evs_handle_t handle,
 	evs_guarantee_t guarantee,
 	const struct iovec *iovec,
 	unsigned int iov_len)
 {
 	int i;
 	evs_error_t error;
 	struct evs_inst *evs_inst;
 	struct iovec iov[64];
 	struct req_lib_evs_mcast_joined req_lib_evs_mcast_joined;
 	struct res_lib_evs_mcast_joined res_lib_evs_mcast_joined;
 	size_t msg_len = 0;
 
 	error = hdb_error_to_cs(hdb_handle_get (&evs_handle_t_db, handle, (void *)&evs_inst));
 	if (error != CS_OK) {
 		return (error);
 	}
 
 	for (i = 0; i < iov_len; i++ ) {
 		msg_len += iovec[i].iov_len;
 	}
 
 	req_lib_evs_mcast_joined.header.size = sizeof (struct req_lib_evs_mcast_joined) +
 		msg_len;
 
 	req_lib_evs_mcast_joined.header.id = MESSAGE_REQ_EVS_MCAST_JOINED;
 	req_lib_evs_mcast_joined.guarantee = guarantee;
 	req_lib_evs_mcast_joined.msg_len = msg_len;
 
 	iov[0].iov_base = (void *)&req_lib_evs_mcast_joined;
 	iov[0].iov_len = sizeof (struct req_lib_evs_mcast_joined);
 	memcpy (&iov[1], iovec, iov_len * sizeof (struct iovec));
 
 	error = qb_to_cs_error(qb_ipcc_sendv_recv (evs_inst->c, iov,
 		iov_len + 1,
 		&res_lib_evs_mcast_joined,
 		sizeof (struct res_lib_evs_mcast_joined), -1));
 
 	if (error != CS_OK) {
 		goto error_exit;
 	}
 
 	error = res_lib_evs_mcast_joined.header.error;
 
 error_exit:
 	hdb_handle_put (&evs_handle_t_db, handle);
 
 	return (error);
 }
 
 evs_error_t evs_mcast_groups (
 	evs_handle_t handle,
 	evs_guarantee_t guarantee,
 	const struct evs_group *groups,
 	size_t group_entries,
 	const struct iovec *iovec,
 	unsigned int iov_len)
 {
 	int i;
 	evs_error_t error;
 	struct evs_inst *evs_inst;
 	struct iovec iov[64]; /* FIXME: what if iov_len > 62 ?  use malloc */
 	struct req_lib_evs_mcast_groups req_lib_evs_mcast_groups;
 	struct res_lib_evs_mcast_groups res_lib_evs_mcast_groups;
 	size_t msg_len = 0;
 
 	error = hdb_error_to_cs(hdb_handle_get (&evs_handle_t_db, handle, (void *)&evs_inst));
 	if (error != CS_OK) {
 		return (error);
 	}
 	for (i = 0; i < iov_len; i++) {
 		msg_len += iovec[i].iov_len;
 	}
 	req_lib_evs_mcast_groups.header.size = sizeof (struct req_lib_evs_mcast_groups) +
 		(group_entries * sizeof (struct evs_group)) + msg_len;
 	req_lib_evs_mcast_groups.header.id = MESSAGE_REQ_EVS_MCAST_GROUPS;
 	req_lib_evs_mcast_groups.guarantee = guarantee;
 	req_lib_evs_mcast_groups.msg_len = msg_len;
 	req_lib_evs_mcast_groups.group_entries = group_entries;
 
 	iov[0].iov_base = (void *)&req_lib_evs_mcast_groups;
 	iov[0].iov_len = sizeof (struct req_lib_evs_mcast_groups);
 	iov[1].iov_base = (void *) groups; /* cast away const */
 	iov[1].iov_len = (group_entries * sizeof (struct evs_group));
 	memcpy (&iov[2], iovec, iov_len * sizeof (struct iovec));
 
 	error = qb_to_cs_error(qb_ipcc_sendv_recv (evs_inst->c, iov,
 		iov_len + 2,
 		&res_lib_evs_mcast_groups,
 		sizeof (struct res_lib_evs_mcast_groups), -1));
 
 	if (error != CS_OK) {
 		goto error_exit;
 	}
 
 	error = res_lib_evs_mcast_groups.header.error;
 
 error_exit:
 	hdb_handle_put (&evs_handle_t_db, handle);
 
 	return (error);
 }
 
 evs_error_t evs_membership_get (
 	evs_handle_t handle,
 	unsigned int *local_nodeid,
 	unsigned int *member_list,
 	size_t *member_list_entries)
 {
 	evs_error_t error;
 	struct evs_inst *evs_inst;
 	struct iovec iov;
 	struct req_lib_evs_membership_get req_lib_evs_membership_get;
 	struct res_lib_evs_membership_get res_lib_evs_membership_get;
 
 	error = hdb_error_to_cs(hdb_handle_get (&evs_handle_t_db, handle, (void *)&evs_inst));
 	if (error != CS_OK) {
 		return (error);
 	}
 
 	req_lib_evs_membership_get.header.size = sizeof (struct req_lib_evs_membership_get);
 	req_lib_evs_membership_get.header.id = MESSAGE_REQ_EVS_MEMBERSHIP_GET;
 
 	iov.iov_base = (void *)&req_lib_evs_membership_get;
 	iov.iov_len = sizeof (struct req_lib_evs_membership_get);
 
 	error = qb_to_cs_error(qb_ipcc_sendv_recv (evs_inst->c,
 		&iov,
 		1,
 		&res_lib_evs_membership_get,
 		sizeof (struct res_lib_evs_membership_get), -1));
 
 	if (error != CS_OK) {
 		goto error_exit;
 	}
 
 	error = res_lib_evs_membership_get.header.error;
 
 	/*
 	 * Copy results to caller
 	 */
 	if (local_nodeid) {
 		*local_nodeid = res_lib_evs_membership_get.local_nodeid;
  	}
 	*member_list_entries = QB_MIN (*member_list_entries,
 				    res_lib_evs_membership_get.member_list_entries);
 	if (member_list) {
 		memcpy (member_list, &res_lib_evs_membership_get.member_list,
 			*member_list_entries * sizeof (struct in_addr));
 	}
 
 error_exit:
 	hdb_handle_put (&evs_handle_t_db, handle);
 
 	return (error);
 }
 
 /** @} */