Exemple #1
0
static int dns_module_init(noit_module_t *self) {
  const struct dns_nameval *nv;
  struct dns_ctx *pctx;
  int i;
  pthread_mutex_init(&dns_ctx_store_lock, NULL);
  pthread_mutex_init(&active_events_lock, NULL);
  /* HASH the rr types */
  for(i=0, nv = dns_type_index(i); nv->name; nv = dns_type_index(++i))
    noit_hash_store(&dns_rtypes,
                    nv->name, strlen(nv->name),
                    (void *)nv);
  /* HASH the class types */
  for(i=0, nv = dns_class_index(i); nv->name; nv = dns_class_index(++i))
    noit_hash_store(&dns_ctypes,
                    nv->name, strlen(nv->name),
                    (void *)nv);

  noit_check_interpolate_register_oper_fn("inaddrarpa",
                                          dns_interpolate_inaddr_arpa);
  noit_check_interpolate_register_oper_fn("reverseip",
                                          dns_interpolate_reverse_ip);

  if (dns_init(NULL, 0) < 0 || (pctx = dns_new(NULL)) == NULL) {
    noitL(nlerr, "Unable to initialize dns subsystem\n");
    return -1;
  }
  dns_free(pctx);
  if(dns_ctx_alloc(NULL, 0) == NULL) {
    noitL(nlerr, "Error setting up default dns resolver context.\n");
    return -1;
  }
  return 0;
}
Exemple #2
0
/******************************************************************************
 * DnsQuery_W              [DNSAPI.@]
 *
 */
DNS_STATUS WINAPI DnsQuery_W( PCWSTR name, WORD type, DWORD options, PVOID servers,
                              PDNS_RECORDW *result, PVOID *reserved )
{
    char *nameU;
    DNS_RECORDA *resultA;
    DNS_STATUS status;

    TRACE( "(%s,%s,0x%08x,%p,%p,%p)\n", debugstr_w(name), dns_type_to_str( type ),
           options, servers, result, reserved );

    if (!name || !result)
        return ERROR_INVALID_PARAMETER;

    nameU = dns_strdup_wu( name );
    if (!nameU) return ERROR_NOT_ENOUGH_MEMORY;

    status = DnsQuery_UTF8( nameU, type, options, servers, &resultA, reserved ); 

    if (status == ERROR_SUCCESS)
    {
        *result = (DNS_RECORDW *)DnsRecordSetCopyEx(
            (DNS_RECORD *)resultA, DnsCharSetUtf8, DnsCharSetUnicode );

        if (!*result) status = ERROR_NOT_ENOUGH_MEMORY;
        DnsRecordListFree( (DNS_RECORD *)resultA, DnsFreeRecordList );
    }

    dns_free( nameU );
    return status;
}
Exemple #3
0
static void dns_ctx_handle_free(void *vh) {
  dns_ctx_handle_t *h = vh;
  assert(h->timeout == NULL);
  free(h->ns);
  dns_close(h->ctx);
  dns_free(h->ctx);
}
Exemple #4
0
void noit_lua_init_dns() {
  int i;
  const struct dns_nameval *nv;
  struct dns_ctx *pctx;

  /* HASH the rr types */
  for(i=0, nv = dns_type_index(i); nv->name; nv = dns_type_index(++i))
    noit_hash_store(&dns_rtypes,
                    nv->name, strlen(nv->name),
                    (void *)nv);
  /* HASH the class types */
  for(i=0, nv = dns_class_index(i); nv->name; nv = dns_class_index(++i))
    noit_hash_store(&dns_ctypes,
                    nv->name, strlen(nv->name),
                    (void *)nv);

  eventer_name_callback("lua/dns_eventer", noit_lua_dns_eventer);
  eventer_name_callback("lua/dns_timeouts", noit_lua_dns_timeouts);

  if (dns_init(NULL, 0) < 0 || (pctx = dns_new(NULL)) == NULL) {
    noitL(noit_error, "Unable to initialize dns subsystem\n");
  }
  else
    dns_free(pctx);
}
Exemple #5
0
/******************************************************************************
 * DnsQuery_A           [DNSAPI.@]
 *
 */
DNS_STATUS WINAPI DnsQuery_A( PCSTR name, WORD type, DWORD options, PVOID servers,
                              PDNS_RECORDA *result, PVOID *reserved )
{
    WCHAR *nameW;
    DNS_RECORDW *resultW;
    DNS_STATUS status;

    TRACE( "(%s,%s,0x%08x,%p,%p,%p)\n", debugstr_a(name), dns_type_to_str( type ),
           options, servers, result, reserved );

    if (!name || !result)
        return ERROR_INVALID_PARAMETER;

    nameW = dns_strdup_aw( name );
    if (!nameW) return ERROR_NOT_ENOUGH_MEMORY;

    status = DnsQuery_W( nameW, type, options, servers, &resultW, reserved ); 

    if (status == ERROR_SUCCESS)
    {
        *result = (DNS_RECORDA *)DnsRecordSetCopyEx(
             (DNS_RECORD *)resultW, DnsCharSetUnicode, DnsCharSetAnsi );

        if (!*result) status = ERROR_NOT_ENOUGH_MEMORY;
        DnsRecordListFree( (DNS_RECORD *)resultW, DnsFreeRecordList );
    }

    dns_free( nameW );
    return status;
}
Exemple #6
0
/******************************************************************************
 * DnsNameCompare_A               [DNSAPI.@]
 *
 */
