dbus_mgr.c   [plain text]

/* dbus_mgr.c
 *
 *  named module to provide dynamic forwarding zones in 
 *  response to D-BUS dhcp events or commands.
 *
 *  Copyright(C) Jason Vas Dias, Red Hat Inc., 2005
 *  Modified by Adam Tkac, Red Hat Inc., 2007
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation at 
 *           http://www.fsf.org/licensing/licenses/gpl.txt
 *  and included in this software distribution as the "LICENSE" file.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 */
#include <config.h>
#include <isc/types.h>
#include <isc/net.h>
#include <isc/mem.h>
#include <isc/magic.h>
#include <isc/list.h>
#include <isc/task.h>
#include <isc/event.h>
#include <isc/socket.h>
#include <isc/timer.h>
#include <isc/netaddr.h>
#include <isc/sockaddr.h>
#include <isc/buffer.h>
#include <isc/log.h>

#include <dns/name.h>
#include <dns/acl.h>
#include <dns/fixedname.h>
#include <dns/view.h>
#include <dns/forward.h>

#include <named/types.h>
#include <named/config.h>
#include <named/server.h>
#include <named/globals.h>
#include <named/log.h>

#include <named/dbus_service.h>
#include <named/dbus_mgr.h>

#include <string.h>
#include <search.h>

typedef void (*__free_fn_t) (void *__nodep);
extern void tdestroy (void *__root, __free_fn_t __freefct);
extern void free(void*);

#ifdef ISC_USE_INTERNAL_MALLOC
#  if  ISC_USE_INTERNAL_MALLOC
#      error dbus_mgr cannot be used if ISC_USE_INTERNAL_MALLOC==1
#  endif
#endif

#define DBUSMGR_DESTINATION  "com.redhat.named"
#define DBUSMGR_OBJECT_PATH "/com/redhat/named"
#define DBUSMGR_INTERFACE    "com.redhat.named"

#define DBUSMGR_MAGIC	ISC_MAGIC('D', 'B', 'U', 'S')

struct ns_dbus_mgr
{
    unsigned int        magic;
    isc_mem_t         *	mctx;		/* Memory context. */
    isc_taskmgr_t     * taskmgr;	/* Task manager.   */
    isc_socketmgr_t   *	socketmgr;	/* Socket manager. */   
    isc_timermgr_t    *	timermgr;	/* Timer manager.  */   
    isc_task_t        * task;           /* task            */
    isc_timer_t       * timer;          /* dbus_init retry */
    void              * sockets;        /* dbus fd tree    */ 
    void              * dhc_if;         /* dhcp interface tree */
    void              * ifwdt;          /* initial forwarder tree */
    char              * dhcdbd_name;    /* dhcdbd destination  */
    DBUS_SVC            dbus;	        /* dbus handle */
};

typedef
struct dbus_mgr_sock_s
{
    int fd;
    struct ns_dbus_mgr *mgr;
    isc_socket_t *sock;
    isc_socketevent_t *ser;
    isc_socketevent_t *sew;
    isc_socketevent_t *sel;
} DBusMgrSocket;

typedef
enum dhc_state_e
{
   DHC_NBI,         	/* no broadcast interfaces found */
   DHC_PREINIT, 	/* configuration started   */
   DHC_BOUND, 		/* lease obtained          */
   DHC_RENEW, 		/* lease renewed           */
   DHC_REBOOT,	        /* have valid lease, but now obtained a different one */
   DHC_REBIND, 		/* new, different lease */
   DHC_STOP,  		/* remove old lease */
   DHC_MEDIUM, 		/* media selection begun */
   DHC_TIMEOUT, 	/* timed out contacting DHCP server */
   DHC_FAIL, 		/* all attempts to contact server timed out, sleeping */
   DHC_EXPIRE, 		/* lease has expired, renewing */
   DHC_RELEASE, 	/* releasing lease */
   DHC_START,           /* sent when dhclient started OK */
   DHC_ABEND,  		/* dhclient exited abnormally    */
   DHC_END, 		/* dhclient exited normally      */
   DHC_END_OPTIONS,     /* last option in subscription sent */
   DHC_INVALID=255      
} DHC_State;

typedef ISC_LIST(dns_name_t) DNSNameList;

typedef ISC_LIST(isc_sockaddr_t) SockAddrList;

typedef struct dbm_fwdr_s
{
    dns_fwdpolicy_t fwdpolicy;
    dns_name_t       dn;
    SockAddrList     sa;
    ISC_LINK( struct dbm_fwdr_s ) link;
} DBusMgrInitialFwdr;

typedef
struct dhc_if_s
{
    char           *if_name;
    DHC_State      dhc_state;
    DHC_State      previous_state;
    struct in_addr ip;
    struct in_addr subnet_mask;
    DNSNameList    dn;
    SockAddrList   dns;
} DHC_IF;

static void 
dbus_mgr_watch_handler( int fd, dbus_svc_WatchFlags flags, void *mgrp );

static
dbus_svc_HandlerResult 
dbus_mgr_message_handler
(  
    DBusMsgHandlerArgs
);

static
void dbus_mgr_close_socket( const void *p, const VISIT which, const int level);

static
void dbus_mgr_destroy_socket( void *p );

static
void dbus_mgr_free_dhc( void *p );

static void
dbus_mgr_watches_selected(isc_task_t *t, isc_event_t *ev);

static isc_result_t
dbus_mgr_init_dbus(ns_dbus_mgr_t *);

static isc_result_t
dbus_mgr_record_initial_fwdtable(ns_dbus_mgr_t *);

static
dns_fwdtable_t *dbus_mgr_get_fwdtable(void);

static void
dbus_mgr_free_initial_fwdtable(ns_dbus_mgr_t *);

static 
uint8_t dbus_mgr_subscribe_to_dhcdbd( ns_dbus_mgr_t * );

static 
void dbus_mgr_dbus_shutdown_handler ( ns_dbus_mgr_t * );

static
int dbus_mgr_log_err( const char *fmt, ...)
{
    va_list  va;
    va_start(va, fmt);
    isc_log_vwrite(ns_g_lctx,		  
		   NS_LOGCATEGORY_DBUS,
		   NS_LOGMODULE_DBUS,	
		   ISC_LOG_NOTICE,
		   fmt, va
	          );
    va_end(va);
    return 0;
}

static
int dbus_mgr_log_dbg( const char *fmt, ...)
{
    va_list  va;
    va_start(va, fmt);
    isc_log_vwrite(ns_g_lctx,		  
		   NS_LOGCATEGORY_DBUS,
		   NS_LOGMODULE_DBUS,	
		   ISC_LOG_DEBUG(80),
		   fmt, va
	          );
    va_end(va);
    return 0;
}

static
int dbus_mgr_log_info( const char *fmt, ...)
{
    va_list  va;
    va_start(va, fmt);
    isc_log_vwrite(ns_g_lctx,		  
		   NS_LOGCATEGORY_DBUS,
		   NS_LOGMODULE_DBUS,	
		   ISC_LOG_DEBUG(1),
		   fmt, va
	          );
    va_end(va);
    return 0;
}

isc_result_t 
dbus_mgr_create
(   isc_mem_t *mctx, 
    isc_taskmgr_t *taskmgr,
    isc_socketmgr_t *socketmgr,
    isc_timermgr_t *timermgr,
    ns_dbus_mgr_t **dbus_mgr
)
{
    isc_result_t result;
    ns_dbus_mgr_t *mgr;
    
    *dbus_mgr = 0L; 

    mgr = isc_mem_get(mctx, sizeof(*mgr));
    if (mgr == NULL)
	return (ISC_R_NOMEMORY);

    mgr->magic = DBUSMGR_MAGIC;
    mgr->mctx = mctx;
    mgr->taskmgr = taskmgr;
    mgr->socketmgr = socketmgr;
    mgr->timermgr = timermgr;
    mgr->task = 0L;
    mgr->sockets = 0L;
    mgr->timer = 0L;
    mgr->dhc_if = 0L;
    mgr->ifwdt = 0L;
    mgr->dhcdbd_name = 0L;

    if( (result = isc_task_create( taskmgr, 100, &(mgr->task)))
        != ISC_R_SUCCESS
      )	goto cleanup_mgr;
    
    isc_task_setname( mgr->task, "dbusmgr", mgr );

    mgr->dbus = 0L;

    if( (result = dbus_mgr_record_initial_fwdtable( mgr ))
	!= ISC_R_SUCCESS
      )	goto cleanup_mgr;

    if( (result = dbus_mgr_init_dbus( mgr ))
	!= ISC_R_SUCCESS 
      )	goto cleanup_mgr;     

    *dbus_mgr = mgr; 
   
    return ISC_R_SUCCESS;

 cleanup_mgr:
    if ( dbus_mgr_get_fwdtable() != NULL)
	dbus_mgr_free_initial_fwdtable (mgr);
    if( mgr->task != 0L )
	isc_task_detach(&(mgr->task));
    isc_mem_put(mctx, mgr, sizeof(*mgr));
    return (result);
}

static isc_result_t
dbus_mgr_init_dbus(ns_dbus_mgr_t * mgr)
{
    char destination[]=DBUSMGR_DESTINATION;
    isc_result_t result;

    if( mgr->sockets != 0L )
    {
	isc_task_purgerange(mgr->task, 0L, ISC_SOCKEVENT_READ_READY, ISC_SOCKEVENT_SELECTED, 0L);
	twalk(mgr->sockets, dbus_mgr_close_socket);
	tdestroy(mgr->sockets, dbus_mgr_destroy_socket);
	mgr->sockets = 0L;
    }

    if( mgr->dbus != 0L )
    {
	dbus_svc_shutdown(mgr->dbus);
	mgr->dbus = 0L;
    }

    result = dbus_svc_init(DBUS_PRIVATE_SYSTEM, destination, &mgr->dbus,
					dbus_mgr_watch_handler, 0L, 0L, mgr);

    if(result != ISC_R_SUCCESS)
	goto cleanup;

    if( mgr->dbus == 0L )
    {
	if( mgr->timer == 0L)
	{
	    isc_task_purgerange(mgr->task, 0L, ISC_SOCKEVENT_READ_READY, ISC_SOCKEVENT_SELECTED, 0L);
	    if( mgr->sockets != 0L )
	    {
		twalk(mgr->sockets, dbus_mgr_close_socket);
		tdestroy(mgr->sockets, dbus_mgr_destroy_socket);
		mgr->sockets = 0L;
	    }
	    dbus_mgr_dbus_shutdown_handler (  mgr );
	    return ISC_R_SUCCESS;
	}
	goto cleanup;
    }

    if( !dbus_svc_add_filter
	( mgr->dbus, dbus_mgr_message_handler, mgr, 4,
	  "type=signal,path=/org/freedesktop/DBus,member=NameOwnerChanged",
	  "type=signal,path=/org/freedesktop/DBus/Local,member=Disconnected",
	  "type=signal,interface=com.redhat.dhcp.subscribe.binary",
	  "type=method_call,destination=com.redhat.named,path=/com/redhat/named" 	 
	)
      )
    {
	dbus_mgr_log_err( "dbus_svc_add_filter failed" );
	goto cleanup;
    }
    
    if( mgr->timer != 0L )
    {
	isc_timer_reset(mgr->timer,
			isc_timertype_inactive,
			NULL, NULL, ISC_TRUE
	               );
    }

    if( !dbus_mgr_subscribe_to_dhcdbd( mgr ) )
	dbus_mgr_log_err("D-BUS dhcdbd subscription disabled.");

    dbus_mgr_log_err("D-BUS service enabled.");
    return ISC_R_SUCCESS;

 cleanup:
    isc_task_purgerange(mgr->task, 0L, ISC_SOCKEVENT_READ_READY, ISC_SOCKEVENT_SELECTED, 0L);
    twalk(mgr->sockets, dbus_mgr_close_socket);
    tdestroy(mgr->sockets, dbus_mgr_destroy_socket);
    mgr->sockets = 0L;
    if( mgr->dbus )
    {
	dbus_svc_shutdown(mgr->dbus);
	mgr->dbus = 0L;
    }
    return ISC_R_FAILURE;
}

