dbus_mgr.c

来自「非常好的dns解析软件」· C语言 代码 · 共 2,442 行 · 第 1/5 页

    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 )
	return;

    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 ) 
	    return;
	*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);
} 

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, ISC_FALSE, 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);