Example #1
0
static void
EmulatedDomainEnumerationCallBack(
    DNSServiceDomainEnumerationReplyResultType	inResult,
    const char *								inDomain,
    DNSServiceDiscoveryReplyFlags				inFlags,
    void *										inContext )
{
    DNS_UNUSED( inFlags );
    DNS_UNUSED( inContext );

    if( inResult == DNSServiceDomainEnumerationReplyAddDomain )
    {
        fprintf( stdout, "\"%s\" domain added emulated\n", inDomain );
    }
    else if( inResult == DNSServiceDomainEnumerationReplyAddDomainDefault )
    {
        fprintf( stdout, "\"%s\" default domain added emulated\n", inDomain );
    }
    else if( inResult == DNSServiceDomainEnumerationReplyRemoveDomain )
    {
        fprintf( stdout, "\"%s\" domain removed emulated\n", inDomain );
    }
    else
    {
        fprintf( stdout, "### unknown emulated domain enumeration callback result (%d)\n", inResult );
    }
}
Example #2
0
static void
RegistrationCallBack(
    void *							inContext,
    DNSRegistrationRef				inRef,
    DNSStatus						inStatusCode,
    const DNSRegistrationEvent *	inEvent )
{
    DNS_UNUSED( inContext );
    DNS_UNUSED( inRef );
    DNS_UNUSED( inStatusCode );

    switch( inEvent->type )
    {
    case kDNSRegistrationEventTypeRelease:
        break;

    case kDNSRegistrationEventTypeRegistered:
        fprintf( stdout, "name registered and active\n" );
        break;

    case kDNSRegistrationEventTypeNameCollision:
        fprintf( stdout, "name in use, please choose another name\n" );
        break;

    default:
        break;
    }
}
Example #3
0
static void
EmulatedBrowserCallBack(
    DNSServiceBrowserReplyResultType	inResult,
    const char *						inName,
    const char *						inType,
    const char *						inDomain,
    DNSServiceDiscoveryReplyFlags		inFlags,
    void *								inContext )
{
    DNS_UNUSED( inFlags );
    DNS_UNUSED( inContext );

    if( inResult == DNSServiceBrowserReplyAddInstance )
    {
        fprintf( stdout, "\"%s.%s%s\" service added emulated\n", inName, inType, inDomain );
    }
    else if( inResult == DNSServiceBrowserReplyRemoveInstance )
    {
        fprintf( stdout, "\"%s.%s%s\" service removed emulated\n", inName, inType, inDomain );
    }
    else
    {
        fprintf( stdout, "### unknown emulated browser callback result (%d)\n", inResult );
    }
}
Example #4
0
static void
EmulatedResolverCallBack(
    struct sockaddr *				inInterfaceAddr,
    struct sockaddr *				inAddr,
    const char *					inTextRecord,
    DNSServiceDiscoveryReplyFlags	inFlags,
    void *							inContext )
{
    struct sockaddr_in *		ifSin4;
    struct sockaddr_in *		sin4;
    char						ifIP[ 64 ];
    char						ip[ 64 ];

    DNS_UNUSED( inFlags );
    DNS_UNUSED( inContext );

    ifSin4 	= (struct sockaddr_in *) inInterfaceAddr;
    sin4 	= (struct sockaddr_in *) inAddr;

    fprintf( stdout, "service resolved to %s:%d on interface %s with text \"%s\"\n",
             IPv4ToString( *( (DNSOpaque32 *) &sin4->sin_addr.s_addr ), ip ),
             ntohs( sin4->sin_port ),
             IPv4ToString( *( (DNSOpaque32 *) &ifSin4->sin_addr.s_addr ), ifIP ),
             inTextRecord ? inTextRecord : "" );
}
DNS_LOCAL void
	DNSServiceBrowserPrivateCallBack( 
		void *					inContext, 
		DNSBrowserRef 			inRef, 
		DNSStatus 				inStatusCode, 
		const DNSBrowserEvent *	inEvent )
{
	dns_service_discovery_ref		obj;
	DNSServiceBrowserReply			callback;
	
	DNS_UNUSED( inRef );
	DNS_UNUSED( inStatusCode );
	
	check( inContext );
	obj = (dns_service_discovery_ref) inContext;
	check( obj->callback );
	callback = (DNSServiceBrowserReply) obj->callback;
	
	switch( inEvent->type )
	{
		case kDNSBrowserEventTypeAddService:
			debugf( DEBUG_NAME "add service \"%s.%s%s\"\n", 
				  inEvent->data.addService.name, 
				  inEvent->data.addService.type, 
				  inEvent->data.addService.domain );
			
			if( callback )
			{
				callback( DNSServiceBrowserReplyAddInstance, 
						  inEvent->data.addService.name, 
						  inEvent->data.addService.type, 
						  inEvent->data.addService.domain, 
						  DNSServiceDiscoverReplyFlagsFinished, 
						  obj->context );
			}
			break;
		
		case kDNSBrowserEventTypeRemoveService:
			debugf( DEBUG_NAME "remove service \"%s.%s%s\"\n", 
				  inEvent->data.removeService.name, 
				  inEvent->data.removeService.type, 
				  inEvent->data.removeService.domain );
			
			if( callback )
			{
				callback( DNSServiceBrowserReplyRemoveInstance, 
						  inEvent->data.removeService.name, 
						  inEvent->data.removeService.type, 
						  inEvent->data.removeService.domain, 
						  DNSServiceDiscoverReplyFlagsFinished, 
						  obj->context );
			}
			break;
		
		default:
			break;
	}
}
DNSServiceRegistrationReplyErrorType
	DNSServiceRegistrationRemoveRecord( 
		dns_service_discovery_ref 	inRef, 
		DNSRecordReference 			inRecordRef )
{
	DNS_UNUSED( inRef );
	DNS_UNUSED( inRecordRef );
	
	debugf( DEBUG_NAME "DNSServiceRegistrationRemoveRecord is currently not supported\n" );
	return( kDNSServiceDiscoveryUnsupportedErr );
}
DNS_LOCAL void
	DNSServiceDomainEnumerationPrivateCallBack( 
		void *					inContext, 
		DNSBrowserRef 			inRef, 
		DNSStatus 				inStatusCode, 
		const DNSBrowserEvent *	inEvent )
{
	dns_service_discovery_ref				obj;
	DNSServiceDomainEnumerationReply		callback;
	
	DNS_UNUSED( inRef );
	DNS_UNUSED( inStatusCode );
	
	check( inContext );
	obj = (dns_service_discovery_ref) inContext;
	check( obj->callback );
	callback = (DNSServiceDomainEnumerationReply) obj->callback;
	
	switch( inEvent->type )
	{
		case kDNSBrowserEventTypeAddDomain:
			debugf( DEBUG_NAME "add domain \"%s\"\n", inEvent->data.addDomain.domain );
			
			if( callback )
			{
				callback( DNSServiceDomainEnumerationReplyAddDomain, inEvent->data.addDomain.domain, 
						  DNSServiceDiscoverReplyFlagsFinished, obj->context );
			}
			break;
		
		case kDNSBrowserEventTypeAddDefaultDomain:
			debugf( DEBUG_NAME "add default domain \"%s\"\n", inEvent->data.addDefaultDomain.domain );
			
			if( callback )
			{
				callback( DNSServiceDomainEnumerationReplyAddDomainDefault, inEvent->data.addDefaultDomain.domain, 
						  DNSServiceDiscoverReplyFlagsFinished, obj->context );
			}
			break;
		
		case kDNSBrowserEventTypeRemoveDomain:
			debugf( DEBUG_NAME "add default domain \"%s\"\n", inEvent->data.removeDomain.domain );
			
			if( callback )
			{
				callback( DNSServiceDomainEnumerationReplyRemoveDomain, inEvent->data.removeDomain.domain, 
						  DNSServiceDiscoverReplyFlagsFinished, obj->context );
			}
			break;
		
		default:
			break;
	}
}
DNS_LOCAL void
	DNSServiceResolverPrivateCallBack( 
		void *						inContext, 
		DNSResolverRef 				inRef, 
		DNSStatus 					inStatusCode, 
		const DNSResolverEvent *	inEvent )
{
	dns_service_discovery_ref		obj;
	DNSServiceResolverReply			callback;
	struct sockaddr_in				interfaceAddr;
	struct sockaddr_in				addr;
	
	DNS_UNUSED( inRef );
	DNS_UNUSED( inStatusCode );
	
	check( inContext );
	obj = (dns_service_discovery_ref) inContext;
	check( obj->callback );
	callback = (DNSServiceResolverReply) obj->callback;
	
	switch( inEvent->type )
	{
		case kDNSResolverEventTypeResolved:
			debugf( DEBUG_NAME "resolved \"%s.%s%s\"\n", 
				  inEvent->data.resolved.name, 
				  inEvent->data.resolved.type, 
				  inEvent->data.resolved.domain );
			
			memset( &interfaceAddr, 0, sizeof( interfaceAddr ) );
			interfaceAddr.sin_family		= AF_INET;
			interfaceAddr.sin_port			= 0;
			interfaceAddr.sin_addr.s_addr	= inEvent->data.resolved.interfaceIP.u.ipv4.addr.v32;
			
			memset( &addr, 0, sizeof( addr ) );
			addr.sin_family			= AF_INET;
			addr.sin_port			= inEvent->data.resolved.address.u.ipv4.port.v16;
			addr.sin_addr.s_addr	= inEvent->data.resolved.address.u.ipv4.addr.v32;
			
			if( callback )
			{
				callback( (struct sockaddr *) &interfaceAddr, (struct sockaddr *) &addr, inEvent->data.resolved.textRecord, 
						  DNSServiceDiscoverReplyFlagsFinished, obj->context );
			}
			break;
				
		default:
			break;
	}
}
mach_port_t	DNSServiceDiscoveryMachPort( dns_service_discovery_ref inRef )
{
	DNS_UNUSED( inRef );
	
	debugf( DEBUG_NAME "DNSServiceDiscoveryMachPort is not supported\n" );
	return( 0 );
}
Example #10
0
static void	SigIntHandler( int inSignalNumber )
{
    DNS_UNUSED( inSignalNumber );

    signal( SIGINT, SIG_DFL );
    CFRunLoopStop( CFRunLoopGetCurrent() );
}
DNSServiceRegistrationReplyErrorType
	DNSServiceRegistrationUpdateRecord(
		dns_service_discovery_ref 	inRef, 
		DNSRecordReference			inRecordRef, 
		uint16_t 					inRDLength, 
		const char *				inRData, 
		uint32_t 					inTTL )
{
	DNS_UNUSED( inRef );
	DNS_UNUSED( inRecordRef );
	DNS_UNUSED( inRDLength );
	DNS_UNUSED( inRData );
	DNS_UNUSED( inTTL );
	
	debugf( DEBUG_NAME "DNSServiceRegistrationUpdateRecord is currently not supported\n" );
	return( kDNSServiceDiscoveryUnsupportedErr );
}
DNSRecordReference
	DNSServiceRegistrationAddRecord( 
		dns_service_discovery_ref	inRef, 
		uint16_t 					inRRType, 
		uint16_t 					inRDLength, 
		const char *				inRData, 
		uint32_t 					inTTL )
{
	DNS_UNUSED( inRef );
	DNS_UNUSED( inRRType );
	DNS_UNUSED( inRDLength );
	DNS_UNUSED( inRData );
	DNS_UNUSED( inTTL );
	
	debugf( DEBUG_NAME "DNSServiceRegistrationAddRecord is currently not supported\n" );
	return( 0 );
}
DNS_LOCAL void
	DNSServiceRegistrationPrivateCallBack( 
		void *							inContext, 
		DNSRegistrationRef				inRef, 
		DNSStatus						inStatusCode, 
		const DNSRegistrationEvent *	inEvent )
{
	dns_service_discovery_ref		obj;
	DNSServiceRegistrationReply		callback;
	
	DNS_UNUSED( inRef );
	DNS_UNUSED( inStatusCode );
	
	check( inContext );
	obj = (dns_service_discovery_ref) inContext;
	check( obj->callback );
	callback = (DNSServiceRegistrationReply) obj->callback;
	
	switch( inEvent->type )
	{
		case kDNSRegistrationEventTypeRegistered:
			debugf( DEBUG_NAME "name registered and active\n" );
			
			if( callback )
			{
				callback( kDNSServiceDiscoveryNoError, obj->context );
			}
			break;

		case kDNSRegistrationEventTypeNameCollision:
			debugf( DEBUG_NAME "name in use, please choose another name\n" );
			
			if( callback )
			{
				callback( kDNSServiceDiscoveryNameConflict, obj->context );
			}
			break;
		
		default:
			break;
	}
}
Example #14
0
static void	EmulatedRegistrationCallBack( DNSServiceRegistrationReplyErrorType inResult, void *inContext )
{
    DNS_UNUSED( inContext );

    if( inResult == kDNSServiceDiscoveryNoError )
    {
        fprintf( stdout, "service name registered successfully\n" );
    }
    else
    {
        fprintf( stdout, "service registration failed( %d)\n", inResult );
    }
}
Example #15
0
static void
HostRegistrationCallBack(
    void *					inContext,
    DNSHostRegistrationRef 	inRef,
    DNSStatus 				inStatusCode,
    void *					inData )
{
    DNS_UNUSED( inContext );
    DNS_UNUSED( inRef );
    DNS_UNUSED( inData );

    if( inStatusCode == kDNSNoErr )
    {
        fprintf( stdout, "host name registered and active\n" );
    }
    else if( inStatusCode == kDNSNameConflictErr )
    {
        fprintf( stdout, "host name in use, please choose another name\n" );
    }
    else
    {
        fprintf( stdout, "unknown host registration status (%ld)\n", inStatusCode );
    }
}
void	DNSServiceDiscovery_handleReply( void *inReplyMessage )
{
	DNS_UNUSED( inReplyMessage );
	
	debugf( DEBUG_NAME "DNSServiceDiscovery_handleReply is not supported\n" );
}
Example #17
0
static void ResolverCallBack( void *inContext, DNSResolverRef inRef, DNSStatus inStatusCode, const DNSResolverEvent *inEvent )
{
    char		ifIP[ 32 ];
    char		ip[ 32 ];

    DNS_UNUSED( inContext );
    DNS_UNUSED( inRef );
    DNS_UNUSED( inStatusCode );

    switch( inEvent->type )
    {
    case kDNSResolverEventTypeResolved:
    {
        const uint8_t *		p;
        const uint8_t *		end;
        int					i;

        fprintf( stdout, "resolved       \"%s.%s%s\" to \"%s\" (%s:%u) on interface 0x%p (%s)%s\n",
                 inEvent->data.resolved.name,
                 inEvent->data.resolved.type,
                 inEvent->data.resolved.domain,
                 inEvent->data.resolved.hostName,
                 IPv4ToString( inEvent->data.resolved.address.u.ipv4.addr, ip ),
                 ( inEvent->data.resolved.address.u.ipv4.port.v8[ 0 ] << 8 ) |
                 inEvent->data.resolved.address.u.ipv4.port.v8[ 1 ],
                 (int) inEvent->data.resolved.interfaceID,
                 IPv4ToString( inEvent->data.resolved.interfaceIP.u.ipv4.addr, ifIP ),
                 ( inEvent->data.resolved.textRecordRawSize > 0 ) ? " with text:" : "" );

        p 	= (const uint8_t *) inEvent->data.resolved.textRecordRaw;
        end = p + inEvent->data.resolved.textRecordRawSize;
        i 	= 0;

        if( gPrintTXTRecords )
        {
            while( p < end )
            {
                uint8_t		size;

                size = *p++;
                if( ( p + size ) > end )
                {
                    fprintf( stdout, "\n### MALFORMED TXT RECORD (length byte too big for record)\n\n" );
                    break;
                }
                fprintf( stdout, "%5d (%3d bytes): \"%.*s\"\n", i, size, size, p );
                p += size;
                ++i;
            }
            fprintf( stdout, "\n" );
        }
        break;
    }

    case kDNSResolverEventTypeRelease:
        break;

    default:
        break;
    }
}