static 
uint8_t dbus_mgr_subscribe_to_dhcdbd( ns_dbus_mgr_t *mgr )
{
    DBUS_SVC dbus = mgr->dbus;
    char subs[1024], path[1024], 
	dhcdbd_destination[]="com.redhat.dhcp", *ddp[1]={ &(dhcdbd_destination[0]) },
	*dhcdbd_name=0L;
    const char *options[] = { "reason", "ip-address", "subnet-mask", 
			      "domain-name", "domain-name-servers" 
                            };
    dbus_svc_MessageHandle msg;
    int i, n_opts = 5;

    if( mgr->dhcdbd_name == 0L )
    {
	msg = dbus_svc_call
	      ( dbus,
		"org.freedesktop.DBus",
		"/org/freedesktop/DBus",
		"GetNameOwner",		
		"org.freedesktop.DBus",
		TYPE_STRING, &ddp,
		TYPE_INVALID
	       );
	if( msg == 0L )	
	    return 0;    

	if( !dbus_svc_get_args(dbus, msg,
			       TYPE_STRING, &(dhcdbd_name),
			       TYPE_INVALID
		              ) 
	  )	return 0;

	mgr->dhcdbd_name = isc_mem_get(mgr->mctx, strlen(dhcdbd_name) + 1);
	if( mgr->dhcdbd_name == 0L )
	    return 0;

	strcpy(mgr->dhcdbd_name, dhcdbd_name);

    }

    sprintf(path,"/com/redhat/dhcp/subscribe");    
    sprintf(subs,"com.redhat.dhcp.binary");

    for(i = 0; i < n_opts; i++)
    {
	msg = dbus_svc_call
	      ( dbus,
		"com.redhat.dhcp",
		path,
		"binary",		
		subs,		
		TYPE_STRING, &(options[i]),
		TYPE_INVALID
	      );
	if(msg == 0L)
	    return 0;
	if ( dbus_svc_message_type( msg ) == ERROR )
	    return 0;
    }
    dbus_mgr_log_err("D-BUS dhcdbd subscription enabled.");
    return 1;
}

void 
dbus_mgr_shutdown
(   ns_dbus_mgr_t *mgr
)
{
    if( mgr->timer != 0L )
	isc_timer_detach(&(mgr->timer));
    if( mgr->dbus != 0L )
    {
	isc_task_purgerange(mgr->task, 0L, ISC_SOCKEVENT_READ_READY, ISC_SOCKEVENT_SELECTED, 0L);
	if( mgr->sockets != 0L )
	{
	    twalk(mgr->sockets, dbus_mgr_close_socket);
	    tdestroy(mgr->sockets, dbus_mgr_destroy_socket);
	    mgr->sockets = 0L;
	}
	dbus_svc_shutdown(mgr->dbus);
    }
    if( mgr->dhc_if != 0L )
	tdestroy(mgr->dhc_if, dbus_mgr_free_dhc);
    if( mgr->dhcdbd_name != 0L )
	isc_mem_put(mgr->mctx, mgr->dhcdbd_name, strlen(mgr->dhcdbd_name) + 1);
    isc_task_detach(&(mgr->task));
    dbus_mgr_free_initial_fwdtable(mgr);
    isc_mem_put(mgr->mctx, mgr, sizeof(ns_dbus_mgr_t));
}

static 
void dbus_mgr_restart_dbus(isc_task_t *t, isc_event_t *ev)
{   
    ns_dbus_mgr_t *mgr = (ns_dbus_mgr_t*)(ev->ev_arg) ;
    t=t;    
    isc_event_free(&ev);
    dbus_mgr_log_dbg("attempting to connect to D-BUS");
    dbus_mgr_init_dbus( mgr );
}

static
void dbus_mgr_handle_dbus_shutdown_event(isc_task_t *t, isc_event_t *ev)
{
    ns_dbus_mgr_t *mgr = ev->ev_arg;
    isc_time_t     tick={10,0};
    isc_interval_t tock={10,0};
    DBUS_SVC dbus = mgr->dbus;
    t = t;

    mgr->dbus = 0L;

    isc_event_free(&ev);

    if ( dbus != 0L )
    {
	isc_task_purgerange(mgr->task, 0L, ISC_SOCKEVENT_READ_READY, ISC_SOCKEVENT_SELECTED, 0L);
	if( mgr->sockets != 0L )
	{
	    twalk(mgr->sockets, dbus_mgr_close_socket);
	    tdestroy(mgr->sockets, dbus_mgr_destroy_socket);
	    mgr->sockets = 0L;
	}
	dbus_svc_shutdown(dbus);    
    }

    dbus_mgr_log_err( "D-BUS service disabled." );

    if( mgr->timer != 0L )
    {
	isc_timer_reset(mgr->timer,
			isc_timertype_ticker,
			&tick, &tock, ISC_TRUE
	               );
    }else
    if( isc_timer_create
	(   mgr->timermgr,
	    isc_timertype_ticker,
	    &tick, &tock,
	    mgr->task,
	    dbus_mgr_restart_dbus,
	    mgr,
	    &(mgr->timer)
	) != ISC_R_SUCCESS
      )
    {
	dbus_mgr_log_err( "D-BUS service cannot be restored." );
    }
}

static 
void dbus_mgr_dbus_shutdown_handler ( ns_dbus_mgr_t *mgr )
{ 
    isc_event_t *dbus_shutdown_event = 
	isc_event_allocate
	(   mgr->mctx, 
	    mgr->task, 
	    1,
	    dbus_mgr_handle_dbus_shutdown_event,
	    mgr,
	    sizeof(isc_event_t)
	 );
    if( dbus_shutdown_event != 0L )
    {
	isc_task_purgerange(mgr->task, 0L, ISC_SOCKEVENT_READ_READY, ISC_SOCKEVENT_SELECTED, 0L);
	isc_task_send( mgr->task, &dbus_shutdown_event );
    }else
	dbus_mgr_log_err("unable to allocate dbus shutdown event");
}

static
dns_view_t *dbus_mgr_get_localhost_view(void)
{
    dns_view_t       *view;
    isc_netaddr_t    localhost = { AF_INET, { { htonl( ( 127 << 24 ) | 1 ) } }, 0 };
    int              match;

    for (view = ISC_LIST_HEAD(ns_g_server->viewlist);
	 view != NULL;
	 view = ISC_LIST_NEXT(view, link)
        )
    {	
	/* return first view matching "localhost" source and dest */

	if(( (view->matchclients != 0L )   /* 0L: accept "any" */
	   &&(( dns_acl_match( &localhost, 
			     NULL, /* unsigned queries */
			     view->matchclients,
		  	     &(ns_g_server->aclenv),
			     &match, 
			     NULL  /* no match list */
		            ) != ISC_R_SUCCESS
	      ) || (match <= 0)
	     )
	    ) 
	 ||( (view->matchdestinations != 0L )   /* 0L: accept "any" */
	   &&(( dns_acl_match( &localhost, 
			     NULL, /* unsigned queries */
			     view->matchdestinations,
		  	     &(ns_g_server->aclenv),
			     &match, 
			     NULL  /* no match list */
		            ) != ISC_R_SUCCESS
	      ) || (match <= 0)
	     )
	    )
	  ) continue;	
	
	break;
    }
    return view;
}

static
dns_fwdtable_t *dbus_mgr_get_fwdtable(void)
{
    dns_view_t *view = dbus_mgr_get_localhost_view();
    if( view != 0L )
	return view->fwdtable;
    return 0L;
}

static
dns_fwdtable_t *dbus_mgr_get_view_and_fwdtable( dns_view_t **viewp )
{
    *viewp = dbus_mgr_get_localhost_view();
    if( *viewp != 0L )
	return (*viewp)->fwdtable;
    return 0L;
}

static int dbus_mgr_ifwdr_comparator( const void *p1, const void *p2 )
{
    char  n1buf[ DNS_NAME_FORMATSIZE ]="", *n1p=&(n1buf[0]),
	  n2buf[ DNS_NAME_FORMATSIZE ]="", *n2p=&(n2buf[0]);
    dns_name_t *dn1;
    dns_name_t *dn2;
    DE_CONST(&(((const DBusMgrInitialFwdr*)p1)->dn), dn1);
    DE_CONST(&(((const DBusMgrInitialFwdr*)p2)->dn), dn2);
    dns_name_format(dn1, n1p, DNS_NAME_FORMATSIZE );    
    dns_name_format(dn2, n2p, DNS_NAME_FORMATSIZE );    
    return strcmp(n1buf, n2buf);
}

static int dbus_mgr_dhc_if_comparator( const void *p1, const void *p2 );

static void dbus_mgr_record_initial_forwarder( dns_name_t *name, dns_forwarders_t *fwdr, void *mp )
{
    ns_dbus_mgr_t *mgr = mp;
    isc_sockaddr_t *sa, *nsa;
    DBusMgrInitialFwdr *ifwdr;
 
    if( ISC_LIST_HEAD(fwdr->addrs) == 0L) 
	return;

    if( (ifwdr = isc_mem_get(mgr->mctx, sizeof(DBusMgrInitialFwdr))) == 0L)
	return;

    ifwdr->fwdpolicy = fwdr->fwdpolicy;

    dns_name_init(&(ifwdr->dn), NULL);
    if( dns_name_dupwithoffsets(name, mgr->mctx, &(ifwdr->dn)) != ISC_R_SUCCESS )
	goto namedup_err;

    ISC_LIST_INIT(ifwdr->sa);
    
    for( sa = ISC_LIST_HEAD(fwdr->addrs);
	 sa != 0L;
	 sa = ISC_LIST_NEXT(sa,link)
       )
    {
	nsa = isc_mem_get(mgr->mctx, sizeof(isc_sockaddr_t));
	if( nsa == 0L ) 
	    goto nsa_err;
	*nsa = *sa;
	ISC_LINK_INIT(nsa, link);
	ISC_LIST_APPEND(ifwdr->sa, nsa, link);
    }
    ISC_LINK_INIT(ifwdr, link);
    tsearch( ifwdr, &(mgr->ifwdt), dbus_mgr_ifwdr_comparator);

    return;

nsa_err:
    while ( (sa = ISC_LIST_HEAD (ifwdr->sa)) != NULL) {
	ISC_LIST_UNLINK (ifwdr->sa, sa, link);
	isc_mem_put (mgr->mctx, sa, sizeof (*sa));
    }

namedup_err:
    isc_mem_put (mgr->mctx, ifwdr, sizeof (*ifwdr));

    return;
}

