双11狂欢大促

盲盒赢 定制羽绒服

开启惊喜盲盒，抽取你的专属好礼

— 惊喜奖品抢先看 —

超级年卡50元券

周边70元券

手机支架

一拖三数据线

雨伞

运动毛巾

电动牙刷

VIP月卡

机械键盘

定制羽绒服

超级年卡50元券

周边70元券

手机支架

一拖三数据线

雨伞

运动毛巾

电动牙刷

VIP月卡

机械键盘

定制羽绒服

关于DNS查询包的格式程序

2011-04-02 11:56:57 1.4k 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

leihelin5201314 墨衍会员 · AI 创作全网分发关注 + 加入社区

DNS查询报文分析 DNS (Domain Name System)，域名系统是互联网的一项服务。它作为将域名和IP地址相互映射的一个分布式系统，能够使人们更方便地访问互联网，DNS服务器使用UDP端口 53。在linux操作系统下，我们可以通过 host 命令，查询域名的IP地址，命令格式为：host -t A 域名，它的工作原理是怎样的呢，接下来，通过解析DNS查询报文，探索DNS工作原理。阅读详情

typedef struct//报文head

{

    	unsigned short id;

    	unsigned short flags;

    	unsigned short ques;

    	unsigned short answer;

    	unsigned short author;

    	unsigned short addition;

}DNSHEAD,*pDNSHEAD;



typedef struct//报文的查询部分

{

    	unsigned short type;

    	unsigned short class;

}SEARCH,*pSEARCH;



void genDNSPacket(char *addr,char *dnssendbuff)

{

    	pDNSHEAD pdnshead = (pDNSHEAD)malloc(sizeof(DNSHEAD));

    	pSEARCH psearch = (pSEARCH)malloc(sizeof(SEARCH));



	pdnshead->id = htons(0x0000);

    	pdnshead->flags = htons(0x000);

    	pdnshead->ques = htons(0x0001);

    	pdnshead->answer = htons(0x0000);

    	pdnshead->author = htons(0x0000);

    	pdnshead->addition = htons(0x0000);



    	memcpy(dnssendbuff,pdnshead,sizeof(DNSHEAD));//将head加到dnssendbuff里面，结果dnssendbuff里面没有这部分

	printf("sizeof(DNSHEAD)=%d\n",sizeof(DNSHEAD));

	printf("dnssendbuff=%s\n",dnssendbuff);



    	char *domain = (char *)malloc(16*sizeof(char)); //3www6hao1233com0

    	char num;

    	char *pbuf;

   

    	int length = 0;

    	num = 0x03;

    	pbuf = "www";

    	memcpy(domain + length,&num,sizeof(num));

    	length += sizeof(num);

    	memcpy(domain+ length,pbuf,strlen(pbuf));

    	length += strlen(pbuf);



    	num = 0x06;

    	pbuf = "hao123";

    	memcpy(domain + length,&num,sizeof(num));

    	length += sizeof(num);

    	memcpy(domain + length,pbuf,strlen(pbuf));

    	length += strlen(pbuf);



	num = 0x03;

    	pbuf = "com";

    	memcpy(domain + length,&num,sizeof(num));

    	length += sizeof(num);

    	memcpy(domain + length,pbuf,strlen(pbuf));

    	length += strlen(pbuf);

	printf("domain=%s\n",domain);



    	num = 0x00;

    	memcpy(domain + length,&num,sizeof(num));

	length += sizeof(num);

    	memcpy(dnssendbuff + sizeof(DNSHEAD),domain,16);/将domain  www.hao123.com加到报文，domain在报文里有

	printf("strlen(domain)=%d\n",strlen(domain));

	memcpy( dnssendbuff, domain, 16);

 

    	psearch->type = htons(0x0001);

    	psearch->class = htons(0x0001);



    	memcpy(dnssendbuff + sizeof(DNSHEAD) + 16,psearch,sizeof(SEARCH)); //将search加到dnssendbuff里面，结果dnssendbuff也里面没有这部分

	printf("strlen(dnssendbuff)=%d\n",strlen(dnssendbuff));

	printf("dnssendbuff=%s\n",dnssendbuff);

}