BOOL WINAPI DnsNameCompare_A( LPSTR name1, LPSTR name2 )
{
    BOOL ret;
    LPWSTR name1W, name2W;

    TRACE( "(%s,%s)\n", debugstr_a(name1), debugstr_a(name2) );

    name1W = dns_strdup_aw( name1 );
    name2W = dns_strdup_aw( name2 );

    ret = DnsNameCompare_W( name1W, name2W );

    dns_free( name1W );
    dns_free( name2W );

    return ret;
}
Exemple #7
0
static void
Resolver_dealloc(Resolver *self) {
    if (NULL != self->ctx) {
        dns_free(self->ctx);
        self->ctx = NULL;
    }
    self->ob_type->tp_free((PyObject*)self);
}
Exemple #8
0
unsigned char *dns_constructpacket (struct dnspkt *pkt, int *l)
{
   static unsigned char *buf, *ptr;
   int len, *offsets, qdcount, i;
   struct rr *list;
   
   qdcount = _get_listlen(pkt->query);

   len = dns_getpktsize(pkt);
   ptr = buf = malloc(len);
   memset(buf, 0, len);
   
   if (len > 512)
     syslog(LOG_WARNING, "WARNING: Constructed non-conform DNS-packet (size: %d)\n", len);
   
   offsets = alloca(qdcount * 4);
   
   /* Header */
   buf[0] = pkt->id / 256;
   buf[1] = pkt->id % 256;
   if (pkt->type == DNS_RESPONSE) {
      buf[2] = 0x84; /* Flags: Response, Authoritative Answer */
      buf[3] = 0x80; /* Flag: Recursion available */
   } else
     buf[2] = 0x01; /* Flags: Recursion desired */
   buf[5] = qdcount;
   buf[7] = _get_listlen(pkt->answer);
   ptr += 12;
   
   /* Query section */
   for (list = pkt->query, i=0; list; list = list->next, i++) {
      offsets[i] = ptr-buf;
      memcpy(ptr, list->data, list->len);
      ptr += list->len;
      ptr[1] = 16;
      ptr[3] = 1;
      ptr += 4;
   }
   
   /* Answer section */
   for (list = pkt->answer; list; list = list->next) {
      ptr[0] = 0xc0 | (offsets[list->link]/256);
      ptr[1] = offsets[list->link]%256;
      ptr[3] = 16;
      ptr[5] = 1;
      ptr[10] = list->len / 256;
      ptr[11] = list->len % 256;
      ptr += 12;
      memcpy(ptr, list->data, list->len);
      ptr += list->len;
   }
   *l = len;
   dns_free (pkt);
   return buf;
}
Exemple #9
0
/******************************************************************************
 * DnsValidateName_UTF8           [DNSAPI.@]
 *
 */
