dbus_mgr.c

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

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