代码原型是我在网上找的，改了之后做个示例
我ping hao123.com,然后wireshark抓包得到的结构看了下，发现我在程序里边的head部分和最后面的查询类和查询类型部分没加到报文里边，报文打出来之后只出现了个 3www6hao1233com ,没发现head和search部分，估计是我的这两部分的程序不正确，希望牛人帮我看下，谢谢！
关于报文的格式我看过了
head+domain+search三部分
head有6部分共12字节，这个结构我清楚，但是程序没把head和search加到报文里，结果发到 220.181.111.78 后收不到东西

...全文

SCCM实战指南：从零搭建企业级Windows自动化部署平台本文提供了一份详细的SCCM实战指南，手把手教你从零搭建企业级Windows自动化部署平台。内容涵盖环境规划、AD架构扩展、SQL Server配置、SCCM主站点安装，以及最终实现操作系统镜像的自动化部署，旨在帮助IT管理员彻底告别手动装机，实现高效、规范的Windows设备批量管理。阅读详情

leihelin5201314

C语言 70,039 成员 243,237 内容

+ 关注 + 加入社区

切换为时间正序

leihelin5201314 2011-04-02

打赏
举报

[Quote=引用 18 楼 hpf976149 的回复:]

代码在VC6 WINXP上测试可以使用，楼主试试
[/Quote]多谢，我得看看能不能看明白，目前新手只会看linux下的C，其他的我得琢磨琢磨

CppCoder 2011-04-02

打赏
举报

代码在VC6 WINXP上测试可以使用，楼主试试

CppCoder 2011-04-02

打赏
举报





CString CDNSQuery::DNSQuery(unsigned char *host, char *dnsserver)