static isc_result_t
dbus_mgr_record_initial_fwdtable( ns_dbus_mgr_t *mgr )
{
    dns_fwdtable_t *fwdtable = dbus_mgr_get_fwdtable();
    
    if( fwdtable == 0L )
	return ISC_R_SUCCESS; /* no initial fwdtable */
    dns_fwdtable_foreach( fwdtable, dbus_mgr_record_initial_forwarder, mgr);
    return ISC_R_SUCCESS;
}

static void
dbus_mgr_free_initial_forwarder( void *p )
{
   DBusMgrInitialFwdr *ifwdr = p;
   isc_sockaddr_t *sa;

   dns_name_free(&(ifwdr->dn), ns_g_mctx);
   for( sa = ISC_LIST_HEAD( ifwdr->sa );
	sa != 0L;
	sa = ISC_LIST_HEAD( ifwdr->sa )
      )
   {
       if( ISC_LINK_LINKED(sa, link) )
	   ISC_LIST_UNLINK(ifwdr->sa, sa, link);
       isc_mem_put(ns_g_mctx, sa, sizeof(isc_sockaddr_t));
   }
   isc_mem_put(ns_g_mctx, ifwdr, sizeof(DBusMgrInitialFwdr));
}

static void
dbus_mgr_free_initial_fwdtable( ns_dbus_mgr_t *mgr )
{
    tdestroy(mgr->ifwdt, dbus_mgr_free_initial_forwarder);
    mgr->ifwdt = 0L;
}

static void
dbus_mgr_log_forwarders( const char *pfx, dns_name_t *name, SockAddrList *saList)
{
    isc_sockaddr_t   *sa;
    char nameP[DNS_NAME_FORMATSIZE], addrP[128];
    int s=0;
    dns_name_format(name, nameP, DNS_NAME_FORMATSIZE );    
    for( sa = ISC_LIST_HEAD(*saList);
	 sa != 0L;
	 sa = ISC_LIST_NEXT(sa,link)
	)
    {
	isc_sockaddr_format(sa, addrP, 128);
	dbus_mgr_log_info("%s zone %s server %d: %s", pfx, nameP, s++, addrP);
    }		
}

static
isc_result_t dbus_mgr_set_forwarders
(   
    ns_dbus_mgr_t *mgr,
    DNSNameList *nameList,
    SockAddrList *saList,
    dns_fwdpolicy_t fwdpolicy
)
{
    isc_result_t   result = ISC_R_SUCCESS;    
    dns_fwdtable_t *fwdtable;
    dns_view_t     *view=0L;
    dns_name_t     *dnsName;
    isc_sockaddr_t   *sa, *nsa;
    dns_forwarders_t *fwdr=0L;

    fwdtable = dbus_mgr_get_view_and_fwdtable(&view);

    if( fwdtable == 0L )
    {
	if( ISC_LIST_HEAD(*saList) == 0L )
	    return ISC_R_SUCCESS;/* deletion not required */

	view = dbus_mgr_get_localhost_view();
	if( view == 0L )
	    return ISC_R_NOPERM; /* if configuration does not allow localhost clients,
				  * then we really shouldn't be creating a forwarding table.
				  */
	result = isc_task_beginexclusive(mgr->task);

	if( result == ISC_R_SUCCESS )
	{
	    result = dns_fwdtable_create( mgr->mctx, &(view->fwdtable) );

	    isc_task_endexclusive(mgr->task);

	    if( result != ISC_R_SUCCESS )
		return result;

	    if( view->fwdtable == 0L )
		return ISC_R_NOMEMORY;

	    if( isc_log_getdebuglevel(ns_g_lctx) >= 1 )
		dbus_mgr_log_info("Created forwarder table.");
	}
    }
	
    for( dnsName = ISC_LIST_HEAD(*nameList);
	 dnsName != NULL;
	 dnsName = ISC_LIST_NEXT(dnsName,link)
	)
    {   	
	fwdr = 0L;
	if( ( dns_fwdtable_find_exact( fwdtable, dnsName, &fwdr ) != ISC_R_SUCCESS )
	  ||( fwdr == 0L )
	  )
	{ 
	    if( ISC_LIST_HEAD( *saList )  == 0L )
		continue;
	   /* no forwarders for name - add forwarders */

	    result = isc_task_beginexclusive(mgr->task);

	    if( result == ISC_R_SUCCESS )
	    {
		result = dns_fwdtable_add( fwdtable, dnsName, 
					   (isc_sockaddrlist_t*)saList, 
					   fwdpolicy
					 ) ;

		if( view != 0L )
		    dns_view_flushcache( view );

		isc_task_endexclusive(mgr->task);	

		if( result != ISC_R_SUCCESS )
		    return result;

		if( isc_log_getdebuglevel(ns_g_lctx) >= 1 )
		    dbus_mgr_log_forwarders("Created forwarder",dnsName, saList);
	    }
	    continue;
	}

	if( ISC_LIST_HEAD( *saList ) == 0L )
	{ /* empty forwarders list - delete forwarder entry */

	    if( isc_log_getdebuglevel(ns_g_lctx) >= 1 )
		dbus_mgr_log_forwarders("Deleting forwarder", dnsName, (SockAddrList*)&(fwdr->addrs));

	    result = isc_task_beginexclusive(mgr->task);
	    if( result == ISC_R_SUCCESS )
	    {
		result = dns_fwdtable_delete( fwdtable, dnsName );

		if( view != 0L )
		    dns_view_flushcache( view );

		isc_task_endexclusive(mgr->task);

		if( result != ISC_R_SUCCESS )
		    return result;	
	    }
	    continue;
	}	

	result = isc_task_beginexclusive(mgr->task);

	if( result == ISC_R_SUCCESS )
	{	 	   
	    fwdr->fwdpolicy = fwdpolicy;

	    if( isc_log_getdebuglevel(ns_g_lctx) >= 1 )
		dbus_mgr_log_forwarders("Removing forwarder", dnsName, (SockAddrList*)&(fwdr->addrs));
	    
	    for( sa = ISC_LIST_HEAD(fwdr->addrs);
		 sa != 0L ;
		 sa = ISC_LIST_HEAD(fwdr->addrs)
	       )
	    {
		if( ISC_LINK_LINKED(sa, link) )
		    ISC_LIST_UNLINK(fwdr->addrs, sa, link);
		isc_mem_put(mgr->mctx, sa, sizeof(isc_sockaddr_t));
	    }

	    ISC_LIST_INIT( fwdr->addrs );
	    
	    for( sa = ISC_LIST_HEAD(*saList);
		 sa != 0L;
		 sa = ISC_LIST_NEXT(sa,link)
	       )
	    {
		nsa = isc_mem_get(mgr->mctx, sizeof(isc_sockaddr_t));
		if( nsa == 0L )
		{
		    result = ISC_R_NOMEMORY;
		    break;
		}
		*nsa = *sa;
		ISC_LINK_INIT( nsa, link );
		ISC_LIST_APPEND( fwdr->addrs, nsa, link );
	    }	    

	    if( view != 0L )
		dns_view_flushcache( view );

	    isc_task_endexclusive(mgr->task);

	    if( isc_log_getdebuglevel(ns_g_lctx) >= 1 )
		dbus_mgr_log_forwarders("Added forwarder", dnsName, (SockAddrList*)&(fwdr->addrs));

	}else
	    return result;

    }
    return (result);
}

static void
dbus_mgr_get_name_list
( 
    ns_dbus_mgr_t *mgr,
    char *domains, 
    DNSNameList *nameList,
    char *error_name,
    char *error_message
)
{
    char *name, *endName, *endp;
    dns_fixedname_t *fixedname;
    dns_name_t      *dnsName;
    isc_buffer_t     buffer;
    isc_result_t     result;
    uint32_t total_length;
    
    total_length = strlen(domains);
    endp = domains + total_length;

    ISC_LIST_INIT( *nameList );

    for( name =   domains + strspn(domains," \t\n"),
	 endName = name + strcspn(name," \t\n");
	 (name < endp) && (endName <= endp); 
	 name =  endName + 1 + strspn(endName+1," \t\n"),
	 endName = name + strcspn(name," \t\n")
       )
    {  /* name loop */
	*endName = '\0';

	isc_buffer_init( &buffer, name, endName - name );
	isc_buffer_add(&buffer, endName - name);		
	
	fixedname = isc_mem_get( mgr->mctx, sizeof( dns_fixedname_t ));

	dns_fixedname_init(fixedname);

	dnsName = dns_fixedname_name(fixedname);

	result= dns_name_fromtext
	        (  dnsName, &buffer, ( *(endp-1) != '.') ? dns_rootname : NULL, 0, NULL
		); 

	if( result != ISC_R_SUCCESS )
	{
	    sprintf(error_name, "com.redhat.named.InvalidArgument");
	    sprintf(error_message,"Invalid DNS name initial argument: %s", name);
	    
	    isc_mem_put( mgr->mctx, fixedname, sizeof( dns_fixedname_t ) );

	    for( dnsName = ISC_LIST_HEAD( *nameList );
		 (dnsName != 0L);
		 dnsName = ISC_LIST_HEAD( *nameList )
	       )
	    {
		if( ISC_LINK_LINKED(dnsName,link) )
		    ISC_LIST_DEQUEUE( *nameList, dnsName, link );
		isc_mem_put( mgr->mctx, dnsName, sizeof( dns_fixedname_t ) );
	    }
	    ISC_LIST_INIT(*nameList);
	    return;
	}
	ISC_LINK_INIT(dnsName, link);
	ISC_LIST_ENQUEUE( *nameList, dnsName, link );
    }
}

