Prepare to Version 1.0.2.43SF and tntegrate stock changes

Author: voxel

asm-openssl-1.0.2m.tar

@@ -12,7 +12,7 @@ CFLAGS?= -O2
 all :   dnsmasq
 
 dnsmasq :
-	$(MAKE) I18N=-DNO_GETTEXT -f ../bld/Makefile -C $(SRC) dnsmasq 
+	$(MAKE) I18N=-DNO_GETTEXT -f ../bld/Makefile -C $(SRC) dnsmasq -lconfig
 
 clean :
 	rm -f *~ $(SRC)/*.mo contrib/*/*~ */*~ $(SRC)/*.pot 

asm-openssl-1.0.2n.tar

@@ -47,6 +47,10 @@ static char *compile_opts =
 static pid_t pid;
 static int pipewrite;
 
+/* libconfig.so */
+extern char *config_get(char *name);
+extern int config_match(char *name, char *match);
+
 #ifdef DNI_IPV6_FEATURE
 extern void check_timeout_forward(struct daemon *daemon, time_t now);
 #endif
@@ -853,7 +857,7 @@ static int set_dns_listeners(struct daemon *daemon, time_t now, fd_set *set, int
       /* death of a child goes through the select loop, so
 	 we don't need to explicitly arrange to wake up here */
       for (i = 0; i < MAX_PROCS; i++)
-	if (daemon->tcp_pids[i] == 0)
+	if ( daemon->tcp_pids[i] == 0 && listener->tcpfd != -1 )
 	  {
 	    FD_SET(listener->tcpfd, set);
 	    bump_maxfd(listener->tcpfd, maxfdp);
@@ -877,6 +881,8 @@ static void check_dns_listeners(struct daemon *daemon, fd_set *set, time_t now)
 {
   struct serverfd *serverfdp;
   struct listener *listener;	  
+  char *buf = NULL;
+  short dial_flag = 0;
 
   for (serverfdp = daemon->sfds; serverfdp; serverfdp = serverfdp->next)
     if (FD_ISSET(serverfdp->fd, set))
@@ -885,14 +891,32 @@ static void check_dns_listeners(struct daemon *daemon, fd_set *set, time_t now)
   for (listener = daemon->listeners; listener; listener = listener->next)
     {
       if (FD_ISSET(listener->fd, set))
-	receive_query(listener, daemon, now); 
+      {
+	buf = config_get("wan_proto");
+	if(!strncmp(buf, "pppoe", 5) || !strncmp(buf, "pptp", 4) || !strncmp(buf, "l2tp", 4))
+	{
+		if(config_match("wan_pppoe_demand","1") 
+			|| config_match("wan_pptp_demand","1")
+			|| config_match("wan_l2tp_demand","1"))
+		{
+			dial_flag = 1;
+			system("echo \"1\">/proc/sys/net/dni/dial_on_demand_dns"); 
+		}
+	}
+		if(listener->family == AF_PACKET)
+			receive_raw_query(listener, daemon, now);  
+		else
+			receive_query(listener, daemon, now); 
+	if(dial_flag)
+		system("echo \"0\">/proc/sys/net/dni/dial_on_demand_dns"); 
+      }
 
 #ifdef HAVE_TFTP     
       if (listener->tftpfd != -1 && FD_ISSET(listener->tftpfd, set))
 	tftp_request(listener, daemon, now);
 #endif
 
-      if (FD_ISSET(listener->tcpfd, set))
+      if (listener->tcpfd != -1 && FD_ISSET(listener->tcpfd, set))
 	{
 	  int confd;
 	  struct irec *iface = NULL;

git_home/datalib.git/datalib

@@ -16,13 +16,16 @@
 #include <sys/types.h> 
 #include <netinet/in.h>
 
+extern char *config_get(char *name);
+
 /*
  * Advanced API
  * source interface/address selection, source routing, etc...
  * *under construction*
  * (this struct is copy from linux/ipv6.h). since netinet/in.h doesn't 
  * have this struct.
  */
+ 
 struct in6_pktinfo {
 	struct in6_addr ipi6_addr;
 	int             ipi6_ifindex;
@@ -99,6 +102,15 @@ extern int capset(cap_user_header_t header, cap_user_data_t data);
 #include <sys/prctl.h>
 #endif
 
+#ifdef HAVE_IPV6
+#include <linux/if_packet.h>
+#include <linux/if_ether.h>
+#include <asm/byteorder.h>
+#include <linux/filter.h>
+#include <linux/udp.h>
+#include <linux/icmpv6.h>
+#endif
+
 /* Min buffer size: we check after adding each record, so there must be 
    memory for the largest packet, and the largest record so the
    min for DNS is PACKETSZ+MAXDNAME+RRFIXEDSZ which is < 1000.
@@ -141,7 +153,7 @@ extern int capset(cap_user_header_t header, cap_user_data_t data);
 #ifdef SUP_STATIC_PPTP
 #define DEF_STATIC_PPTP_CONFIG "/tmp/pptp.conf"
 #endif
-
+#pragma pack(1)
 struct all_addr {
   union {
     struct in_addr addr4;
@@ -489,6 +501,33 @@ typedef unsigned char u8;
 typedef unsigned short u16;
 typedef unsigned int u32;
 
+#ifdef HAVE_IPV6
+struct ipv6hdr {
+#if defined(__LITTLE_ENDIAN_BITFIELD)
+	u8	priority:4,
+		version:4;
+#elif defined(__BIG_ENDIAN_BITFIELD)
+	u8	version:4,
+		priority:4;
+#endif
+	u8	flow_lbl[3];
+	u16	payload_len;
+	u8	nexthdr;
+	u8	hop_limit;
+	struct in6_addr	saddr;
+	struct in6_addr daddr;
+};
+
+struct udp_dns_packet {
+	struct ethhdr eth;
+	struct ipv6hdr ip6;
+	struct udphdr udp;
+	char data[256];
+};
+
+#define IP6VERSION 6
+#define DNS_PORT 53
+#endif
 
 struct dhcp_packet {
   u8 op, htype, hlen, hops;
@@ -688,6 +727,8 @@ int check_for_local_domain(char *name, time_t now, struct daemon *daemon);
 unsigned int questions_crc(HEADER *header, size_t plen, char *buff);
 size_t resize_packet(HEADER *header, size_t plen, 
 		  unsigned char *pheader, size_t hlen);
+extern int get_lan_linklocal_ipaddr6(struct in6_addr *inp6, int global_flag);
+extern int get_lan_ipaddr(struct in_addr *inp);
 #ifdef SUP_STATIC_PPTP
 extern unsigned char *ex_skip_questions(HEADER *header, size_t plen);
 #endif
@@ -853,4 +894,5 @@ extern unsigned char *get_resolve_address(int *addrcount, struct in_addr *ip_add
 extern struct dname_record *dname_list;
 extern char *dname_check_file;
 extern time_t dname_save_time;
+#pragma pack()
 //endif

git_home/datalib.git/libconfig.so

@@ -858,6 +858,212 @@ void reply_query(struct serverfd *sfd, struct daemon *daemon, time_t now)
     }
 }
 
+#pragma pack(1)
+static unsigned short checksum(unsigned short *start, int len)
+{
+	unsigned int sum = 0;
+	unsigned short *w = start;
+	unsigned short answer = 0;
+	while (1 < len) {
+		sum += *w++;
+		len -= 2;
+	}
+	if (1 == len) {
+		*(unsigned char *)(&answer) = *(unsigned char *)w;
+		sum += answer;
+	}
+	while (sum >> 16)
+		sum = (sum & 0xffff) + (sum >> 16);
+	return (unsigned short)~sum;
+}
+
+void receive_raw_query(struct listener *listen, struct daemon *daemon, time_t now)
+{
+	if(config_match("ap_mode", "0"))
+		return 0;
+
+	HEADER *reply_header ;
+	unsigned int fromlen = 0;
+	struct sockaddr_in6 src;
+	struct udp_dns_packet rawhdr;
+	struct udp_dns_packet *packet, *pkt;
+	char buf[1024] = {0}, none_addr[16] = {0}, buf1[1024]={0};
+	char linkprefix[] = {0xfe,0x80,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+	int bytes, n, i, flag = 0;
+	u_int16_t check;
+	struct in6_addr source, dest;
+	char *data, *p, dns[256];
+	char sendbuf[1500];
+
+	fromlen = sizeof(src);
+	memset(&src, 0x00, sizeof(src));
+	memset(&rawhdr, 0x00, sizeof(struct udp_dns_packet));
+	memset(buf, 0x00, sizeof(buf));
+
+	bytes = recvfrom(listen->fd, buf, 1024, 0, (struct sockaddr *)&src, &fromlen);
+
+	if(bytes < 0)
+	{
+		my_syslog(LOG_INFO, "couldn't read on raw listening socket -- ignoring");
+		return;
+	}
+
+/*    for (i=0; i<112; i++) {
+        fprintf(stderr, "%02x ", buf[i]);
+        if (i % 16 == 15) fprintf(stderr, "\n");
+    }
+	*/
+	my_syslog(LOG_INFO, "recv message bytes %d", bytes);
+
+	memcpy(&rawhdr, buf, sizeof(struct udp_dns_packet));
+	packet = (struct udp_dns_packet *)buf;
+	memset(buf1, 0x00, sizeof(buf1));
+	pkt = (struct udp_dns_packet *)buf1;
+
+	if(bytes < (int) (sizeof(struct ethhdr) + sizeof(struct ipv6hdr) + sizeof(struct udphdr)))
+	{
+		my_syslog(LOG_INFO, "message too short, ignoring");
+		return;
+	}
+	
+	if(rawhdr.ip6.nexthdr != IPPROTO_UDP || rawhdr.udp.dest != htons(DNS_PORT) || rawhdr.ip6.payload_len != rawhdr.udp.len )
+	{
+		 my_syslog(LOG_INFO, "unrelated/bogus packet nexthdr %x proto %x port %x payload %x", ntohs(rawhdr.ip6.nexthdr), ntohs(rawhdr.eth.h_proto), ntohs(rawhdr.udp.dest), ntohs(rawhdr.ip6.payload_len));
+		 return;
+	}
+
+	if(!memcmp(&(rawhdr.ip6.saddr), none_addr, 2))
+	{
+		my_syslog(LOG_INFO, "ignore src :");
+		return;
+	}
+
+	/*psuedo-header*/
+	source = rawhdr.ip6.saddr;
+	dest = rawhdr.ip6.daddr;
+	check = rawhdr.udp.check;
+	rawhdr.udp.check = 0;
+	memset(&rawhdr.ip6, 0, sizeof(rawhdr.ip6));
+	packet->udp.check = 0;
+	memset(&(packet->ip6), 0, sizeof(rawhdr.ip6));
+	
+	rawhdr.ip6.hop_limit = IPPROTO_UDP;  /*psuedo-header the protocol must add on hop limit to create correct checksum*/
+	rawhdr.ip6.saddr = source;
+	rawhdr.ip6.daddr = dest;
+	rawhdr.ip6.payload_len = rawhdr.udp.len;
+
+	packet->ip6.hop_limit = IPPROTO_UDP;
+	packet->ip6.saddr = source;
+	packet->ip6.daddr = dest;
+	packet->ip6.payload_len = rawhdr.udp.len;
+
+	if (check && check != checksum(&packet->ip6, bytes)) {
+		my_syslog(LOG_INFO, "packet with bad UDP checksum received, %02x ignorin ", ntohs(check));
+		return -2;
+	}
+
+	memcpy(sendbuf, rawhdr.data, (sizeof(rawhdr.data)));
+	data = rawhdr.data;
+	p = &dns[0];
+	/* add the response */
+	int tolen = 0, msglen;
+	struct sockaddr_in6 dst;
+	unsigned char dns_ver;
+	struct in6_addr source_addr, global_addr;
+	struct in_addr local_addr4;
+	char *ansp = (unsigned char *)(sendbuf + ntohs(rawhdr.udp.len) -8);
+
+	if (*(ansp-3) == 0x1c ) 
+		dns_ver = 6;
+	else
+		dns_ver = 4;
+	PUTSHORT(0x0c | 0xc000, ansp);
+	
+	if (dns_ver == 6 )      //ipv6 dns
+	{
+		PUTSHORT(T_AAAA, ansp);
+	} else {
+		PUTSHORT(T_A, ansp);
+		if(!get_lan_ipaddr(&local_addr4))
+		{
+			return -1;
+		}
+	}
+
+	if(get_lan_linklocal_ipaddr6(&source_addr, 0) < 0) 
+		return -1;
+
+	PUTSHORT(C_IN, ansp);
+	PUTLONG(0, ansp);
+	if(dns_ver == 6)
+		PUTSHORT(16, ansp);
+	else
+		PUTSHORT(INADDRSZ, ansp);
+	if(dns_ver == 6)
+	{
+		if(get_lan_linklocal_ipaddr6(&global_addr, 1) < 0)
+			if(get_lan_linklocal_ipaddr6(&global_addr, 0) < 0)
+				return -1;
+
+		memcpy(ansp, &global_addr, 16);
+		ansp +=16;
+	}
+	else
+	{
+		memcpy(ansp, &local_addr4, 4);
+		ansp +=4;
+	}
+	reply_header = (HEADER *)(sendbuf);
+	reply_header->qr = 1;
+	reply_header->aa = 1;
+	reply_header->ra = 1;
+	reply_header->tc = 0;
+	reply_header->rcode = NOERROR;
+	reply_header->ancount = htons(1);
+	reply_header->nscount = htons(0);
+	reply_header->arcount = htons(0);
+
+	msglen = ansp - sendbuf;
+
+	tolen =sizeof(struct ethhdr) + sizeof(struct ipv6hdr) + sizeof(struct udphdr) + msglen;
+
+	/* pack packet */
+	pkt->ip6.hop_limit = IPPROTO_UDP;
+	pkt->ip6.saddr = dest;
+	pkt->ip6.daddr = source;
+	pkt->udp.check = 0;
+
+	pkt->udp.dest  = packet->udp.source;
+	pkt->udp.source = packet->udp.dest;
+	pkt->udp.len = htons (sizeof(struct udphdr) + msglen);
+	pkt->ip6.payload_len =  pkt->udp.len;
+	memcpy(pkt->data, sendbuf, msglen);
+
+	pkt->udp.check = checksum((unsigned short *)&pkt->ip6, tolen);
+	my_syslog(LOG_INFO, " pkt %02x", pkt->udp.check);
+	
+	pkt->ip6.priority = 0;
+	pkt->ip6.version = 6;
+	pkt->ip6.flow_lbl[0] = 0;
+	pkt->ip6.flow_lbl[1] = 0;
+	pkt->ip6.flow_lbl[2] = 0;
+	pkt->ip6.nexthdr = IPPROTO_UDP;
+	pkt->ip6.hop_limit = IPDEFTTL;
+
+	memcpy(pkt->eth.h_dest, rawhdr.eth.h_source, ETH_ALEN);
+	memcpy(pkt->eth.h_source, rawhdr.eth.h_dest, ETH_ALEN);
+	pkt->eth.h_proto = htons(ETH_P_IPV6);
+
+	memset(&dst, 0x00, sizeof(dst));
+	dst.sin6_family = htons(AF_INET6);
+	dst.sin6_addr = rawhdr.ip6.saddr;
+	my_syslog(LOG_INFO, "send dns packet, sockfd = %d", listen->fd);
+	if (0 >= send(listen->fd, pkt, tolen, 0)) {
+		my_syslog(LOG_INFO,"sendto failure! %s\n", strerror(errno));
+	}
+
+}
+#pragma pack()
 void receive_query(struct listener *listen, struct daemon *daemon, time_t now)
 {
   HEADER *header = (HEADER *)daemon->packet;