{

	unsigned char buf[65536],*qname,*reader;

	int i , j , stop;

	

	SOCKET s;

	struct sockaddr_in a;



	struct RES_RECORD answers[20],auth[20],addit[20];  //DNS服务器的回应

	struct sockaddr_in dest;

	

	struct DNS_HEADER *dns = NULL;

	struct QUESTION   *qinfo = NULL;



	CString sResult = "", sTemp;



	s = socket(AF_INET,SOCK_DGRAM,IPPROTO_UDP);  //采用UDP进行DNS查询



	dest.sin_family=AF_INET;

	dest.sin_port=htons(53);                    //DNS端口

	dest.sin_addr.s_addr=inet_addr(dnsserver);  //DNS服务器



	//设置DNS标准查询结构

	dns = (struct DNS_HEADER *)&buf;

	

	dns->id = (unsigned short) (htons((unsigned short) GetCurrentProcessId()));

	dns->qr = 0;      //这是一个查询

	dns->opcode = 0;  //这是一个标准查询

	dns->aa = 0;      //不用认证

	dns->tc = 0;      //这是一个完整封包

	dns->rd = 1;      //希望递归查询

	dns->ra = 0;      

	dns->z  = 0;

	dns->ad = 0;

	dns->cd = 0;

	dns->rcode = 0;

	dns->q_count = htons(1);   //只有一个问题

	dns->ans_count  = 0;

	dns->auth_count = 0;

	dns->add_count  = 0;

	

	//指针指向查询部分

	qname =(unsigned char*)&buf[sizeof(struct DNS_HEADER)];

    //转换域名格式

	ChangetoDnsNameFormat(qname,host);

	qinfo =(struct QUESTION*)&buf[sizeof(struct DNS_HEADER) + (strlen((const char*)qname) + 1)]; //fill it



	qinfo->qtype = htons(1);  //只查询ipv4地址

	qinfo->qclass = htons(1); //这是internet网络



	TRACE("\nSending Packet...");

	if(sendto(s,(char*)buf,sizeof(struct DNS_HEADER) + (strlen((const char*)qname)+1) + sizeof(struct QUESTION),0,(struct sockaddr*)&dest,sizeof(dest))==SOCKET_ERROR)

	{

		TRACE("%d  error",WSAGetLastError());

	}

	TRACE("Sent");

	

	i = sizeof(dest);

	TRACE("\nReceiving answer...");

	if(recvfrom (s,(char*)buf,65536,0,(struct sockaddr*)&dest,&i)==SOCKET_ERROR)

	{

		TRACE("Failed. Error Code : %d",WSAGetLastError());

	}

	TRACE("Received.");

	

	dns=(struct DNS_HEADER*)buf;

	

	//指针越过DNS包头和查询问题部分

	reader=&buf[sizeof(struct DNS_HEADER) + (strlen((const char*)qname)+1) + sizeof(struct QUESTION)];



    sTemp.Format("The response contains : ");

	sResult += sTemp;

	sTemp.Format("\r\n %d Questions.",ntohs(dns->q_count));

	sResult += sTemp;

	sTemp.Format("\r\n %d Answers.",ntohs(dns->ans_count));

	sResult += sTemp;

	sTemp.Format("\r\n %d Authoritative Servers.",ntohs(dns->auth_count));

	sResult += sTemp;

	sTemp.Format("\r\n %d Additional records.\r\n",ntohs(dns->add_count));

	sResult += sTemp;



	//读问题回答

	stop=0;

	

	for(i=0;i<ntohs(dns->ans_count);i++)

	{

		answers[i].name=ReadName(reader,buf,&stop);

		reader = reader + stop;

		

		answers[i].resource = (struct R_DATA*)(reader);

		reader = reader + sizeof(struct R_DATA);

	

		if(ntohs(answers[i].resource->type) == 1) //if its an ipv4 address

		{

			answers[i].rdata = (unsigned char*)malloc(ntohs(answers[i].resource->data_len));

			

			for(j=0 ; j<ntohs(answers[i].resource->data_len) ; j++)

				answers[i].rdata[j]=reader[j];

			

			answers[i].rdata[ntohs(answers[i].resource->data_len)] = '\0';

			

			reader = reader + ntohs(answers[i].resource->data_len);

		

		}

		else

		{

			answers[i].rdata = ReadName(reader,buf,&stop);

		    reader = reader + stop;

		}

	}

	

	//读认证回应

	for(i=0;i<ntohs(dns->auth_count);i++)

	{

		auth[i].name=ReadName(reader,buf,&stop);

		reader+=stop;

		

		auth[i].resource=(struct R_DATA*)(reader);

		reader+=sizeof(struct R_DATA);

	

		auth[i].rdata=ReadName(reader,buf,&stop);

		reader+=stop;

	}



	//读附加资源数据

	for(i=0;i<ntohs(dns->add_count);i++)

	{

		addit[i].name=ReadName(reader,buf,&stop);

		reader+=stop;

		

		addit[i].resource=(struct R_DATA*)(reader);

		reader+=sizeof(struct R_DATA);

	

		if(ntohs(addit[i].resource->type)==1)

		{

			addit[i].rdata = (unsigned char*)malloc(ntohs(addit[i].resource->data_len));

			for(j=0;j<ntohs(addit[i].resource->data_len);j++)

				addit[i].rdata[j]=reader[j];



			addit[i].rdata[ntohs(addit[i].resource->data_len)]='\0';

			reader+=ntohs(addit[i].resource->data_len);

		

		}

		else

		{

			addit[i].rdata=ReadName(reader,buf,&stop);

		    reader+=stop;

		}

	}



	

	//输出回答，即查询结果

	for(i=0;i<ntohs(dns->ans_count);i++)

	{

		sTemp.Format("Name : %s ",answers[i].name);

		sResult += sTemp;

			

		if(ntohs(answers[i].resource->type)==1)   //IPv4地址

		{

			

			long *p;

			p=(long*)answers[i].rdata;

			a.sin_addr.s_addr=(*p);    

			sTemp.Format("has \r\nIPv4 address :  %s",inet_ntoa(a.sin_addr));

			sResult += sTemp;

		}

		if(ntohs(answers[i].resource->type)==5)   //别名

		{

			sTemp.Format("has alias name : %s",answers[i].rdata);

			sResult += sTemp;

		}

				

		sTemp.Format("\r\n");

		sResult += sTemp;

	}



	//输出认证信息

	for(i=0;i<ntohs(dns->auth_count);i++)

	{

		sTemp.Format("Name : %s ",auth[i].name);

		sResult += sTemp;

		if(ntohs(auth[i].resource->type)==2)

		{

			sTemp.Format("has authoritative nameserver : %s",auth[i].rdata);

			sResult += sTemp;

		}

		sTemp.Format("\r\n");

		sResult += sTemp;

	}



	//输出附加资源数据

	for(i=0;i<ntohs(dns->add_count);i++)

	{

		sTemp.Format("Name : %s ",addit[i].name);

		sResult += sTemp;

		if(ntohs(addit[i].resource->type)==1)

		{

			long *p;

			p=(long*)addit[i].rdata;

			a.sin_addr.s_addr=(*p);    

			sTemp.Format("has \r\nIPv4 address :  %s",inet_ntoa(a.sin_addr));

			sResult += sTemp;

		}

		sTemp.Format("\r\n");

		sResult += sTemp;

	}



    return sResult;

}