static isc_result_t
dbus_mgr_get_sa_list
(
    ns_dbus_mgr_t *mgr,
    dbus_svc_MessageIterator iter,
    SockAddrList *saList ,
    uint8_t *fwdpolicy,
    char *error_name,
    char *error_message
)
{
    DBUS_SVC dbus = mgr->dbus;
    isc_sockaddr_t *nsSA=0L, *nsSA_Q=0L;
    uint32_t argType = dbus_svc_message_next_arg_type( dbus, iter ), 
	     length;    
    isc_result_t result;
    in_port_t port;
    char *ip;
    uint8_t *iparray=0L;

    ISC_LIST_INIT(*saList);

    if( argType == TYPE_INVALID ) 
	return ISC_R_SUCCESS; /* address list "removal" */
   
    do
    {
	switch( argType )
	{
	case TYPE_UINT32:

	    nsSA = isc_mem_get(mgr->mctx, sizeof(isc_sockaddr_t));
	    if( nsSA != 0L )
	    {
		memset(nsSA,'\0', sizeof(isc_sockaddr_t));
		nsSA_Q = nsSA;
		dbus_svc_message_next_arg(dbus, iter, &(nsSA->type.sin.sin_addr.s_addr));	
		nsSA->type.sa.sa_family = AF_INET;
		nsSA->length = sizeof( nsSA->type.sin );
	    }
	    break;

	case TYPE_ARRAY:

	    argType = dbus_svc_message_element_type( dbus, iter );
	    if( argType == TYPE_BYTE )
	    {
		iparray = 0L;
		length = 0;

		dbus_svc_message_get_elements(dbus, iter, &length, &iparray);
		
		if( iparray != 0L )
		{
		    if (length == sizeof( struct in_addr ))
		    {
			nsSA = isc_mem_get(mgr->mctx, sizeof(isc_sockaddr_t));
			if( nsSA != 0L )
			{
			    memset(nsSA,'\0', sizeof(isc_sockaddr_t));
			    nsSA_Q = nsSA;

			    memcpy(&(nsSA->type.sin.sin_addr), iparray, sizeof( struct in_addr ));
			    nsSA->type.sa.sa_family = AF_INET;
			    nsSA->length = sizeof( nsSA->type.sin );
			}
		    }else
		    if (length == sizeof( struct in6_addr ))
		    {
			nsSA = isc_mem_get(mgr->mctx, sizeof(isc_sockaddr_t));
			if( nsSA != 0L )
			{
			    memset(nsSA,'\0', sizeof(isc_sockaddr_t));
			    nsSA_Q = nsSA;
			
			    memcpy(&(nsSA->type.sin6.sin6_addr), iparray, sizeof( struct in6_addr ));
			    nsSA->type.sa.sa_family = AF_INET6;
			    nsSA->length = sizeof( nsSA->type.sin6 );
			}
		    }
		}
	    }
	    break;

	case TYPE_STRING:

	    ip = 0L;
	    dbus_svc_message_next_arg(dbus, iter, &(ip));	
	    if( ip != 0L )
	    {
		length = strlen(ip);
		if( strspn(ip, "0123456789.") == length )
		{
		    nsSA = isc_mem_get(mgr->mctx, sizeof(isc_sockaddr_t));
		    if( nsSA != 0L) 
		    {
			memset(nsSA,'\0', sizeof(isc_sockaddr_t));
			if( inet_pton( AF_INET, ip, &(nsSA->type.sin.sin_addr)) )
			{
			    nsSA->type.sa.sa_family = AF_INET;
			    nsSA->length = sizeof(nsSA->type.sin);
			    nsSA_Q = nsSA;
			}
		    }
		}else
		if( strspn(ip, "0123456789AaBbCcDdEeFf:.") == length)
		{
		    nsSA = isc_mem_get(mgr->mctx, sizeof(isc_sockaddr_t));
		    if( nsSA != 0L )
		    {
			memset(nsSA,'\0', sizeof(isc_sockaddr_t));
			if( inet_pton( AF_INET6, ip, &(nsSA->type.sin6.sin6_addr)) )
			{
			    nsSA->type.sa.sa_family = AF_INET6;
			    nsSA->length = sizeof(nsSA->type.sin6);
			    nsSA_Q = nsSA;
			}
		    }
		}
	    }
	    break;
	   
	case TYPE_UINT16:
	    
	    if( (nsSA == 0L) || (nsSA->type.sa.sa_family == AF_UNSPEC) )
		break;
	    else
	    if( nsSA->type.sa.sa_family == AF_INET )
		dbus_svc_message_next_arg(dbus, iter, &(nsSA->type.sin.sin_port));
	    else
            if( nsSA->type.sa.sa_family == AF_INET6 )
		dbus_svc_message_next_arg(dbus, iter, &(nsSA->type.sin6.sin6_port));
	    break;

	case TYPE_BYTE:

	    dbus_svc_message_next_arg(dbus, iter, fwdpolicy);
	    if(*fwdpolicy > dns_fwdpolicy_only)
		*fwdpolicy =  dns_fwdpolicy_only;
	    break;

	default:

	    if(nsSA != 0L) 
		nsSA->type.sa.sa_family = AF_UNSPEC;
	    sprintf(error_message,"Unhandled argument type: %c", argType);
	    break;
	}

	if( (nsSA != 0L) 
	  &&(nsSA->type.sa.sa_family == AF_UNSPEC)
	  )
	{
	    sprintf(error_name, "com.redhat.named.InvalidArgument");
	    if( error_message[0]=='\0')
	    {
		if( nsSA == 0L )
		    sprintf(error_message,"Missing IP Address Name Server argument");
		else
		    sprintf(error_message,"Bad IP Address Name Server argument");
	    }
       	    if( nsSA != 0L )
		isc_mem_put(mgr->mctx, nsSA, sizeof(isc_sockaddr_t));
	    nsSA = 0L;
	    for( nsSA = ISC_LIST_HEAD( *saList );
		 (nsSA != 0L);
		 nsSA = ISC_LIST_HEAD( *saList )
	       )
	    {
		if(ISC_LINK_LINKED(nsSA, link))
		    ISC_LIST_DEQUEUE( *saList, nsSA, link );
		isc_mem_put( mgr->mctx, nsSA, sizeof( isc_sockaddr_t ) );
	    }
	    ISC_LIST_INIT(*saList);
	    return ISC_R_FAILURE;
	}

	if( nsSA != 0L )
	{
	    if( nsSA->type.sin.sin_port == 0 )
	    {
		if( ns_g_port != 0L )
		    nsSA->type.sin.sin_port = htons(ns_g_port);
		else
		{
		    result = ns_config_getport(ns_g_config, &(port) );
		    if( result != ISC_R_SUCCESS )
			port = 53;
		    nsSA->type.sin.sin_port = htons( port );
		}
	    }	
	
	    if( nsSA_Q != 0L )
	    {
		ISC_LINK_INIT(nsSA,link);
		ISC_LIST_ENQUEUE(*saList, nsSA, link);
		nsSA_Q = 0L;
	    }
	}

	argType = dbus_svc_message_next_arg_type( dbus, iter );    

    } while ( argType != TYPE_INVALID );

    return ISC_R_SUCCESS;
}

static void
dbus_mgr_handle_set_forwarders
(
    ns_dbus_mgr_t *mgr,
    DBUS_SVC dbus, 
    uint8_t  reply_expected,
    uint32_t serial,        
    const char *path,         
    const char *member,         
    const char *interface,
    const char *sender,   
    dbus_svc_MessageHandle msg
)
{
    dbus_svc_MessageIterator iter;
    char error_name[1024]="", error_message[1024]="", *domains=0L;
    uint32_t       argType, new_serial;
    DNSNameList nameList; 
    dns_name_t     *dnsName;
    SockAddrList  saList;    
    isc_sockaddr_t *nsSA;
    isc_result_t   result;
    uint8_t fwdpolicy = dns_fwdpolicy_only;
    
    iter = dbus_svc_message_iterator_new( dbus, msg );

    if( iter == 0L )
    {
	if( reply_expected )
	{
	    sprintf(error_name, "com.redhat.named.InvalidArguments");
	    sprintf(error_message,"SetForwarders requires DNS name and nameservers arguments.");
	    dbus_svc_send( dbus, ERROR, serial, &new_serial, sender, path, interface, member,
			   TYPE_STRING, error_name, TYPE_STRING, error_message, TYPE_INVALID 
		         );
	}
	return;
    }
    
    argType = dbus_svc_message_next_arg_type( dbus, iter );

    if( argType != TYPE_STRING )
    {
	if( reply_expected )
	{
	    sprintf(error_name, "com.redhat.named.InvalidArguments");
	    sprintf(error_message,"SetForwarders requires DNS name string initial argument.");
	    dbus_svc_send( dbus, ERROR, serial, &new_serial, sender, path, interface, member,
			   TYPE_STRING, error_name, TYPE_STRING, error_message, TYPE_INVALID 
		         );
	}
	return;
    } 
    
    dbus_svc_message_next_arg( dbus, iter, &domains );

    if( ( domains == 0L ) || (*domains == '\0') )
    {
	if( reply_expected )
	{
	    sprintf(error_name, "com.redhat.named.InvalidArguments");
	    sprintf(error_message,"SetForwarders requires DNS name string initial argument.");
	    dbus_svc_send( dbus, ERROR, serial, &new_serial, sender, path, interface, member,
			   TYPE_STRING, error_name, TYPE_STRING, error_message, TYPE_INVALID 
		         );
	}
	return;
    }
    
    dbus_mgr_get_name_list( mgr, domains, &nameList, error_name, error_message );
    
    if( error_name[0] != '\0' )
    {
	if( reply_expected )
	{
	    dbus_svc_send( dbus, ERROR, serial, &new_serial, sender, path, interface, member,
			   TYPE_STRING, error_name, TYPE_STRING, error_message, TYPE_INVALID 
		         );
	}
	return;
    }

    if( ISC_LIST_HEAD( nameList ) == 0L )
	return;	

    result = dbus_mgr_get_sa_list( mgr, iter, &saList , &fwdpolicy, error_name, error_message );

    if( result == ISC_R_SUCCESS )
    {
	result = dbus_mgr_set_forwarders( mgr, &nameList, &saList, fwdpolicy );

	if( result != ISC_R_SUCCESS )
	{
	    if( reply_expected )
	    {
		sprintf(error_name, "com.redhat.named.Failure");
		sprintf(error_message, isc_result_totext(result));
		dbus_svc_send( dbus, ERROR, serial, &new_serial, sender, path, interface, member,
			       TYPE_STRING, error_name, TYPE_STRING, error_message, TYPE_INVALID 
		             );
	    }
	}else	
	    if( reply_expected )
		dbus_svc_send( dbus, RETURN, serial, &new_serial, sender, path, interface, member,
		       TYPE_UINT32, &result, TYPE_INVALID
	             );
    }else
    {
	if( reply_expected )
	{
	    dbus_svc_send( dbus, ERROR, serial, &new_serial, sender, path, interface, member,
			   TYPE_STRING, error_name, TYPE_STRING, error_message, TYPE_INVALID 
		         );
	}
    }

    for( dnsName = ISC_LIST_HEAD( nameList );
	 (dnsName != 0L) ;
	 dnsName = ISC_LIST_HEAD( nameList )
	)
    {
	if( ISC_LINK_LINKED(dnsName,link) )
	    ISC_LIST_DEQUEUE( nameList, dnsName, link );
	isc_mem_put( mgr->mctx, dnsName, sizeof( dns_fixedname_t ) );
    }

    for( nsSA = ISC_LIST_HEAD(saList);
	 (nsSA != 0L) ;
	 nsSA = ISC_LIST_HEAD(saList)
       )
    {
	if( ISC_LINK_LINKED(nsSA,link) )
	    ISC_LIST_DEQUEUE( saList, nsSA, link );
	isc_mem_put(mgr->mctx, nsSA, sizeof(isc_sockaddr_t));
    }
}

