dbus_mgr.c

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

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