//查询

void OnQuery() 

{

	CDNSQuery m_query;

	char szDNS_Server[100];

	sprintf(szDNS_Server, "%d.%d.%d.%d", 192, 168, 1, 1);//你的DNS服务器IP

	unsigned char szName[100];

	strcpy((char*)szName, "www.baidu.com");//查询的域名

	CString strResult = m_query.DNSQuery(&szName[0], szServer);

}

CppCoder 2011-04-02

打赏
举报



//DNSQuery.h

//查询和回应的数据位置定义

#define T_A		    1		// 主机地址

#define T_NS		2		// 认证服务器

#define T_CNAME		5		// 别名

#define T_SOA		6		// 认证区域起始

#define T_PTR		12		// 域名指针

#define T_MX		15		// 邮件路由信息



//DNS 头结构

struct DNS_HEADER

{

	unsigned	short id;		    // 标识

	

	unsigned	char rd     :1;		// 递归查询模式

	unsigned	char tc     :1;		// 完整封包信息

	unsigned	char aa     :1;		// 认证回应

	unsigned	char opcode :4;	    // 操作码

	unsigned	char qr     :1;		// 查询/回应标志

	

	unsigned	char rcode  :4;	    // 回应码

	unsigned	char cd     :1;	    // 检查无效

	unsigned	char ad     :1;	    // 认证数据

	unsigned	char z      :1;		// 预留

	unsigned	char ra     :1;		// 能否进行递归查询

	

	unsigned    short q_count;	    // 问题数目

	unsigned	short ans_count;	// 回答数目

	unsigned	short auth_count;	// 权威回答数目

	unsigned	short add_count;	// 附加数目

};



//查询问题结构

struct QUESTION

{

	unsigned short qtype;   // 查询的资源类型

	unsigned short qclass;  // 查询网络类型

};





//查询回应结构

#pragma pack(push, 1)

struct  R_DATA

{

	unsigned short type;    // 查询回应类型

	unsigned short _class;  // 查询回应的网络类型

	unsigned int   ttl;     // 在DNS服务器的存活时间

	unsigned short data_len;// 数据的长度

};

#pragma pack(pop)



//资源记录内容指针

struct RES_RECORD

{

	unsigned char  *name;      // 资源名称

	struct R_DATA  *resource;  // 资源数据

	unsigned char  *rdata;     // 查询结果

};



//查询结构

typedef struct

{

	unsigned char *name;       // 资源名称

	QUESTION      *ques;       // 问题

} QUERY;





class CDNSQuery  