static 
int dbus_mgr_msg_append_dns_name
(   DBUS_SVC dbus, 
    dbus_svc_MessageHandle msg,
    dns_name_t *name
)
{
    char  nameBuf[ DNS_NAME_FORMATSIZE ]="", *nameP=&(nameBuf[0]);

    dns_name_format(name, nameP, DNS_NAME_FORMATSIZE );    

    if( *nameP == '\0' )
	return 0;

    return dbus_svc_message_append_args( dbus, msg, TYPE_STRING, &nameP, TYPE_INVALID ) > 0;
}

typedef enum dbmoi_e
{
    OUTPUT_BINARY,
    OUTPUT_TEXT    
}   DBusMgrOutputInterface;

static 
int dbus_mgr_msg_append_forwarders
(   DBUS_SVC               dbus, 
    dbus_svc_MessageHandle msg,
    dns_forwarders_t      *fwdr,
    DBusMgrOutputInterface outputType
)
{
    isc_sockaddr_t *sa;
    char policyBuf[16]="", *pbp[1]={&(policyBuf[0])}, addressBuf[64]="", *abp[1]={&(addressBuf[0])};
    uint8_t *byteArray[1];

    if( outputType == OUTPUT_BINARY )
    {
	if(!dbus_svc_message_append_args
	   (   dbus, msg, 
	       TYPE_BYTE, &(fwdr->fwdpolicy),
	       TYPE_INVALID
	   )
	  ) return 0;
    }else
    if( outputType == OUTPUT_TEXT )
    {
	sprintf(policyBuf,"%s",
		(fwdr->fwdpolicy == dns_fwdpolicy_none)
		? "none"
		:  (fwdr->fwdpolicy == dns_fwdpolicy_first)
		   ? "first"
		   : "only"
	       );
	if(!dbus_svc_message_append_args
	   (   dbus, msg, 
	       TYPE_STRING, pbp,
	       TYPE_INVALID
	   )
	  ) return 0;
    }else
	return 0;

    for( sa = ISC_LIST_HEAD(fwdr->addrs);
	 sa != 0L;
	 sa = ISC_LIST_NEXT(sa, link)
	)
    {
	if( outputType == OUTPUT_BINARY )
	{
	    if( sa->type.sa.sa_family == AF_INET )
	    {
		if(!dbus_svc_message_append_args
		   (   dbus, msg, 
		       TYPE_UINT32, &(sa->type.sin.sin_addr.s_addr),
		       TYPE_INVALID
		   )
		  ) return 0;
		
		if(!dbus_svc_message_append_args
		   (   dbus, msg, 
		       TYPE_UINT16, &(sa->type.sin.sin_port),
		       TYPE_INVALID
		   )
		  ) return 0;
	    }else
	    if( sa->type.sa.sa_family == AF_INET6 )
	    {
		byteArray[0] = (uint8_t*)&(sa->type.sin6.sin6_addr);
		if(!dbus_svc_message_append_args
		   (   dbus, msg, 
		       TYPE_ARRAY, TYPE_BYTE, &byteArray, sizeof(struct in6_addr),
		       TYPE_INVALID
		   )
		  ) return 0;

		if(!dbus_svc_message_append_args
		   (   dbus, msg, 
		       TYPE_UINT16, &(sa->type.sin6.sin6_port),
		       TYPE_INVALID
		   )
		  ) return 0;
	    }else
		continue;
	}else
	if( outputType == OUTPUT_TEXT )
	{
	    if( sa->type.sa.sa_family == AF_INET )
	    {
		if( inet_ntop( AF_INET, &(sa->type.sin.sin_addr), addressBuf, sizeof(addressBuf)) == 0L )
		    continue;
		if(!dbus_svc_message_append_args
		   (   dbus, msg, 
		       TYPE_STRING, abp,
		       TYPE_INVALID
		   )
		  ) return 0;
		sprintf(addressBuf, "%hu", ntohs( sa->type.sin.sin_port ));
		if(!dbus_svc_message_append_args
		   (   dbus, msg, 
		       TYPE_STRING, abp,
		       TYPE_INVALID
		   )
		  ) return 0;
	    }else
	    if( sa->type.sa.sa_family == AF_INET6 )
	    {
		if( inet_ntop( AF_INET6, &(sa->type.sin6.sin6_addr), addressBuf, sizeof(addressBuf)) == 0L )
		    continue;
		if(!dbus_svc_message_append_args
		   (   dbus, msg, 
		       TYPE_STRING, abp,
		       TYPE_INVALID
		   )
		  ) return 0;
		sprintf(addressBuf, "%hu", ntohs( sa->type.sin6.sin6_port ));
		if(!dbus_svc_message_append_args
		   (   dbus, msg, 
		       TYPE_STRING, abp,
		       TYPE_INVALID
		   )
		  ) return 0;		
	    }else
		continue;
	}else
	    return 0;
    }
    return 1;
}

typedef struct dbm_m_s
{
    DBUS_SVC dbus;
    dbus_svc_MessageHandle msg;
    DBusMgrOutputInterface outputType;
}   DBusMgrMsg;

static
void forwarders_to_msg( dns_name_t *name, dns_forwarders_t *fwdr, void *mp )
{
    DBusMgrMsg *m = mp;
    
    if( (fwdr == 0L) || (name == 0L) || (mp == 0L))
	return;
    dbus_mgr_msg_append_dns_name  ( m->dbus, m->msg, name );
    dbus_mgr_msg_append_forwarders( m->dbus, m->msg, fwdr, m->outputType );    
}

static void
dbus_mgr_handle_list_forwarders
(
    DBUS_SVC dbus, 
    uint8_t  reply_expected,
    uint32_t serial,        
    const char *path,         
    const char *member,         
    const char *interface,
    const char *sender,   
    dbus_svc_MessageHandle msg
)
{
    char error_name[1024], error_message[1024];
    DBusMgrMsg m;
    uint32_t new_serial;
    dns_fwdtable_t *fwdtable = dbus_mgr_get_fwdtable();
    DBusMgrOutputInterface outputType = OUTPUT_BINARY;
    uint32_t length = strlen(interface);
        
    if( !reply_expected )
	return;

    if( (length > 4) && (strcmp(interface + (length - 4), "text")==0))
	outputType = OUTPUT_TEXT;

    if( fwdtable == 0L )
    {	
	sprintf(error_name,"com.redhat.dbus.Failure");
	sprintf(error_message, "%s", isc_result_totext(ISC_R_NOPERM));
	dbus_svc_send( dbus, ERROR, serial, &new_serial, sender, path, interface, member,
		       TYPE_STRING, error_name, TYPE_STRING, error_message, TYPE_INVALID 
	             );	    
	return;
    }

    msg = dbus_svc_new_message( dbus, RETURN, serial, sender, path, interface, member);

    m.dbus = dbus;
    m.msg = msg;
    m.outputType = outputType;

    if( msg == 0L )
    {
	sprintf(error_name,"com.redhat.dbus.OutOfMemory");
	sprintf(error_message,"out of memory");
	dbus_svc_send( dbus, ERROR, serial, &new_serial, sender, path, interface, member,
		       TYPE_STRING, error_name, TYPE_STRING, error_message, TYPE_INVALID 
	             );	    
    }
    
    dns_fwdtable_foreach( fwdtable, forwarders_to_msg, &m );

    dbus_svc_send_message( dbus, msg, &new_serial );
}

static void
dbus_mgr_handle_get_forwarders
(
    DBUS_SVC dbus, 
    uint8_t  reply_expected,
    uint32_t serial,        
    const char *path,         
    const char *member,         
    const char *interface,
    const char *sender,   
    dbus_svc_MessageHandle msg
)
{
    char error_name[1024], error_message[1024], *domain=0L;
    isc_result_t    result;
    dns_fixedname_t  fixedname;
    dns_name_t       *dnsName;
    isc_buffer_t     buffer;
    uint32_t         length,  new_serial;
    dns_fwdtable_t   *fwdtable;
    dns_forwarders_t *fwdr=0L;
    dns_name_t       *foundname;
    dns_fixedname_t  fixedFoundName;
    DBusMgrOutputInterface outputType = OUTPUT_BINARY;

    if( !reply_expected )
	return;

    length = strlen(interface);

    if( (length > 4) && (strcmp(interface + (length - 4), "text")==0))
	outputType = OUTPUT_TEXT;

    if( (!dbus_svc_get_args( dbus, msg, TYPE_STRING, &domain, TYPE_INVALID))
      ||(domain == 0L)
      ||(*domain == '\0')
      )
    {

	sprintf(error_name,"com.redhat.dbus.InvalidArguments");
	sprintf(error_message,"domain name argument expected");
	dbus_svc_send( dbus, ERROR, serial, &new_serial, sender, path, interface, member,
		       TYPE_STRING, error_name, TYPE_STRING, error_message, TYPE_INVALID 
	             );	    
	return;
    }
    
    length = strlen( domain );

    isc_buffer_init( &buffer, domain, length); 

    isc_buffer_add(&buffer, length);		
    
    dns_fixedname_init(&fixedname);

    dnsName = dns_fixedname_name(&fixedname);

    result = dns_name_fromtext
	     (  dnsName, &buffer, dns_rootname, 0, NULL
	     ); 

    if( result != ISC_R_SUCCESS )
    {	
	sprintf(error_name,"com.redhat.dbus.InvalidArguments");
	sprintf(error_message,"invalid domain name argument: %s", domain);
	dbus_svc_send( dbus, ERROR, serial, &new_serial, sender, path, interface, member,
		       TYPE_STRING, error_name, TYPE_STRING, error_message, TYPE_INVALID 
	             );	    
	return;
    }

    msg = dbus_svc_new_message( dbus, RETURN, serial, sender, path, interface, member);
    
    if( msg == 0L )
    {
	sprintf(error_name,"com.redhat.dbus.OutOfMemory");
	sprintf(error_message,"out of memory");
	dbus_svc_send( dbus, ERROR, serial, &new_serial, sender, path, interface, member,
		       TYPE_STRING, error_name, TYPE_STRING, error_message, TYPE_INVALID 
	             );	
	return;
    }	
    
    fwdtable = dbus_mgr_get_fwdtable();

    if( fwdtable == 0L )
    {
	sprintf(error_name,"com.redhat.dbus.Failure");
	sprintf(error_message, "%s", isc_result_totext(ISC_R_NOPERM));
	dbus_svc_send( dbus, ERROR, serial, &new_serial, sender, path, interface, member,
		       TYPE_STRING, error_name, TYPE_STRING, error_message, TYPE_INVALID 
	             );	    
	return;
    }

    dns_fixedname_init(&fixedFoundName);
    foundname = dns_fixedname_name(&fixedFoundName);
	
    if( ( dns_fwdtable_find_closest( fwdtable, dnsName, foundname, &fwdr ) == ISC_R_SUCCESS )
      &&( fwdr != 0L )
      )
    {
	if( (!dbus_mgr_msg_append_dns_name( dbus, msg, foundname ))
	  ||(!dbus_mgr_msg_append_forwarders( dbus, msg, fwdr, outputType ))
	  )
	{
	    sprintf(error_name,"com.redhat.dbus.OutOfMemory");
	    sprintf(error_message,"out of memory");
	    dbus_svc_send( dbus, ERROR, serial, &new_serial, sender, path, interface, member,
			   TYPE_STRING, error_name, TYPE_STRING, error_message, TYPE_INVALID 
		);	    
	    return;
	}	
	
    }else
    {
	result = ISC_R_NOTFOUND;
	if( outputType == OUTPUT_BINARY )
	{
	    dbus_svc_message_append_args( dbus, msg, 
					  TYPE_UINT32, &(result),
					  TYPE_INVALID
		                        ) ;
	}else
	{
	    sprintf(error_name,"com.redhat.dbus.NotFound");
	    sprintf(error_message,"Not Found");
	    dbus_svc_send( dbus, ERROR, serial, &new_serial, sender, path, interface, member,
			   TYPE_STRING, error_name, TYPE_STRING, error_message, TYPE_INVALID 
		         );	   
	    return;
	}
    }
    dbus_svc_send_message( dbus, msg, &new_serial );
}