DNS_STATUS WINAPI DnsValidateName_UTF8( LPCSTR name, DNS_NAME_FORMAT format )
{
    LPWSTR nameW;
    DNS_STATUS ret;

    TRACE( "(%s, %d)\n", debugstr_a(name), format );

    nameW = dns_strdup_uw( name );
    ret = DnsValidateName_W( nameW, format );

    dns_free( nameW );
    return ret;
}
Exemple #10
0
static DNS_STATUS dns_copy_record( ns_msg msg, ns_sect section,
                                   unsigned short num, DNS_RECORDA **recp )
{
    DNS_STATUS ret;
    DNS_RECORDA *record;
    WORD dlen;
    ns_rr rr;

    if (dns_ns_parserr( &msg, section, num, &rr ) < 0)
        return DNS_ERROR_BAD_PACKET;

    if (!(record = dns_zero_alloc( dns_get_record_size( &rr ) )))
        return ERROR_NOT_ENOUGH_MEMORY;

    record->pName = dns_strdup_u( rr.name );
    if (!record->pName)
    {
        dns_free( record );
        return ERROR_NOT_ENOUGH_MEMORY;
    }

    record->wType = rr.type;
    record->Flags.S.Section = section;
    record->Flags.S.CharSet = DnsCharSetUtf8;
    record->dwTtl = rr.ttl;

    if ((ret = dns_copy_rdata( msg, &rr, record, &dlen )))
    {
        dns_free( record->pName );
        dns_free( record );
        return ret;
    }
    record->wDataLength = dlen;
    *recp = record;

    TRACE( "found %s record in %s section\n",
           dns_type_to_str( rr.type ), dns_section_to_str( section ) );
    return ERROR_SUCCESS;
}
Exemple #11
0
static int dns_module_init(noit_module_t *self) {
  const struct dns_nameval *nv;
  struct dns_ctx *pctx;
  int i;
  const char *config_val;
  dns_mod_config_t *conf;

  conf = noit_module_get_userdata(self);

  pthread_mutex_init(&dns_ctx_store_lock, NULL);
  pthread_mutex_init(&active_events_lock, NULL);

  conf->contexts = DEFAULT_MAX_CONTEXTS;
  if(noit_hash_retr_str(conf->options,
                         "contexts", strlen("contexts"),
                         (const char**)&config_val)) {
    conf->contexts = atoi(config_val);
    if (conf->contexts <= 0)
      conf->contexts = DEFAULT_MAX_CONTEXTS;
  }
  /* HASH the rr types */
  for(i=0, nv = dns_type_index(i); nv->name; nv = dns_type_index(++i))
    noit_hash_store(&dns_rtypes,
                    nv->name, strlen(nv->name),
                    (void *)nv);
  /* HASH the class types */
  for(i=0, nv = dns_class_index(i); nv->name; nv = dns_class_index(++i))
    noit_hash_store(&dns_ctypes,
                    nv->name, strlen(nv->name),
                    (void *)nv);

  noit_check_interpolate_register_oper_fn("inaddrarpa",
                                          dns_interpolate_inaddr_arpa);
  noit_check_interpolate_register_oper_fn("reverseip",
                                          dns_interpolate_reverse_ip);

  if (dns_init(NULL, 0) < 0 || (pctx = dns_new(NULL)) == NULL) {
    noitL(nlerr, "Unable to initialize dns subsystem\n");
    return -1;
  }
  dns_free(pctx);
  if(dns_module_dns_ctx_alloc(self, NULL, 0) == NULL) {
    noitL(nlerr, "Error setting up default dns resolver context.\n");
    return -1;
  }
  register_console_dns_commands();
  return 0;
}
Exemple #12
0
static void dns_ctx_handle_free(void *vh) {
  dns_ctx_handle_t *h = vh;
  free(h->ns);
  eventer_remove_fd(h->e->fd);
  eventer_free(h->e);
  h->e = NULL;
  if(h->timeout) {
    eventer_remove(h->timeout);
    eventer_free(h->timeout);
    h->timeout = NULL;
  }
  dns_close(h->ctx);
  dns_free(h->ctx);
  assert(h->timeout == NULL);
  free(h);
}
Exemple #13
0
gint slave_free(Slave* slave) {
    MAGIC_ASSERT(slave);
    gint returnCode = (slave->numPluginErrors > 0) ? -1 : 0;

    /* this launches delete on all the plugins and should be called before
     * the engine is marked "killed" and workers are destroyed.
     */
    g_hash_table_destroy(slave->hosts);

    /* we will never execute inside the plugin again */
    slave->forceShadowContext = TRUE;

    if(slave->topology) {
        topology_free(slave->topology);
    }
    if(slave->dns) {
        dns_free(slave->dns);
    }

    g_hash_table_destroy(slave->programs);

    g_mutex_clear(&(slave->lock));
    g_mutex_clear(&(slave->pluginInitLock));

    /* join and free spawned worker threads */
//TODO

    if(slave->cwdPath) {
        g_free(slave->cwdPath);
    }
    if(slave->dataPath) {
        g_free(slave->dataPath);
    }
    if(slave->hostsPath) {
        g_free(slave->hostsPath);
    }

    /* free main worker */
    worker_free(slave->mainThreadWorker);

    MAGIC_CLEAR(slave);
    g_free(slave);

    return returnCode;
}
Exemple #14
0
void master_free(Master* master) {
    MAGIC_ASSERT(master);

    if(master->topology) {
        topology_free(master->topology);
    }
    if(master->dns) {
        dns_free(master->dns);
    }
    if(master->config) {
        configuration_free(master->config);
    }
    if(master->random) {
        random_free(master->random);
    }

    MAGIC_CLEAR(master);
    g_free(master);

    message("simulation master destroyed");
}
Exemple #15
0
//Can be used to resolv a single PBX if uPBX!=0
void DNSUpdate(unsigned uPBX)
{
        MYSQL_RES *res;
        MYSQL_ROW field;
	unsigned uCount=0;
	unsigned uRRCount=0;

	if(!guSilent) printf("DNSUpdate(%u) start\n",uPBX);

	sprintf(gcQuery,"SELECT tContainer.cHostname,tContainer.uContainer"
			" FROM tContainer,tGroup,tGroupGlue"
			" WHERE tGroup.cLabel='Production PBXs'"
			" AND tGroup.uGroup=tGroupGlue.uGroup"
			" AND tContainer.uContainer=tGroupGlue.uContainer"
			" AND tContainer.uSource=0"
			" AND IF(%u,tContainer.uContainer=%u,1)"
				,uPBX,uPBX);
	mysql_query(&gMysql,gcQuery);
	if(mysql_errno(&gMysql))
	{
		printf(gcQuery);
		logfileLine("DNSUpdate",mysql_error(&gMysql));
		mysql_close(&gMysql);
		exit(2);
	}
        res=mysql_store_result(&gMysql);
	while((field=mysql_fetch_row(res)))
	{
		unsigned uA=0,uB=0,uC=0,uD=0;
		if(!guSilent)
			printf("%s\n",field[0]);

		//This has to be done first
		sscanf(field[1],"%u",&uPBX);

		//Handle special case where cDomain is an IPv4 number
		if(sscanf(field[0],"%u.%u.%u.%u",&uA,&uB,&uC,&uD)==4)
		{
			//Not sure if this is an exact test see RFC
			if(uA>0 && uA<256 && uB<256 && uC<256 && uD<256)
			{
				//5060,0,0 pattern it is not an A record
				//UpdatetAddressForPBX(uPBX,field[0],5060,0,0);
				UpdatetContainer(uPBX,field[0],5060,0,0);
				sprintf(gcQuery,"%s added as IP to %u\n",field[0],uPBX);
				if(!guSilent)
					printf(gcQuery);
				if(guLogLevel>0)
					logfileLine("DNSUpdate",gcQuery);
				continue;
			}
			//Matches pattern but out of range values
			logfileLine("DNSUpdate",field[0]);
		}
		uCount++;

		//DNS
		dns_host_t sDnsHost;
		dns_host_t sDnsHostSave;
		dns_host_t sDnsHost2;
		dns_host_t sDnsHostSave2;
		dns_srv_t sDnsSrv;
		char cHostname[128]={""};

		//SRV records
		unsigned uSRVCount=0;
		sprintf(cHostname,"_sip._udp.%.99s",field[0]);
		sDnsHost=dns_resolve(cHostname,3);
		if(guLogLevel>3)
			logfileLine("DNSUpdate dns_resolv",cHostname);
		sDnsHostSave=sDnsHost;
		if(sDnsHost!=NULL)
		{
			if(!guSilent)
				printf("SRV records\n");
			sDnsSrv=(dns_srv_t)sDnsHost->rr;

			//Nested get A record
			sprintf(cHostname,"%.99s",sDnsSrv->name);
			sDnsHost2=dns_resolve(cHostname,1);
			if(guLogLevel>3)
				logfileLine("DNSUpdate dns_resolv",cHostname);
			sDnsHostSave2=sDnsHost2;
			if(sDnsHost2!=NULL)
			{
				UpdatetContainer(uPBX,(char *)sDnsHost2->rr,sDnsSrv->port,sDnsSrv->priority,sDnsSrv->weight);
				uSRVCount++;
				if(guLogLevel>3)
					logfileLine("DNSUpdate A",(char *)sDnsHost2->rr);
				uRRCount++;
				while(sDnsHost2->next!=NULL)
				{
					sDnsHost2=sDnsHost2->next;
					UpdatetContainer(uPBX,(char *)sDnsHost2->rr,sDnsSrv->port,sDnsSrv->priority,sDnsSrv->weight);
					uSRVCount++;
					if(guLogLevel>3)
						logfileLine("DNSUpdate A",(char *)sDnsHost2->rr);
					uRRCount++;
				}
			}
			//
			if(guLogLevel>3)
				logfileLine("DNSUpdate SRV",sDnsSrv->name);
			uRRCount++;
			while(sDnsHost->next!=NULL)
			{
				sDnsHost=sDnsHost->next;
				sDnsSrv=(dns_srv_t)sDnsHost->rr;
				//Nested get A record
				sprintf(cHostname,"%.99s",sDnsSrv->name);
				sDnsHost2=dns_resolve(cHostname,1);
				sDnsHostSave2=sDnsHost2;
				if(sDnsHost2!=NULL)
				{
					UpdatetContainer(uPBX,(char *)sDnsHost2->rr,sDnsSrv->port,sDnsSrv->priority,sDnsSrv->weight);
					uSRVCount++;
					if(guLogLevel>3)
						logfileLine("DNSUpdate A",(char *)sDnsHost2->rr);
					uRRCount++;
					while(sDnsHost2->next!=NULL)
					{
						sDnsHost2=sDnsHost2->next;
						UpdatetContainer(uPBX,(char *)sDnsHost2->rr,sDnsSrv->port,sDnsSrv->priority,sDnsSrv->weight);
						uSRVCount++;
						if(guLogLevel>3)
							logfileLine("DNSUpdate A",(char *)sDnsHost2->rr);
						uRRCount++;
					}
			}
			//
				if(guLogLevel>3)
					logfileLine("DNSUpdate SRV",sDnsSrv->name);
				uRRCount++;
			}
		}
		else
		{
			if(guLogLevel>4)
				logfileLine("DNSUpdate No SRV",cHostname);
		}
		dns_free(sDnsHostSave);

		//Only if not two SRV records
		if(uSRVCount<2)
		{
			//A records
			sprintf(cHostname,"%.99s",field[0]);
			sDnsHost=dns_resolve(cHostname,1);
			sDnsHostSave=sDnsHost;
			if(sDnsHost!=NULL)
			{
				//UpdatetAddressForPBX(uPBX,(char *)sDnsHost->rr,5060,1000,100);
				UpdatetContainer(uPBX,(char *)sDnsHost2->rr,5060,0,0);
				if(guLogLevel>3)
					logfileLine("DNSUpdate A not SRV",(char *)sDnsHost->rr);
				uRRCount++;
				while(sDnsHost->next!=NULL)
				{
					sDnsHost=sDnsHost->next;
					//UpdatetAddressForPBX(uPBX,(char *)sDnsHost->rr,5060,1000,100);
					UpdatetContainer(uPBX,(char *)sDnsHost2->rr,5060,0,0);
					if(guLogLevel>3)
						logfileLine("DNSUpdate A not SRV",(char *)sDnsHost->rr);
					uRRCount++;
				}
			}
			else
			{
				if(guLogLevel>0)
					logfileLine("DNSUpdate No A not SRV",cHostname);
				if(!guSilent)
					printf("No A records not SRV\n");
			}
			dns_free(sDnsHostSave);
		}
	}
	mysql_free_result(res);

	if(guLogLevel>0)
	{
		sprintf(gcQuery,"Processed %u cHostnames updated %u tAddress records",uCount,uRRCount);
		logfileLine("DNSUpdate",gcQuery);
	}

	if(!guSilent) printf("DNSUpdate() end\n");
}//void DNSUpdate()
Exemple #16
0
struct dnspkt *
dns_extractpkt(const unsigned char *buf, int len)
{
   u_int16_t qdcount, ancount, remain, *offsets, i, j, off;
   const unsigned char *ptr;
   struct dnspkt *pkt;
   struct rr *rrp;
   struct ns_answer_header *nsh;
   
   if (len < 17)
     return NULL;
   
   pkt = dns_alloc();
   struct ns_transaction_header *nsth=
	   (struct ns_transaction_header*)buf;
   pkt->id = ntohs(nsth->tid);
   
   qdcount = ntohs(nsth->questions);
   ancount = ntohs(nsth->answers);
   offsets = malloc(qdcount * 4);
   
   ptr = buf + sizeof(struct ns_transaction_header);
   remain = len - sizeof(struct ns_transaction_header);
   
   i = 0;
   while (qdcount--)
     {
	offsets[i++] = ptr - buf;
	rrp = _new_listitem(&pkt->query);
	rrp->data = decompress_label((char*)buf, len, (char*)ptr);
	if (!rrp->data)
	  {
	     syslog(LOG_ERR, "dns_extractpkt: decompress_label choked in qd\n");
	     free(offsets);
	     dns_free(pkt);
	     return NULL;
	  }
	rrp->len = strlen(rrp->data)+1;
	ptr = _skip_lbl(ptr, &remain);
	if (!ptr)
	  {
	     syslog(LOG_ERR, "dns_extractpkt: _skip_lbl choked in qd\n");
	     free(offsets);
	     dns_free(pkt);
	     return NULL;
	  }
	ptr += 4;
	remain -= 4;
     }
   while (ancount--)
   {
	rrp = _new_listitem(&pkt->answer);
	rrp->link = -1;
	if ((ptr[0] & 0xc0) == 0xc0)
	  {
	     off = (ptr[0] & ~(0xc0)) * 256 + ptr[1];
	     for (j = 0; j < i; j++)
	       if (offsets[j] == off)
		 break;
	     if (j < i)
	       rrp->link = j;
	  }
	ptr=_skip_lbl(ptr,&remain);
	nsh=(struct ns_answer_header *)ptr;
	ptr+=sizeof(struct ns_answer_header);
	remain-=sizeof(struct ns_answer_header);
	//printf("REMAIN=%u, datalen=%u, type= 0x%02x, sizeof ns_answer_header=%u\n",remain,ntohs(nsh->datalen), ntohs(nsh->type),sizeof(struct ns_answer_header));
	if (ntohs(nsh->type) != NSTYPE_TXT){
		ptr+=ntohs(nsh->datalen);
		remain-=ntohs(nsh->datalen);
		continue;
	}
	rrp->len = ntohs(nsh->datalen);
	rrp->data = malloc(rrp->len);
	memcpy(rrp->data, ptr,rrp->len);
	remain -= rrp->len;
	ptr += rrp->len;
   }
   return(pkt);
}
Exemple #17
0
//Can be used to resolv a single GW if uGateway!=0
void DNSUpdateGW(char const *cCluster,unsigned uGateway)
{
        MYSQL_RES *res;
        MYSQL_ROW field;
	unsigned uCount=0;
	unsigned uRRCount=0;

	if(!guSilent) printf("DNSUpdateGW() start\n");

	//outbound GW only non empty cHostname
	sprintf(gcQuery,"SELECT tGateway.cHostname,tGateway.uGateway"
			" FROM tGateway,tCluster"
			" WHERE tGateway.uCluster=tCluster.uCluster"
			" AND tCluster.cLabel='%s'"
			" AND tGateway.uGatewayType=2"
			" AND tGateway.cHostname!=''"
			" AND IF(%u,tGateway.uGateway=%u,1)"
				,cCluster,uGateway,uGateway);
	mysql_query(&gMysql,gcQuery);
	if(mysql_errno(&gMysql))
	{
		printf(gcQuery);
		logfileLine("DNSUpdateGW",mysql_error(&gMysql));
		mysql_close(&gMysql);
		exit(2);
	}
        res=mysql_store_result(&gMysql);
	while((field=mysql_fetch_row(res)))
	{
		unsigned uA=0,uB=0,uC=0,uD=0;
		if(!guSilent)
			printf("%s\n",field[0]);

		//This has to be done first
		sscanf(field[1],"%u",&uGateway);

		//Handle special case where cDomain is an IPv4 number
		if(sscanf(field[0],"%u.%u.%u.%u",&uA,&uB,&uC,&uD)==4)
		{
			//Not sure if this is an exact test see RFC
			if(uA>0 && uA<256 && uB<256 && uC<256 && uD<256)
			{
				//5060,0,0 pattern it is not an A record
				UpdatetAddressForGateway(uGateway,field[0],5060,0,0);
				sprintf(gcQuery,"%s added as IP to %u\n",field[0],uGateway);
				if(!guSilent)
					printf(gcQuery);
				if(guLogLevel>0)
					logfileLine("DNSUpdateGW",gcQuery);
				continue;
			}
			//Matches pattern but out of range values
			logfileLine("DNSUpdateGW",field[0]);
		}
		uCount++;

		//DNS
		dns_host_t sDnsHost;
		dns_host_t sDnsHostSave;
		dns_host_t sDnsHost2;
		dns_host_t sDnsHostSave2;
		dns_srv_t sDnsSrv;
		char cHostname[128]={""};

		//SRV records
		sprintf(cHostname,"_sip._udp.%.99s",field[0]);
		sDnsHost=dns_resolve(cHostname,3);
		sDnsHostSave=sDnsHost;
		if(sDnsHost!=NULL)
		{
			if(!guSilent)
				printf("SRV records\n");
			sDnsSrv=(dns_srv_t)sDnsHost->rr;

			//Nested get A record
			sprintf(cHostname,"%.99s",sDnsSrv->name);
			sDnsHost2=dns_resolve(cHostname,1);
			sDnsHostSave2=sDnsHost2;
			if(sDnsHost2!=NULL)
			{
				UpdatetAddressForGateway(uGateway,(char *)sDnsHost2->rr,sDnsSrv->port,sDnsSrv->priority,sDnsSrv->weight);
				if(guLogLevel>3)
					logfileLine("DNSUpdateGW A",(char *)sDnsHost2->rr);
				uRRCount++;
				while(sDnsHost2->next!=NULL)
				{
					sDnsHost2=sDnsHost2->next;
					UpdatetAddressForGateway(uGateway,(char *)sDnsHost2->rr,sDnsSrv->port,sDnsSrv->priority,sDnsSrv->weight);
					if(guLogLevel>3)
						logfileLine("DNSUpdateGW A",(char *)sDnsHost2->rr);
					uRRCount++;
				}
			}
			//
			if(guLogLevel>3)
				logfileLine("DNSUpdateGW SRV",sDnsSrv->name);
			uRRCount++;
			while(sDnsHost->next!=NULL)
			{
				sDnsHost=sDnsHost->next;
				sDnsSrv=(dns_srv_t)sDnsHost->rr;
				//Nested get A record
				sprintf(cHostname,"%.99s",sDnsSrv->name);
				sDnsHost2=dns_resolve(cHostname,1);
				sDnsHostSave2=sDnsHost2;
				if(sDnsHost2!=NULL)
				{
					UpdatetAddressForGateway(uGateway,(char *)sDnsHost2->rr,sDnsSrv->port,sDnsSrv->priority,sDnsSrv->weight);
					if(guLogLevel>3)
						logfileLine("DNSUpdateGW A",(char *)sDnsHost2->rr);
					uRRCount++;
					while(sDnsHost2->next!=NULL)
					{
						sDnsHost2=sDnsHost2->next;
						UpdatetAddressForGateway(uGateway,(char *)sDnsHost2->rr,sDnsSrv->port,sDnsSrv->priority,sDnsSrv->weight);
						if(guLogLevel>3)
							logfileLine("DNSUpdateGW A",(char *)sDnsHost2->rr);
						uRRCount++;
					}
			}
			//
				if(guLogLevel>3)
					logfileLine("DNSUpdateGW SRV",sDnsSrv->name);
				uRRCount++;
			}
		}
		else
		{
			if(guLogLevel>4)
				logfileLine("DNSUpdateGW No SRV",cHostname);
		}
		dns_free(sDnsHostSave);

		//A records
		sprintf(cHostname,"%.99s",field[0]);
		sDnsHost=dns_resolve(cHostname,1);
		sDnsHostSave=sDnsHost;
		if(sDnsHost!=NULL)
		{
			UpdatetAddressForGateway(uGateway,(char *)sDnsHost->rr,5060,1000,100);
			if(guLogLevel>3)
				logfileLine("DNSUpdateGW A",(char *)sDnsHost->rr);
			uRRCount++;
			while(sDnsHost->next!=NULL)
			{
				sDnsHost=sDnsHost->next;
				UpdatetAddressForGateway(uGateway,(char *)sDnsHost->rr,5060,1000,100);
				if(guLogLevel>3)
					logfileLine("DNSUpdateGW A",(char *)sDnsHost->rr);
				uRRCount++;
			}
		}
		else
		{
			if(guLogLevel>0)
				logfileLine("DNSUpdateGW No A",cHostname);
			if(!guSilent)
				printf("No A records\n");
		}
		dns_free(sDnsHostSave);

		//Remove non updated in this pass records 300s 5min ago
		sprintf(gcQuery,"DELETE FROM tAddress"
				" WHERE tAddress.uGateway=%u AND uOwner=0"
				" AND ((uModDate>0 AND (uModDate<(UNIX_TIMESTAMP(NOW())-300))) OR (uModDate=0 AND uCreatedDate<(UNIX_TIMESTAMP(NOW())-300)))"
					,uGateway);
		mysql_query(&gMysql,gcQuery);
		if(mysql_errno(&gMysql))
		{
			printf(gcQuery);
			logfileLine("DNSUpdateGW",mysql_error(&gMysql));
			mysql_close(&gMysql);
			exit(2);
		}
		if(guLogLevel>0)
		{
			sprintf(gcQuery,"%lu stale tAddress records deleted",(long unsigned)mysql_affected_rows(&gMysql));
			logfileLine("DNSUpdateGW",gcQuery);
		}
	}
	mysql_free_result(res);

	if(guLogLevel>0)
	{
		sprintf(gcQuery,"Processed %u cHostnames updated %u tAddress records",uCount,uRRCount);
		logfileLine("DNSUpdateGW",gcQuery);
	}

	if(!guSilent) printf("DNSUpdateGW() end\n");
}//void DNSUpdateGW(char const *cCluster)
Exemple #18
0
static dns_ctx_handle_t *dns_module_dns_ctx_alloc(noit_module_t *self, const char *ns, int port) {
  void *vh;
  char *hk = NULL;
  dns_mod_config_t *conf = noit_module_get_userdata(self);
  int randkey = random() % conf->contexts;
  dns_ctx_handle_t *h = NULL;
  if(ns && *ns == '\0') ns = NULL;
  pthread_mutex_lock(&dns_ctx_store_lock);
  if(ns == NULL && default_ctx_handle != NULL) {
    /* special case -- default context */
    h = default_ctx_handle;
    dns_module_dns_ctx_acquire(h);
    goto bail;
  }

  if (ns != NULL) {
    int len = snprintf(NULL, 0, "%s:%d:%d", ns, port, randkey); 
    hk = (char *)malloc(len+1);
    snprintf(hk, len+1, "%s:%d:%d", ns, port, randkey);
  }

  if(ns &&
     noit_hash_retrieve(&dns_ctx_store, hk, strlen(hk), &vh)) {
    h = (dns_ctx_handle_t *)vh;
    dns_module_dns_ctx_acquire(h);
    free(hk);
  }
  else {
    int failed = 0;
    h = calloc(1, sizeof(*h));
    h->ns = ns ? strdup(ns) : NULL;
    h->ctx = dns_new(NULL);
    if(dns_init(h->ctx, 0) != 0) {
      noitL(nlerr, "dns_init failed\n");
      failed++;
    }
    dns_set_dbgfn(h->ctx, dns_debug_wrap);
    if(ns) {
      if(dns_add_serv(h->ctx, NULL) < 0) {
        noitL(nlerr, "dns_add_serv(NULL) failed\n");
        failed++;
      }
      if(dns_add_serv(h->ctx, ns) < 0) {
        noitL(nlerr, "dns_add_serv(%s) failed\n", ns);
        failed++;
      }
    }
    if(port && port != DNS_PORT) {
      dns_set_opt(h->ctx, DNS_OPT_PORT, port);
    }
    if(dns_open(h->ctx) < 0) {
      noitL(nlerr, "dns_open failed\n");
      failed++;
    }
    if(failed) {
      free(h->ns);
      dns_free(h->ctx);
      free(h);
      free(hk);
      h = NULL;
      goto bail;
    }
    h->hkey = hk;
    dns_set_tmcbck(h->ctx, dns_module_eventer_dns_utm_fn, h);
    h->e = eventer_alloc();
    h->e->mask = EVENTER_READ | EVENTER_EXCEPTION;
    h->e->closure = h;
    h->e->callback = dns_module_eventer_callback;
    h->e->fd = dns_sock(h->ctx);
    eventer_add(h->e);
    h->refcnt = 1;
    if(!ns)
      default_ctx_handle = h;
    else
      noit_hash_store(&dns_ctx_store, h->hkey, strlen(h->hkey), h);
  }
 bail:
  pthread_mutex_unlock(&dns_ctx_store_lock);
  return h;
}
Exemple #19
0
static DNS_STATUS dns_copy_rdata( ns_msg msg, const ns_rr *rr, DNS_RECORDA *r, WORD *dlen )
{
    DNS_STATUS ret = ERROR_SUCCESS;
    const unsigned char *pos = rr->rdata;
    unsigned int i, size;

    switch (rr->type)
    {
    case ns_t_a:
    {
        r->Data.A.IpAddress = *(const DWORD *)pos;
        *dlen = sizeof(DNS_A_DATA);
        break; 
    }
    case ns_t_aaaa:
    {
        for (i = 0; i < sizeof(IP6_ADDRESS)/sizeof(DWORD); i++)
        {
            r->Data.AAAA.Ip6Address.IP6Dword[i] = *(const DWORD *)pos;
            pos += sizeof(DWORD);
        }

        *dlen = sizeof(DNS_AAAA_DATA);
        break;
    }
    case ns_t_key:
    {
        /* FIXME: byte order? */
        r->Data.KEY.wFlags      = *(const WORD *)pos;   pos += sizeof(WORD);
        r->Data.KEY.chProtocol  = *(const BYTE *)pos++;
        r->Data.KEY.chAlgorithm = *(const BYTE *)pos++;

        size = rr->rdata + rr->rdlength - pos;

        for (i = 0; i < size; i++)
            r->Data.KEY.Key[i] = *(const BYTE *)pos++;

        *dlen = sizeof(DNS_KEY_DATA) + (size - 1) * sizeof(BYTE);
        break;
    }
    case ns_t_rp:
    case ns_t_minfo:
    {
        r->Data.MINFO.pNameMailbox = dns_dname_from_msg( msg, pos );
        if (!r->Data.MINFO.pNameMailbox) return ERROR_NOT_ENOUGH_MEMORY;

        if (dns_ns_name_skip( &pos, ns_msg_end( msg ) ) < 0)
            return DNS_ERROR_BAD_PACKET;

        r->Data.MINFO.pNameErrorsMailbox = dns_dname_from_msg( msg, pos );
        if (!r->Data.MINFO.pNameErrorsMailbox)
        {
            dns_free( r->Data.MINFO.pNameMailbox ); 
            return ERROR_NOT_ENOUGH_MEMORY;
        }

        *dlen = sizeof(DNS_MINFO_DATAA);
        break; 
    }
    case ns_t_afsdb:
    case ns_t_rt:
    case ns_t_mx:
    {
        r->Data.MX.wPreference = ntohs( *(const WORD *)pos );
        r->Data.MX.pNameExchange = dns_dname_from_msg( msg, pos + sizeof(WORD) );
        if (!r->Data.MX.pNameExchange) return ERROR_NOT_ENOUGH_MEMORY;

        *dlen = sizeof(DNS_MX_DATAA);
        break; 
    }
    case ns_t_null:
    {
        r->Data.Null.dwByteCount = rr->rdlength;
        memcpy( r->Data.Null.Data, rr->rdata, rr->rdlength );

        *dlen = sizeof(DNS_NULL_DATA) + rr->rdlength - 1;
        break;
    }
    case ns_t_cname:
    case ns_t_ns:
    case ns_t_mb:
    case ns_t_md:
    case ns_t_mf:
    case ns_t_mg:
    case ns_t_mr:
    case ns_t_ptr:
    {
        r->Data.PTR.pNameHost = dns_dname_from_msg( msg, pos );
        if (!r->Data.PTR.pNameHost) return ERROR_NOT_ENOUGH_MEMORY;

        *dlen = sizeof(DNS_PTR_DATAA);
        break;
    }
    case ns_t_sig:
    {
        r->Data.SIG.pNameSigner = dns_dname_from_msg( msg, pos );
        if (!r->Data.SIG.pNameSigner) return ERROR_NOT_ENOUGH_MEMORY;

        if (dns_ns_name_skip( &pos, ns_msg_end( msg ) ) < 0)
            return DNS_ERROR_BAD_PACKET;

        /* FIXME: byte order? */
        r->Data.SIG.wTypeCovered  = *(const WORD *)pos;   pos += sizeof(WORD);
        r->Data.SIG.chAlgorithm   = *(const BYTE *)pos++;
        r->Data.SIG.chLabelCount  = *(const BYTE *)pos++;
        r->Data.SIG.dwOriginalTtl = *(const DWORD *)pos;  pos += sizeof(DWORD);
        r->Data.SIG.dwExpiration  = *(const DWORD *)pos;  pos += sizeof(DWORD);
        r->Data.SIG.dwTimeSigned  = *(const DWORD *)pos;  pos += sizeof(DWORD);
        r->Data.SIG.wKeyTag       = *(const WORD *)pos;

        size = rr->rdata + rr->rdlength - pos;

        for (i = 0; i < size; i++)
            r->Data.SIG.Signature[i] = *(const BYTE *)pos++;

        *dlen = sizeof(DNS_SIG_DATAA) + (size - 1) * sizeof(BYTE);
        break; 
    }
    case ns_t_soa:
    {
        r->Data.SOA.pNamePrimaryServer = dns_dname_from_msg( msg, pos );
        if (!r->Data.SOA.pNamePrimaryServer) return ERROR_NOT_ENOUGH_MEMORY;

        if (dns_ns_name_skip( &pos, ns_msg_end( msg ) ) < 0)
            return DNS_ERROR_BAD_PACKET;

        r->Data.SOA.pNameAdministrator = dns_dname_from_msg( msg, pos );
        if (!r->Data.SOA.pNameAdministrator)
        {
            dns_free( r->Data.SOA.pNamePrimaryServer ); 
            return ERROR_NOT_ENOUGH_MEMORY;
        }

        if (dns_ns_name_skip( &pos, ns_msg_end( msg ) ) < 0)
            return DNS_ERROR_BAD_PACKET;

        r->Data.SOA.dwSerialNo   = ntohl( *(const DWORD *)pos ); pos += sizeof(DWORD);
        r->Data.SOA.dwRefresh    = ntohl( *(const DWORD *)pos ); pos += sizeof(DWORD);
        r->Data.SOA.dwRetry      = ntohl( *(const DWORD *)pos ); pos += sizeof(DWORD);
        r->Data.SOA.dwExpire     = ntohl( *(const DWORD *)pos ); pos += sizeof(DWORD);
        r->Data.SOA.dwDefaultTtl = ntohl( *(const DWORD *)pos ); pos += sizeof(DWORD);

        *dlen = sizeof(DNS_SOA_DATAA);
        break; 
    }
    case ns_t_srv:
    {
        r->Data.SRV.wPriority = ntohs( *(const WORD *)pos ); pos += sizeof(WORD);
        r->Data.SRV.wWeight   = ntohs( *(const WORD *)pos ); pos += sizeof(WORD);
        r->Data.SRV.wPort     = ntohs( *(const WORD *)pos ); pos += sizeof(WORD);

        r->Data.SRV.pNameTarget = dns_dname_from_msg( msg, pos );
        if (!r->Data.SRV.pNameTarget) return ERROR_NOT_ENOUGH_MEMORY;

        *dlen = sizeof(DNS_SRV_DATAA);
        break; 
    }
    case ns_t_hinfo:
    case ns_t_isdn:
    case ns_t_x25:
    case ns_t_txt:
    {
        i = 0;
        while (pos[0] && pos < rr->rdata + rr->rdlength)
        {
            r->Data.TXT.pStringArray[i] = dns_str_from_rdata( pos );
            if (!r->Data.TXT.pStringArray[i])
            {
                while (i > 0) dns_free( r->Data.TXT.pStringArray[--i] );
                return ERROR_NOT_ENOUGH_MEMORY;
            }
            i++;
            pos += pos[0] + 1;
        }
        r->Data.TXT.dwStringCount = i;
        *dlen = sizeof(DNS_TXT_DATAA) + (i - 1) * sizeof(PCHAR);
        break;
    }
    case ns_t_atma:
    case ns_t_loc:
    case ns_t_nxt:
    case ns_t_tsig:
    case ns_t_wks:
    case 0x00f9:  /* TKEY */
    case 0xff01:  /* WINS */
    case 0xff02:  /* WINSR */
    default:
        FIXME( "unhandled type: %s\n", dns_type_to_str( rr->type ) );
        return DNS_ERROR_RCODE_NOT_IMPLEMENTED;
    }

    return ret;
}