{

public:

	CDNSQuery();

	virtual ~CDNSQuery();



	CString DNSQuery(unsigned char *host, char *dnsserver);

	unsigned char* ReadName(unsigned char* reader,unsigned char* buffer,int* count);

	void RetrieveDnsServersFromRegistry();

	void ChangetoDnsNameFormat(unsigned char* dns,unsigned char* host);



	int GetDNSServer(char* dnsserver)

	{

		for(int i = 0; i < 10; i++)

		{

			if( m_DnsServers[i][0] == '\0' )

				break;

			strcpy(&dnsserver[i*100], m_DnsServers[i]);

		}



		return i;

	}

private:

	//List of DNS Servers registered on the system

	char m_DnsServers[10][100];



};





//DNSQuery.cpp

#include "DNSQuery.h"



#include "winsock2.h"

#pragma comment(lib,"ws2_32.lib")   //Winsock Library



CDNSQuery::CDNSQuery()

{



	WSADATA firstsock;

	

	RetrieveDnsServersFromRegistry();



	TRACE("\nInitialising Winsock...");

	if (WSAStartup(MAKEWORD(2,2),&firstsock) != 0)

	{

		TRACE("Failed. Error Code : %d",WSAGetLastError());

		return;

	} 

	TRACE("Initialised.");



}



CDNSQuery::~CDNSQuery()

{

	WSACleanup();

}





unsigned char* CDNSQuery::ReadName(unsigned char* reader,unsigned char* buffer,int* count)

{

	unsigned char *name;

	unsigned int p=0,jumped=0,offset;

	int i , j;



	*count = 1;

	name   = (unsigned char*)malloc(256);

	

	name[0]='\0';



	//read the names in 3www6google3com format

	while(*reader!=0)

	{

		if(*reader>=192)

		{

			offset = (*reader)*256 + *(reader+1) - 49152; //49152 = 11000000 00000000  ;)

			reader = buffer + offset - 1;

			jumped = 1;  //we have jumped to another location so counting wont go up!

		}

		else 

			name[p++]=*reader;

		

		reader=reader+1;

		

		if(jumped==0) *count = *count + 1; //if we havent jumped to another location then we can count up

	}

	

	name[p]='\0';    //string complete

	if(jumped==1) *count = *count + 1;  //number of steps we actually moved forward in the packet

	

	//now convert 3www6google3com0 to www.google.com

	for(i=0;i<(int)strlen((const char*)name);i++)

	{

		p=name[i];

		for(j=0;j<(int)p;j++)

		{

			name[i]=name[i+1];

			i=i+1;

		}

		name[i]='.';

	}

	name[i-1]='\0';	  //remove the last dot

	return name;		

}





// 从注册表读出DNS服务器

void CDNSQuery::RetrieveDnsServersFromRegistry()

{

	HKEY hkey=0;

	char name[256];

	char *path="SYSTEM\\CurrentControlSet\\Services\\Tcpip\\Parameters\\Interfaces";

	char *fullpath[256];

	unsigned long s=sizeof(name);

	int  dns_count=0 , err , i , j;

	HKEY inter;

	unsigned long count;





	//Open the registry folder

	RegOpenKeyEx(HKEY_LOCAL_MACHINE , path , 0 , KEY_READ , &hkey );

		

	

	

	//how many interfaces

	RegQueryInfoKey(hkey, 0 , 0 , 0 , &count , 0 , 0 , 0 , 0 , 0 , 0 , 0 );

	

	for(i=0;i<(int)count;i++)

	{

		s=256;

		//Get the interface subkey name

		RegEnumKeyEx(hkey , i , (char*)name , &s , 0 , 0 , 0 , 0 );

		

		//Make the full path

		strcpy((char*)fullpath,path);

		strcat((char*)fullpath,"\\");

		strcat((char*)fullpath,name);

				

		//Open the full path name

		RegOpenKeyEx(HKEY_LOCAL_MACHINE , (const char*)fullpath , 0 , KEY_READ , &inter );

				

		//Extract the value in Nameserver field

		s=256;

		err=RegQueryValueEx(inter , "NameServer" , 0 , 0 , (unsigned char*)name ,	&s );

		

		if(err==ERROR_SUCCESS && strlen(name)>0) strcpy(m_DnsServers[dns_count++],name);

	}



	for(i=0;i<dns_count;i++)

	{

		for(j=0;j<(int)strlen(m_DnsServers[i]);j++)

		{

			if(m_DnsServers[i][j]==',' || m_DnsServers[i][j]==' ')

			{

				strcpy(m_DnsServers[dns_count++],m_DnsServers[i]+j+1);

				m_DnsServers[i][j]=0;

			}

		}

	}



	TRACE("\nThe following DNS Servers were found on your system...");

	for(i=0;i<dns_count;i++)

	{

		TRACE("\n%d)  %s",i+1,m_DnsServers[i]);

	}

}