static void
dbus_mgr_check_dhcdbd_state( ns_dbus_mgr_t *mgr, dbus_svc_MessageHandle msg )
{
    DBUS_SVC dbus = mgr->dbus;
    char *name_owned = 0L,
	 *old_owner = 0L,
	 *new_owner = 0L;
    
    if( !dbus_svc_get_args( dbus, msg,
			    TYPE_STRING, &name_owned,
			    TYPE_STRING, &old_owner,
			    TYPE_STRING, &new_owner,
			    TYPE_INVALID
	                  )
      ) return;
	
    dbus_mgr_log_dbg("NameOwnerChanged: %s %s %s ( %s )", name_owned, old_owner, new_owner, mgr->dhcdbd_name);

    if( (name_owned == 0L) || (new_owner == 0L) || (old_owner == 0L) )
	return;

    if( strcmp( name_owned, "com.redhat.dhcp" ) == 0 )
    {
	if( *new_owner == '\0' )
	{
	    isc_mem_put(mgr->mctx, mgr->dhcdbd_name, strlen(mgr->dhcdbd_name) + 1);
	    mgr->dhcdbd_name = 0L;
	    dbus_mgr_log_err("D-BUS dhcdbd subscription disabled.");
	    return;
	}
	if( (mgr->dhcdbd_name == 0L) 
	  ||( strcmp( mgr->dhcdbd_name, new_owner) != 0 )
	  )
	{
	    if( mgr->dhcdbd_name != 0L )
	    {
		isc_mem_put(mgr->mctx, mgr->dhcdbd_name, strlen(mgr->dhcdbd_name)+1);
		mgr->dhcdbd_name = 0L;
	    }
	    mgr->dhcdbd_name = isc_mem_get(mgr->mctx, strlen(new_owner) + 1);
	    if( mgr->dhcdbd_name == 0L )
		return;
	    strcpy( mgr->dhcdbd_name, new_owner );
	    dbus_mgr_subscribe_to_dhcdbd( mgr );
	}
    }else
    if(  ( mgr->dhcdbd_name != 0L ) 
      && ( strcmp(mgr->dhcdbd_name, name_owned) == 0L )
      && ( *new_owner == '\0' )
      ) 
    {
	isc_mem_put(mgr->mctx, mgr->dhcdbd_name, strlen(mgr->dhcdbd_name));
	mgr->dhcdbd_name = 0L;
	dbus_mgr_log_err("D-BUS dhcdbd subscription disabled.");
    }
}

static int dbus_mgr_dhc_if_comparator( const void *p1, const void *p2 )
{
    return( strcmp( ((const DHC_IF*)p1)->if_name, ((const DHC_IF*)p2)->if_name) );
}

static 
dns_name_t *dbus_mgr_if_reverse_ip_name
(   ns_dbus_mgr_t *mgr,
    struct in_addr ip_address, 
    struct in_addr subnet_mask 
)
{
    dns_name_t *dns_name =0L;
    dns_fixedname_t *fixedname=0L;
    char name [ DNS_NAME_FORMATSIZE ], *p;
    uint32_t ip = (ntohl(ip_address.s_addr) & ntohl(subnet_mask.s_addr)), i;
    isc_buffer_t buffer;
    isc_result_t result;

    if( (ip == 0) || (ip == 0xffffffff) )
	return 0L;
    
    for(i = 8, p = name; (i < 32); i += 8)
	if( ip & ( 0xff << i ) )
	    p += sprintf(p, "%u.", (((ip & ( 0xff << i )) >> i ) & 0xff) );

    if( p > name )
    {
	p += sprintf(p, "in-addr.arpa");
	isc_buffer_init( &buffer, name, p - name );
	isc_buffer_add(&buffer, p - name);		
	
	fixedname = isc_mem_get( mgr->mctx, sizeof( dns_fixedname_t ));

	dns_fixedname_init(fixedname);

	dns_name = dns_fixedname_name(fixedname);

	result= dns_name_fromtext
	        (  dns_name, &buffer, dns_rootname, 0, NULL
		); 

	ISC_LINK_INIT(dns_name, link);
	if( result == ISC_R_SUCCESS )
	    return dns_name;
    }
    return 0L;
}

static void
dbus_mgr_free_dhc( void *p )
{
    DHC_IF *d_if = p;
    dns_name_t *dn;
    isc_sockaddr_t *sa;

    isc_mem_put( ns_g_mctx, d_if->if_name, strlen(d_if->if_name) + 1);
    for( sa = ISC_LIST_HEAD( d_if->dns );
	 sa != NULL;
	 sa = ISC_LIST_HEAD( d_if->dns )
       )
    {
	if( ISC_LINK_LINKED( sa, link ) )
	    ISC_LIST_UNLINK( d_if->dns, sa, link );
	isc_mem_put(ns_g_mctx, sa, sizeof(isc_sockaddr_t));
    }
    for( dn = ISC_LIST_HEAD( d_if->dn );
	 dn != NULL;
	 dn = ISC_LIST_HEAD( d_if->dn )
       )
    {
	if( ISC_LINK_LINKED( dn, link ) )
	    ISC_LIST_UNLINK( d_if->dn, dn, link );
	isc_mem_put( ns_g_mctx, dn, sizeof( dns_fixedname_t ) );
    }
    isc_mem_put( ns_g_mctx, d_if, sizeof(DHC_IF));    
}

