dbus_mgr.c

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

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