//转换格式： www.google.com -> www google com ;

void CDNSQuery::ChangetoDnsNameFormat(unsigned char* dns,unsigned char* host)

{

	int lock=0 , i;

	

	strcat((char*)host,".");

	

	for(i=0;i<(int)strlen((char*)host);i++)

	{

		if(host[i]=='.')

		{

			*dns++=i-lock;

			for(;lock<i;lock++)

			{

				*dns++=host[lock];

			}

			lock++; //or lock=i+1;

		}

	}

    *dns++='\0';

}

leihelin5201314 2011-04-02

打赏
举报

[Quote=引用 14 楼 dx_deepblue 的回复:]

同志，我也做协议这方面，不过现在没做dns这方面，以后得好好讨论~
[/Quote]别叫同志好不？我听着怪怪的，叫同学吧···

DX_deepblue 2011-04-02

打赏
举报

同志，我也做协议这方面，不过现在没做dns这方面，以后得好好讨论~

leihelin5201314 2011-04-02

打赏
举报

[Quote=引用 12 楼 leihelin5201314 的回复:]

引用 11 楼 luciferisnotsatan 的回复:

destionation unreachable这个应该是目的地到不了。你的机器是否能连通那边的服务器？
我的本机ping可以ping通，但是我不明白就算我的应答解析做的不对，那么收包应该可以收到吧，
C/C++ code
int res;
res = sendto(server_socke……
[/Quote]错了，

res = sendto(server_socket,sendbuff,31,0,(struct sockaddr*)&addr,addrlen);结果还是12楼的那样

    perror("sendto");

leihelin5201314 2011-04-02

打赏
举报

[Quote=引用 11 楼 luciferisnotsatan 的回复:]

destionation unreachable这个应该是目的地到不了。你的机器是否能连通那边的服务器？
[/Quote]我的本机ping可以ping通，但是我不明白就算我的应答解析做的不对，那么收包应该可以收到吧，

    	int res;

    	res = sendto(server_socket,sendbuff,27,0,(struct sockaddr*)&addr,addrlen);//31

	perror("sendto");

    	printf("send to %d \n",res);

	int rev;

    	rev = recvfrom(server_socket,recvbuff,sizeof(recvbuff),0,(struct sockaddr*)&addr,&addrlen);

	perror("recv\n");

    	printf("recv %d ",rev);

程序跑到recvfrom 处停了，没打印perror("recv\n");的结果，结果如下：
sendto: Success
send to 31
recv

后面就没了，不知道收没收到包

luciferisnotsatan 2011-04-02

打赏
举报

destionation unreachable这个应该是目的地到不了。你的机器是否能连通那边的服务器？

leihelin5201314 2011-04-02

打赏
举报

[Quote=引用 9 楼 chenjiawei007 的回复:]

报文就是一个BUFFER而已，发出去的内容其实就是一个CHAR BUFFER[LEN],控制好字符串.
写或者解析协议一般有两种方式，一种就是定长，还有种就是不定长，定长的在你收到BUFFER后根据指定位置段数据读取；不定长的可根据自定义的字符来分隔数据段比如用'|'。你的memcpy用的有些乱啊，一有地方重复拷贝了，你的就全部乱了。直接用sturct传输数据我觉得这点确实很不好。
[/Quote]多谢指教。确实感觉直接用字符串比较好，重复的地方已经改过了，发送抓包看了下，因为收应答包的时候没收到，wireshark提示目的地没有应答，收包解析做的还不好，这样无法确定查询包是不是正确的

chenjiawei007 2011-04-02

打赏
举报

报文就是一个BUFFER而已，发出去的内容其实就是一个CHAR BUFFER[LEN],控制好字符串.
写或者解析协议一般有两种方式，一种就是定长，还有种就是不定长，定长的在你收到BUFFER后根据指定位置段数据读取；不定长的可根据自定义的字符来分隔数据段比如用'|'。你的memcpy用的有些乱啊，一有地方重复拷贝了，你的就全部乱了。直接用sturct传输数据我觉得这点确实很不好。

leihelin5201314 2011-04-02

打赏
举报

[Quote=引用 6 楼 luciferisnotsatan 的回复:]

memcpy(dnssendbuff + sizeof(DNSHEAD),domain,16);/将domain www.hao123.com加到报文，domain在报文里有
printf("strlen(domain)=%d\n",strlen(domain));
memcpy( dnssendbuff, domain, 16); 又把domain直接复……
[/Quote]改过了，现在只是收不到应答包，这样也不清楚发的包对不对，
应答包抓包看结果，提示 destionation unreachable ，应答解析没做好

luciferisnotsatan 2011-04-02

打赏
举报

另外，strlen函数也是以 '\0'为结束点的。也就是说，第一个字符就是0，那么长度就是0

luciferisnotsatan 2011-04-02

打赏
举报

memcpy(dnssendbuff + sizeof(DNSHEAD),domain,16);/将domain www.hao123.com加到报文，domain在报文里有
printf("strlen(domain)=%d\n",strlen(domain));
memcpy( dnssendbuff, domain, 16); 又把domain直接复制到dnssendbuff处？？

leihelin5201314 2011-04-02

打赏
举报

就算打印不出来0x0之后的内容，可是包的长度应该是不会变的，我的包长度也不对，代码估计有误···

leihelin5201314 2011-04-02

打赏
举报

[Quote=引用 2 楼 luciferisnotsatan 的回复:]

C/C++ code
pdnshead->id = htons(0x0000);
...
memcpy(dnssendbuff,pdnshead,sizeof(DNSHEAD));//将head加到dnssendbuff里面，结果dnssendbuff里面没有这部分
printf("sizeof(DNSHEAD)=%d\n",sizeof(DNSHEAD));
printf("dns……
[/Quote]你好，但是我截了包看了下，我发的包的结构跟ping 域名之后的包的结构不一样，我的包结构就有一个域名，没head也没有后面search的0101，发包后也没返回，看样子包的结构不对或者代码不对；

luciferisnotsatan 2011-04-02

打赏
举报

调试，或者自己写个代码，把内存里的值转换成能显示的数字字符。

luciferisnotsatan 2011-04-02

打赏
举报

pdnshead->id = htons(0x0000);

...     

memcpy(dnssendbuff,pdnshead,sizeof(DNSHEAD));//将head加到dnssendbuff里面，结果dnssendbuff里面没有这部分

printf("sizeof(DNSHEAD)=%d\n",sizeof(DNSHEAD));

printf("dnssendbuff=%s\n",dnssendbuff);

这个printf里没有输出dnssendbuff内容很正常，你的ID是0x0，即字符串结束符。后面的都一样，dnssendbuff的第一个字节为 0。直接认为字符串结束了

leihelin5201314 2011-04-02

打赏
举报

来人～～～～～这个程序有错误·····

✦双11狂欢大促✦

关于DNS查询包的格式程序

相关推荐

双11狂欢大促