static void
dbus_mgr_handle_dhcdbd_message
(
    ns_dbus_mgr_t *mgr,
    const char *path,
    const char *member,
    dbus_svc_MessageHandle msg
)
{
    DBUS_SVC dbus = mgr->dbus;
    DHC_IF *d_if, *const*d_ifpp, dif;
    DHC_State dhc_state;
    char *if_name, *opt_name, error_name[1024]="", error_message[1024]="";
    uint8_t *value=0L;
    uint32_t length;
    isc_result_t result;
    isc_sockaddr_t *sa = 0L;
    dns_name_t *dn = 0L;
    struct in_addr *ip;
    in_port_t port;
    char dnBuf[ DNS_NAME_FORMATSIZE ];
    isc_buffer_t buffer;
    DBusMgrInitialFwdr *ifwdr, *const*ifwdpp, ifwd;    
    ISC_LIST(DBusMgrInitialFwdr) ifwdrList;
    DNSNameList nameList;
    dbus_mgr_log_dbg("Got dhcdbd message: %s %s %p", path, member, msg );

    if( ( if_name = strrchr(path,'/') ) == 0L )
    {
	dbus_mgr_log_err("bad path in dhcdbd message:", path);
	return;
    }

    ++if_name;
    dif.if_name = if_name;

    if( ((d_ifpp=tfind( &dif, &(mgr->dhc_if), dbus_mgr_dhc_if_comparator)) == 0L)
      ||((d_if = *d_ifpp) == 0L)
      )
    {
	d_if = isc_mem_get( mgr->mctx, sizeof(DHC_IF));
	if( d_if == 0L )	  
	{
	    dbus_mgr_log_err("out of memory");
	    return;
	}
	memset(d_if, '\0', sizeof(DHC_IF));
	if((d_if->if_name =  isc_mem_get( mgr->mctx, strlen(if_name) + 1)) == 0L)
	{
	    dbus_mgr_log_err("out of memory");
	    return;
	}
	strcpy(d_if->if_name, if_name);
	d_if->dhc_state = DHC_INVALID;
	d_if->previous_state = DHC_INVALID;
	ISC_LIST_INIT( d_if->dn );
	ISC_LIST_INIT( d_if->dns );
	if( tsearch( d_if, &(mgr->dhc_if), dbus_mgr_dhc_if_comparator) == 0L )
	{
	    dbus_mgr_log_err("out of memory");
	    return;
	}
    }

    if( strcmp(member, "reason") == 0 )
    {
	if( (!dbus_svc_get_args( dbus, msg,
				 TYPE_STRING, &opt_name,
				 TYPE_ARRAY, TYPE_BYTE, &value, &length,
				 TYPE_INVALID
		               )
	    )
	  ||( value == 0L)
	  ||( length != sizeof(uint32_t))
	  ||( *((uint32_t*)value) > DHC_END_OPTIONS)
	  )
	{
	    dbus_mgr_log_err("Invalid DHC reason value received from dhcdbd");
	    return;
	}
	dhc_state = (DHC_State) *((uint32_t*)value);
	dbus_mgr_log_dbg("reason: %d %d %d", dhc_state, d_if->dhc_state, d_if->previous_state);
	switch( dhc_state )
	{

	case  DHC_END_OPTIONS:
	    switch( d_if->dhc_state )
	    {
	    case  DHC_END_OPTIONS:
		break;

	    case  DHC_RENEW: 
	    case  DHC_REBIND:		
		if( ( d_if->previous_state != DHC_INVALID ) 
		  &&( d_if->previous_state != DHC_RELEASE )
		  ) break; 
		    /* DHC_RENEW means the same lease parameters were obtained. 
		     * Only do configuration if we started up with existing dhclient
		     * which has now renewed - else we are already configured correctly.
		     */
		dbus_mgr_log_err("D-BUS: existing dhclient for interface %s RENEWed lease", if_name);

	    case  DHC_REBOOT:
	    case  DHC_BOUND:
		d_if->previous_state = d_if->dhc_state;
		d_if->dhc_state = DHC_BOUND;
		if( (dn = dbus_mgr_if_reverse_ip_name(mgr, d_if->ip, d_if->subnet_mask )) != 0L )
		{
		    ISC_LIST_APPEND(d_if->dn, dn, link );
		} 
		if( ( ISC_LIST_HEAD( d_if->dn ) != NULL )
		  &&( ISC_LIST_HEAD( d_if->dns ) != NULL )
		  )
		{
		    dbus_mgr_log_err("D-BUS: dhclient for interface %s acquired new lease - creating forwarders.", 
				     if_name
			            );
		    result = dbus_mgr_set_forwarders( mgr, &(d_if->dn), &(d_if->dns), dns_fwdpolicy_only );
		    if( result != ISC_R_SUCCESS )
		    {
			dbus_mgr_log_err("D-BUS: forwarder configuration failed: %s", isc_result_totext(result));
		    }
		}
		break;	  

	    case  DHC_STOP:
	    case  DHC_TIMEOUT:
	    case  DHC_FAIL:
	    case  DHC_EXPIRE:
	    case  DHC_RELEASE:
		d_if->previous_state = d_if->dhc_state;
		d_if->dhc_state = DHC_RELEASE;
		if( ISC_LIST_HEAD( d_if->dn ) != NULL )
		{
		    dbus_mgr_log_err("D-BUS: dhclient for interface %s released lease - removing forwarders.", 
				     if_name);
		    for( sa = ISC_LIST_HEAD( d_if->dns );
			 sa != 0L;
			 sa = ISC_LIST_HEAD( d_if->dns )
		       )
		    {
			if( ISC_LINK_LINKED( sa, link ) )
			    ISC_LIST_UNLINK( d_if->dns, sa, link );
			isc_mem_put( mgr->mctx, sa, sizeof(isc_sockaddr_t));
		    }
		    ISC_LIST_INIT( d_if->dns );
		    ISC_LIST_INIT( ifwdrList );

		    for( dn = ISC_LIST_HEAD( d_if->dn );
			 dn != 0L;
			 dn = ISC_LIST_NEXT( dn, link )
		       )
		    {
		        dns_name_init( &(ifwd.dn), NULL );
			isc_buffer_init( &buffer, dnBuf, DNS_NAME_FORMATSIZE);
			dns_name_setbuffer( &(ifwd.dn), &buffer);
			dns_name_copy(dn, &(ifwd.dn), NULL);
			if( ((ifwdpp = tfind(&ifwd, &(mgr->ifwdt), dbus_mgr_ifwdr_comparator)) != 0L )
			  &&((ifwdr = *ifwdpp) != 0L)
			  )
			{
			    ISC_LIST_APPEND( ifwdrList, ifwdr, link );
			}			
		    }
		    
		    result = dbus_mgr_set_forwarders( mgr, &(d_if->dn), &(d_if->dns), dns_fwdpolicy_none );
		    if( result != ISC_R_SUCCESS )
		    {
			dbus_mgr_log_err("D-BUS: removal of forwarders failed: %s", isc_result_totext(result));
		    }

		    for( dn = ISC_LIST_HEAD( d_if->dn );
			 dn != 0L;
			 dn = ISC_LIST_HEAD( d_if->dn )
		       )
		    {
			if( ISC_LINK_LINKED( dn, link ) )
			    ISC_LIST_UNLINK( d_if->dn, dn, link );			
			isc_mem_put( mgr->mctx, dn, sizeof( dns_fixedname_t ) );
		    }
		    ISC_LIST_INIT( d_if->dn );

		    for( ifwdr = ISC_LIST_HEAD( ifwdrList );
			 ifwdr != 0L;
			 ifwdr = ISC_LIST_HEAD( ifwdrList )
		       )
		    {
			if( ISC_LINK_LINKED( ifwdr, link ) )
			    ISC_LIST_UNLINK( ifwdrList, ifwdr, link );
			ISC_LINK_INIT(ifwdr, link);
			ISC_LIST_INIT(nameList);
			ISC_LINK_INIT(&(ifwdr->dn), link);
			ISC_LIST_APPEND( nameList, &(ifwdr->dn), link );
			result = dbus_mgr_set_forwarders( mgr, &nameList, 
							  &(ifwdr->sa), 
							  ifwdr->fwdpolicy 
			                                );
			if( result != ISC_R_SUCCESS )
			{
			    dbus_mgr_log_err("D-BUS: restore of forwarders failed: %s", isc_result_totext(result));
			}			
		    }
		}

	    case  DHC_ABEND:
	    case  DHC_END:
	    case  DHC_NBI:
	    case  DHC_PREINIT:
	    case  DHC_MEDIUM:
	    case  DHC_START:
	    case  DHC_INVALID:
	    default:
		break;
	    }
	    break;

	case  DHC_BOUND:
	case  DHC_REBOOT:
	case  DHC_REBIND:	
	case  DHC_RENEW:
        case  DHC_STOP:
        case  DHC_TIMEOUT:
	case  DHC_FAIL:
	case  DHC_EXPIRE:
	case  DHC_RELEASE:
		d_if->previous_state = d_if->dhc_state;
		d_if->dhc_state = dhc_state;

	case  DHC_ABEND:
	case  DHC_END:
	case  DHC_NBI:
	case  DHC_PREINIT:
	case  DHC_MEDIUM:
	case  DHC_START:
	case  DHC_INVALID:
	default:
	    break;
	}	
    }else
    if( strcmp( member, "domain_name" ) == 0 )
    {	
	if( (!dbus_svc_get_args( dbus, msg,
				 TYPE_STRING, &opt_name,
				 TYPE_ARRAY, TYPE_BYTE, &value, &length,
				 TYPE_INVALID
		               )
	    )
	  ||( value == 0L)
	  ||( length == 0)
	  )
	{
	    dbus_mgr_log_err("Invalid domain_name value received from dhcdbd");
	    return;	
	}
	dbus_mgr_log_dbg("domain-name %s", (char*)value);
	dbus_mgr_get_name_list( mgr, (char*)value, &(d_if->dn), error_name, error_message );
	if( ( error_message[0] != '\0' ) || (ISC_LIST_HEAD(d_if->dn) == 0L ))
	{
	    dbus_mgr_log_err("Bad domain_name value: %s", error_message );
	}
    }else
    if( strcmp( member, "domain_name_servers") == 0 )
    {
	if( (!dbus_svc_get_args( dbus, msg,
				 TYPE_STRING, &opt_name,
				 TYPE_ARRAY, TYPE_BYTE, &value, &length,
				 TYPE_INVALID
		               )
	    )
	  ||( value == 0L)
	  ||( length == 0)
	  )
	{
	    dbus_mgr_log_err("Invalid domain_name_servers value received from dhcdbd");
	    return;	
	}	
	for(ip = (struct in_addr*) value; ip < ((struct in_addr*)(value + length)); ip++)
	{
	    dbus_mgr_log_dbg("domain-name-servers: %s", inet_ntop(AF_INET, value, error_name, 16));
	    sa = isc_mem_get(mgr->mctx, sizeof(isc_sockaddr_t));
	    memset(sa, '\0', sizeof(isc_sockaddr_t));
	    sa->type.sin.sin_addr = *ip;
	    sa->type.sa.sa_family = AF_INET;
	    sa->length = sizeof(sa->type.sin);
	    result = ns_config_getport(ns_g_config, &(port) );
	    if( result != ISC_R_SUCCESS )
		port = 53;
	    sa->type.sin.sin_port = htons( port );
	    ISC_LIST_APPEND(d_if->dns, sa, link);
	}
    }else
    if( strcmp(member, "ip_address") == 0)
    {
	if( (!dbus_svc_get_args( dbus, msg,
				 TYPE_STRING, &opt_name,
				 TYPE_ARRAY, TYPE_BYTE, &value, &length,
				 TYPE_INVALID
		               )
	    )
	  ||( value == 0L)
	  ||( length != sizeof(struct in_addr) )
	  )
	{
	    dbus_mgr_log_err("Invalid ip_address value received from dhcdbd");
	    return;
	}
	dbus_mgr_log_dbg("ip-address: %s", inet_ntop(AF_INET, value, error_name, 16));
	d_if->ip = *((struct in_addr*)value);
    
    }else
    if( strcmp(member, "subnet_mask") == 0 )
    {
	if( (!dbus_svc_get_args( dbus, msg,
				 TYPE_STRING, &opt_name,
				 TYPE_ARRAY, TYPE_BYTE, &value, &length,
				 TYPE_INVALID
		               )
	    )
	  ||( value == 0L)
	  ||( length != sizeof(struct in_addr) )
	  )
	{
	    dbus_mgr_log_err("Invalid subnet_mask value received from dhcdbd");
	    return;
	}
	dbus_mgr_log_dbg("subnet-mask: %s", inet_ntop(AF_INET, value, error_name, 16));
	d_if->subnet_mask = *((struct in_addr*)value);
    }
}

static
dbus_svc_HandlerResult 
dbus_mgr_message_handler
(  
    DBusMsgHandlerArgs
)
{
    char error_name[1024], error_message[1024];
    ns_dbus_mgr_t *mgr = object;
    uint32_t new_serial;

    if_suffix = prefix = suffix = prefixObject = 0L;

    dbus_mgr_log_dbg("D-BUS message: %u %u %u %s %s %s %s %s %s",
		     type, reply_expected, serial, destination, path, member, interface, sender, signature
	            );

    if (  ( type == SIGNAL )
	&&( strcmp(path,"/org/freedesktop/DBus/Local") == 0 )
       )
    {
	if( strcmp(member,"Disconnected") == 0 )
	    dbus_mgr_dbus_shutdown_handler( mgr );
    }else
    if( ( type == SIGNAL )
      &&( strcmp(path,"/org/freedesktop/DBus") == 0 )
      &&(strcmp(member,"NameOwnerChanged") == 0)
      &&(strcmp(signature, "sss") == 0)
      )
    {
	dbus_mgr_check_dhcdbd_state( mgr, msg );
    }else
    if( ( type == SIGNAL ) 
      &&( (sender != 0L) && (mgr->dhcdbd_name != 0L) && (strcmp(sender,mgr->dhcdbd_name)   == 0)) 
      &&( strcmp(interface,"com.redhat.dhcp.subscribe.binary") == 0 )
      )
    {
	dbus_mgr_handle_dhcdbd_message( mgr, path, member, msg );
    }else
    if( (type == CALL) 
      &&( strcmp(destination, DBUSMGR_DESTINATION)==0)
      &&( strcmp(path, DBUSMGR_OBJECT_PATH)==0)
      )
    {
	if( strcmp(member, "SetForwarders") == 0 )
	    dbus_mgr_handle_set_forwarders
	    ( mgr, dbus, reply_expected, serial, path, member, interface, sender, msg );
	else
	if( strcmp(member, "GetForwarders") == 0 )
	{
	    if( *signature != '\0' )	   
		dbus_mgr_handle_get_forwarders
		( dbus, reply_expected, serial, path, member, interface, sender, msg );
	    else       
		dbus_mgr_handle_list_forwarders
		( dbus, reply_expected, serial, path, member, interface, sender, msg );
	}else
	if( reply_expected )
	{
	    sprintf(error_name, "InvalidOperation");
	    sprintf(error_message, "Unrecognized path / interface / member");
	    dbus_svc_send( dbus, ERROR, serial, &new_serial, sender, path, interface, member,
			   TYPE_STRING, error_name, TYPE_STRING, error_message, TYPE_INVALID 
		);	    
	}
    }
    return HANDLED;
}

static void
dbus_mgr_read_watch_activated(isc_task_t *t, isc_event_t *ev)
{
    DBusMgrSocket *sfd = (DBusMgrSocket*)(ev->ev_arg);
    t = t;
    isc_mem_put(sfd->mgr->mctx, ev, ev->ev_size);
    dbus_mgr_log_dbg("watch %d READ",sfd->fd);  
    isc_socket_fd_handle_reads( sfd->sock, sfd->ser );
    dbus_svc_handle_watch( sfd->mgr->dbus, sfd->fd, WATCH_ENABLE | WATCH_READ );
}

static void
dbus_mgr_write_watch_activated(isc_task_t *t, isc_event_t *ev)
{
    DBusMgrSocket *sfd = (DBusMgrSocket*)(ev->ev_arg);
    t = t;
    isc_mem_put(sfd->mgr->mctx, ev, ev->ev_size);
    dbus_mgr_log_dbg("watch %d WRITE",sfd->fd);
    isc_socket_fd_handle_writes( sfd->sock, sfd->ser );
    dbus_svc_handle_watch( sfd->mgr->dbus, sfd->fd, WATCH_ENABLE | WATCH_WRITE );    
}

static void
dbus_mgr_watches_selected(isc_task_t *t, isc_event_t *ev)
{
    ns_dbus_mgr_t *mgr = (ns_dbus_mgr_t*)(ev->ev_arg);
    t = t;
    isc_mem_put(mgr->mctx, ev, ev->ev_size);
    if( ( mgr->dbus == 0L ) || (mgr->sockets == 0L))
    {
	return;
    }
    dbus_mgr_log_dbg("watches selected");
    dbus_svc_dispatch( mgr->dbus );
    dbus_mgr_log_dbg("dispatch complete");
}

static int dbus_mgr_socket_comparator( const void *p1, const void *p2 )
{
    return( (   ((const DBusMgrSocket*)p1)->fd 
	     == ((const DBusMgrSocket*)p2)->fd
	    ) ? 0
	      : (   ((const DBusMgrSocket*)p1)->fd 
	          > ((const DBusMgrSocket*)p2)->fd
	        ) ? 1
	          : -1
	  );
}

static void 
dbus_mgr_watch_handler( int fd, dbus_svc_WatchFlags flags, void *mgrp )
{
    ns_dbus_mgr_t *mgr = mgrp;
    DBusMgrSocket sockFd, *sfd=0L, *const*spp=0L;
    isc_result_t  result=ISC_R_SUCCESS;
    isc_socketevent_t *sev;
    isc_event_t *pev[1];

    if(mgr == 0L)
	return;

    if( (flags & 7) == WATCH_ERROR )
	return;

    sockFd.fd = fd;

    dbus_mgr_log_dbg("watch handler: fd %d %d", fd, flags);

    if( ((spp = tfind( &sockFd, &(mgr->sockets), dbus_mgr_socket_comparator) ) == 0L )
      ||((sfd = *spp) == 0L )
      )
    {
	if( ( flags & WATCH_ENABLE ) == 0 )
	    return;

	sfd = isc_mem_get(mgr->mctx, sizeof(DBusMgrSocket));
	if( sfd == 0L )
	{
	    dbus_mgr_log_err("dbus_mgr: out of memory" );
	    return;
	}
	sfd->fd = fd;
	sfd->mgr = mgr;
	sfd->ser = sfd->sew = sfd->sel = 0L;

	if( tsearch(sfd, &(mgr->sockets), dbus_mgr_socket_comparator) == 0L )
	{
	    dbus_mgr_log_err("dbus_mgr: out of memory" );
	    isc_mem_put(mgr->mctx, sfd, sizeof(DBusMgrSocket));
	    return;
	}
	sfd->sock = 0L;
	result = isc_socket_create( mgr->socketmgr, fd, isc_sockettype_fd, &(sfd->sock) );
	if( result != ISC_R_SUCCESS )
	{
	    dbus_mgr_log_err("dbus_mgr: isc_socket_create failed: %s", 
			     isc_result_totext(result)
	                    );
	    tdelete(sfd,  &(mgr->sockets), dbus_mgr_socket_comparator);
	    isc_mem_put(mgr->mctx, sfd, sizeof(DBusMgrSocket));
	    return;
	}
    }
    
    if( (flags & WATCH_ENABLE) == WATCH_ENABLE )
    {
	if( (flags & WATCH_READ) == WATCH_READ )
	{
	    if( sfd->ser == 0L )
	    {
		sfd->ser = (isc_socketevent_t *)
		    isc_event_allocate
		    (
			mgr->mctx, mgr->task,
			ISC_SOCKEVENT_READ_READY,
			dbus_mgr_read_watch_activated,
			sfd,
			sizeof(isc_socketevent_t)
		    );

		if( sfd->ser == 0L )
		{
		    dbus_mgr_log_err("dbus_mgr: out of memory" );
		    tdelete(sfd,  &(mgr->sockets), dbus_mgr_socket_comparator);
		    isc_mem_put(mgr->mctx, sfd, sizeof(DBusMgrSocket));
		    return;		    
		}

		sev = isc_socket_fd_handle_reads(sfd->sock, sfd->ser );

	    }else
	    {
		sev = isc_socket_fd_handle_reads(sfd->sock, sfd->ser );
	    }
	}
	if( (flags & WATCH_WRITE) == WATCH_WRITE )
	{
	    if( sfd->sew == 0L )
	    {
		sfd->sew = (isc_socketevent_t *)
		    isc_event_allocate
		    (
			mgr->mctx, mgr->task,
			ISC_SOCKEVENT_WRITE_READY,
			dbus_mgr_write_watch_activated,
			sfd,
			sizeof(isc_socketevent_t)
		    );
		if( sfd->sew == 0L )
		{
		    dbus_mgr_log_err("dbus_mgr: out of memory" );
		    tdelete(sfd,  &(mgr->sockets), dbus_mgr_socket_comparator);
		    isc_mem_put(mgr->mctx, sfd, sizeof(DBusMgrSocket));
		    return;		    
		}
		
		sev = isc_socket_fd_handle_writes(sfd->sock, sfd->sew );
		
	    }else
	    {
		sev = isc_socket_fd_handle_writes(sfd->sock, sfd->sew );
	    }
	}
	if( (sfd->ser != 0L) || (sfd->sew != 0L) )
	{
	    if( sfd->sel == 0L )
	    {
		sfd->sel = (isc_socketevent_t *)
		    isc_event_allocate
		    (
			mgr->mctx, mgr->task,
			ISC_SOCKEVENT_SELECTED,
			dbus_mgr_watches_selected,
			mgr,
			sizeof(isc_socketevent_t)
		    );
		if( sfd->sel == 0L )
		{
		    dbus_mgr_log_err("dbus_mgr: out of memory" );
		    tdelete(sfd,  &(mgr->sockets), dbus_mgr_socket_comparator);
		    isc_mem_put(mgr->mctx, sfd, sizeof(DBusMgrSocket));
		    return;		    
		}
		
		sev = isc_socket_fd_handle_selected(sfd->sock, sfd->sel );
		
	    }else
	    {
		sev = isc_socket_fd_handle_selected(sfd->sock, sfd->sel);
	    }
	}
    }else
    {
	dbus_mgr_log_dbg("watch %d disabled",fd);
	if(flags & WATCH_READ)
	{
	    sev = isc_socket_fd_handle_reads( sfd->sock, 0L );
	    if( sev != 0L )
	    {
		pev[0]=(isc_event_t*)sev;
		isc_event_free(pev);
	    }
	    sfd->ser = 0L;
	}

	if( flags & WATCH_WRITE )
	{
	    sev = isc_socket_fd_handle_writes( sfd->sock, 0L );
	    if( sev != 0L )
	    {
		pev[0]=(isc_event_t*)sev;
		isc_event_free(pev);
	    }
	    sfd->sew = 0L;
	}

	if( (sfd->ser == 0L) && (sfd->sew == 0L) )
	{
	    sev = isc_socket_fd_handle_selected( sfd->sock, 0L );
	    if( sev != 0L )
	    {
		pev[0]=(isc_event_t*)sev;
		isc_event_free(pev);
	    }
	    sfd->sel = 0L;

	    tdelete(sfd, &(mgr->sockets), dbus_mgr_socket_comparator);

	    isc_mem_put(mgr->mctx, sfd,  sizeof(DBusMgrSocket));
	}
    }
}

static
void dbus_mgr_close_socket( const void *p, const VISIT which, const int level)
{
    DBusMgrSocket *const*spp=p, *sfd;
    isc_event_t *ev ;
    int i =  level ? 0 :1;
    i &= i;

    if( (spp==0L) || ((sfd = *spp)==0L) 
      ||((which != leaf) && (which != postorder))
      ) return;
   
    if( sfd->ser != 0L )
    {
	ev = (isc_event_t *)isc_socket_fd_handle_reads(sfd->sock, 0);
	if( ev != 0L )
	    isc_event_free((isc_event_t **)&ev);
	sfd->ser = 0L;
    }

    if( sfd->sew != 0L )
    {
	ev = (isc_event_t *)isc_socket_fd_handle_writes(sfd->sock, 0);
	if( ev != 0L )
	    isc_event_free((isc_event_t **)&ev);
	sfd->sew = 0L;
    }

    if( sfd->sel != 0L )
    {
	ev = (isc_event_t *)isc_socket_fd_handle_selected(sfd->sock, 0);
	if( ev != 0L )
	    isc_event_free((isc_event_t **)&ev);
	sfd->sel = 0L;
	dbus_mgr_log_dbg("CLOSED socket %d", sfd->fd);
    }
}

static
void dbus_mgr_destroy_socket( void *p )
{
    DBusMgrSocket *sfd = p;

    isc_mem_put( sfd->mgr->mctx, sfd, sizeof(DBusMgrSocket) );
}