dns_test支持各字段转化为json

2 files changed, 146 insertions, 5 deletions

diff --git a/test/src/Makefile b/test/src/Makefile
index 6f46816..9b99324 100644
--- a/test/src/Makefile
+++ b/test/src/Makefile
@@ -1,5 +1,5 @@
 all:
-	gcc -Wall -g -fPIC -shared -I./include/ ./dns_test.c -o dns_test.so 
+	gcc -Wall -g -fPIC -shared -I./include/ ./dns_test.c -o dns_test.so -lcjson
 	cp ./dns_test.so ../bin/
 clean:
 	rm -rf *.o *.so
diff --git a/test/src/dns_test.c b/test/src/dns_test.c
index 5c1bc36..ff054c3 100644
--- a/test/src/dns_test.c
+++ b/test/src/dns_test.c
@@ -7,9 +7,12 @@
 
 #include <MESA/stream.h>
 #include <MESA/dns.h>
+#include <MESA/cJSON.h>
 
 #define	LOG_PATH	"./log/dns/"
-//#define	DEBUG	1
+#define	DEBUG	1
+
+char *DNS_TEST_VERSION_20190717=NULL;
 
 int rr_print(dns_info_t *dns_info, struct streaminfo *a_udp, int thread_seq, void *a_packet, int *dns_sec)
 {
@@ -28,7 +31,11 @@ int rr_print(dns_info_t *dns_info, struct streaminfo *a_udp, int thread_seq, voi
 	char *buf = NULL;
 	int buflen = sizeof(rr_buf);
 	buf = rr_buf;
-	
+	cJSON *dns_info_object=cJSON_CreateObject();
+	cJSON *dns_hdr_object=cJSON_CreateObject();
+	cJSON *dns_flags_object=cJSON_CreateObject();
+	cJSON *dns_question_array=cJSON_CreateArray();
+	cJSON *dns_rr_array=cJSON_CreateArray();
 
 	memset(filename, 0 , sizeof(filename));
 	memset(dns_header, 0 , sizeof(dns_header));
@@ -55,24 +62,55 @@ int rr_print(dns_info_t *dns_info, struct streaminfo *a_udp, int thread_seq, voi
 						dns_info->hdr_info.ancount,
 						dns_info->hdr_info.aucount,
 						dns_info->hdr_info.adcount);
+	
+	cJSON_AddNumberToObject(dns_hdr_object, "id", dns_info->hdr_info.id);
+	cJSON_AddNumberToObject(dns_hdr_object, "qdcount", dns_info->hdr_info.qdcount);
+	cJSON_AddNumberToObject(dns_hdr_object, "ancount", dns_info->hdr_info.ancount);
+	cJSON_AddNumberToObject(dns_hdr_object, "aucount", dns_info->hdr_info.aucount);
+	cJSON_AddNumberToObject(dns_hdr_object, "adcount", dns_info->hdr_info.adcount);
+
+	cJSON_AddNumberToObject(dns_flags_object, "qr", dns_info->hdr_info.qr);
+	cJSON_AddNumberToObject(dns_flags_object, "opcode", dns_info->hdr_info.opcode);
+	cJSON_AddNumberToObject(dns_flags_object, "aa", dns_info->hdr_info.aa);
+	cJSON_AddNumberToObject(dns_flags_object, "tc", dns_info->hdr_info.tc);
+	cJSON_AddNumberToObject(dns_flags_object, "rd", dns_info->hdr_info.rd);
+	cJSON_AddNumberToObject(dns_flags_object, "ra", dns_info->hdr_info.ra);
+	cJSON_AddNumberToObject(dns_flags_object, "z", dns_info->hdr_info.z);
+	cJSON_AddNumberToObject(dns_flags_object, "rcode", dns_info->hdr_info.rcode);
 
 	fwrite(dns_header, used_len, 1, fp);
-	
+
+	cJSON_AddItemToObject(dns_info_object, "hdr", dns_hdr_object);
+	cJSON_AddItemToObject(dns_info_object, "flags", dns_flags_object);
+	cJSON_AddItemToObject(dns_info_object,"question", dns_question_array);
 	for(i = 0; i < dns_info->hdr_info.qdcount && (&dns_info->query_question[i])!=NULL; i++)
 	{
 		used_len = snprintf(question, sizeof(question), "question: <qtype: %d, qclass: %d, qname: %s>\n",
 											 dns_info->query_question[i].qtype,
 											 dns_info->query_question[i].qclass,
 											 dns_info->query_question[i].qname);
+			
+		cJSON *dns_question_object=cJSON_CreateObject();
+		cJSON_AddItemToArray(dns_question_array, dns_question_object);
+
+		cJSON_AddNumberToObject(dns_question_object, "qtype", dns_info->query_question[i].qtype);
+		cJSON_AddNumberToObject(dns_question_object, "qclass", dns_info->query_question[i].qclass);
+		cJSON_AddStringToObject(dns_question_object, "qname", (const char *)dns_info->query_question[i].qname);
 	}
 
 	fwrite(question, used_len, 1, fp);
 
 	used_len = snprintf(rr_buf, sizeof(rr_buf), "RRS count: %d\n", dns_info->rr_count);
 	fwrite(rr_buf, used_len, 1, fp);
+
+	
+	cJSON_AddItemToObject(dns_info_object, "rr", dns_rr_array);
 	
 	for(i = 0; i < dns_info->rr_count; i++)
 	{
+		cJSON *dns_rr_object=cJSON_CreateObject();
+		cJSON_AddItemToArray(dns_rr_array, dns_rr_object);
+
 		used_len = 0;
 		dns_rr = &(dns_info->rr[i]);
 		memset(rr_buf, 0 , sizeof(rr_buf));
@@ -84,10 +122,18 @@ int rr_print(dns_info_t *dns_info, struct streaminfo *a_udp, int thread_seq, voi
 											dns_rr->name,
 											dns_rr->type,
 											dns_rr->rr_class,
-											dns_rr->ttl >> 24,
+											dns_rr->ttl>>24,
 											(dns_rr->ttl>>16)&0xFF,
 											dns_rr->ttl&&0xFFFF,
 											dns_rr->rdlength);
+			
+			cJSON_AddStringToObject(dns_rr_object, "name", (const char *)(dns_rr->name));
+			cJSON_AddNumberToObject(dns_rr_object, "type", dns_rr->type);
+			cJSON_AddNumberToObject(dns_rr_object, "udp_payload", dns_rr->rr_class);
+			cJSON_AddNumberToObject(dns_rr_object, "rcode", (int)(dns_rr->ttl>>24));
+			cJSON_AddNumberToObject(dns_rr_object, "version", (int)((dns_rr->ttl>>16)&0xFF));
+			cJSON_AddNumberToObject(dns_rr_object, "Z", (int)(dns_rr->ttl&&0xFFFF));
+			cJSON_AddNumberToObject(dns_rr_object, "rdlength", dns_rr->rdlength);
 		}
 		else
 		{
@@ -99,6 +145,11 @@ int rr_print(dns_info_t *dns_info, struct streaminfo *a_udp, int thread_seq, voi
 											dns_rr->ttl,
 											dns_rr->rdlength);
 
+			cJSON_AddStringToObject(dns_rr_object, "name", (const char *)(dns_rr->name));
+			cJSON_AddNumberToObject(dns_rr_object, "type", dns_rr->type);
+			cJSON_AddNumberToObject(dns_rr_object, "class", dns_rr->rr_class);
+			cJSON_AddNumberToObject(dns_rr_object, "ttl", dns_rr->ttl);
+			cJSON_AddNumberToObject(dns_rr_object, "rdlength", dns_rr->rdlength);
 		}
 	
 		switch(dns_rr->type)
@@ -106,18 +157,23 @@ int rr_print(dns_info_t *dns_info, struct streaminfo *a_udp, int thread_seq, voi
 			case DNS_TYPE_A:
 				inet_ntop(AF_INET, (void *)(dns_rr->rdata.a), ip_str, sizeof(ip_str));
 				used_len += snprintf(buf+used_len, buflen-used_len, "[A: %s]\n", ip_str);
+				cJSON_AddStringToObject(dns_rr_object, "a", ip_str);
 				break;
 			case DNS_TYPE_NS:
 				used_len += snprintf(buf+used_len, buflen-used_len, "[NS: %s]\n", dns_rr->rdata.ns);
+				cJSON_AddStringToObject(dns_rr_object, "ns", (const char *)(dns_rr->rdata.ns));
 				break;
 			case DNS_TYPE_MD:
 				used_len += snprintf(buf+used_len, buflen-used_len, "[MD: %s]\n", dns_rr->rdata.md);
+				cJSON_AddStringToObject(dns_rr_object, "md", (const char *)(dns_rr->rdata.md));
 				break;
 			case DNS_TYPE_MF:
 				used_len += snprintf(buf+used_len, buflen-used_len, "[MF: %s]\n", dns_rr->rdata.mf);
+				cJSON_AddStringToObject(dns_rr_object, "mf", (const char *)(dns_rr->rdata.mf));
 				break;
 			case DNS_TYPE_CNAME:
 				used_len += snprintf(buf+used_len, buflen-used_len, "[CNAME: %s]\n", dns_rr->rdata.cname);
+				cJSON_AddStringToObject(dns_rr_object, "cname", (const char *)(dns_rr->rdata.cname));
 				break;
 			case DNS_TYPE_SOA:
 				used_len += snprintf(buf+used_len, buflen-used_len, 
@@ -129,51 +185,85 @@ int rr_print(dns_info_t *dns_info, struct streaminfo *a_udp, int thread_seq, voi
 							dns_rr->rdata.soa->retry,
 							dns_rr->rdata.soa->expire,
 							dns_rr->rdata.soa->minimum);
+				cJSON_AddStringToObject(dns_rr_object, "mname", (const char *)(dns_rr->rdata.soa->mname));
+				cJSON_AddStringToObject(dns_rr_object, "rname", (const char *)(dns_rr->rdata.soa->rname));
+				cJSON_AddNumberToObject(dns_rr_object, "serial", dns_rr->rdata.soa->serial);
+				cJSON_AddNumberToObject(dns_rr_object, "refresh", dns_rr->rdata.soa->refresh);
+				cJSON_AddNumberToObject(dns_rr_object, "retry", dns_rr->rdata.soa->retry);
+				cJSON_AddNumberToObject(dns_rr_object, "cname", dns_rr->rdata.soa->expire);
+				cJSON_AddNumberToObject(dns_rr_object, "minimum", dns_rr->rdata.soa->minimum);
 				break;
 			case DNS_TYPE_MB:
 				used_len += snprintf(buf+used_len, buflen-used_len, "[MB: %s]\n", dns_rr->rdata.mb);
+				cJSON_AddStringToObject(dns_rr_object, "mb", (const char *)(dns_rr->rdata.mb));
 				break;
 			case DNS_TYPE_MG:
 				used_len += snprintf(buf+used_len, buflen-used_len, "[MG: %s]\n", dns_rr->rdata.mg);
+				cJSON_AddStringToObject(dns_rr_object, "mg", (const char *)(dns_rr->rdata.mg));
 				break;
 			case DNS_TYPE_MR:
 				used_len += snprintf(buf+used_len, buflen-used_len, "[MR: %s]\n", dns_rr->rdata.mr);
+				cJSON_AddStringToObject(dns_rr_object, "mr", (const char *)(dns_rr->rdata.mr));
 				break;
 			case DNS_TYPE_NULL:
 				used_len += snprintf(buf+used_len, buflen-used_len, "[null size: %u, null: %s]\n",
 													dns_rr->rdata.null->size, dns_rr->rdata.null->null);
+				cJSON_AddNumberToObject(dns_rr_object, "size", dns_rr->rdata.null->size);
+				cJSON_AddStringToObject(dns_rr_object, "null", (const char *)(dns_rr->rdata.null->null));
 				break;
 			case DNS_TYPE_WKS:
 				inet_ntop(AF_INET, &(dns_rr->rdata.wks->addr), ip_str, sizeof(ip_str));
 				used_len += snprintf(buf+used_len, buflen-used_len, "[WKS addr: %s, protocol: %u, bitmap: %s, size: %u]\n",
 									ip_str, dns_rr->rdata.wks->protocol, dns_rr->rdata.wks->bitmap, dns_rr->rdata.wks->size);
+				
+				cJSON_AddStringToObject(dns_rr_object, "addr", ip_str);
+				cJSON_AddNumberToObject(dns_rr_object, "protocol", dns_rr->rdata.wks->protocol);
+				cJSON_AddStringToObject(dns_rr_object, "bitmap", (const char *)(dns_rr->rdata.wks->bitmap));
+				cJSON_AddNumberToObject(dns_rr_object, "size", dns_rr->rdata.wks->size);
 				break;
 			case DNS_TYPE_PTR:
 				used_len += snprintf(buf+used_len, buflen-used_len, "[PTR: %s]\n", dns_rr->rdata.ptr);
+				cJSON_AddStringToObject(dns_rr_object, "ptr", (const char *)(dns_rr->rdata.ptr));
 				break;
 			case DNS_TYPE_HINFO:
 				used_len += snprintf(buf+used_len, buflen-used_len, "[HINFO cpu: %s, os: %s]\n", 
 								dns_rr->rdata.hinfo->cpu, dns_rr->rdata.hinfo->os);
+				
+				cJSON_AddStringToObject(dns_rr_object, "cpu", (const char *)(dns_rr->rdata.hinfo->cpu));
+				cJSON_AddStringToObject(dns_rr_object, "os", (const char *)(dns_rr->rdata.hinfo->os));
 				break;
 			case DNS_TYPE_MINFO:
 				used_len += snprintf(buf+used_len, buflen-used_len, "[MINFO rmailbx: %s, emailbx: %s]\n",
 								dns_rr->rdata.minfo->rmailbx, dns_rr->rdata.minfo->emailbx);
+
+				cJSON_AddStringToObject(dns_rr_object, "rmailbx", (const char *)(dns_rr->rdata.minfo->rmailbx));
+				cJSON_AddStringToObject(dns_rr_object, "emailbx", (const char *)(dns_rr->rdata.minfo->emailbx));
 				break;
 			case DNS_TYPE_MX:
 				used_len += snprintf(buf+used_len, buflen-used_len, "[MX preference: %u, exchange: %s]\n",
 								dns_rr->rdata.mx->preference, dns_rr->rdata.mx->exchange);
+
+				cJSON_AddStringToObject(dns_rr_object, "exchange", (const char *)(dns_rr->rdata.mx->exchange));
+				cJSON_AddNumberToObject(dns_rr_object, "preference", dns_rr->rdata.mx->preference);
 				break;
 			case DNS_TYPE_TXT:
 				used_len += snprintf(buf+used_len, buflen-used_len, "[TXT size: %u, txt: %s]\n",
 								dns_rr->rdata.txt->size, dns_rr->rdata.txt->txt);
+
+				cJSON_AddStringToObject(dns_rr_object, "txt", (const char *)(dns_rr->rdata.txt->txt));
+				cJSON_AddNumberToObject(dns_rr_object, "size", dns_rr->rdata.txt->size);
 				break;
 			case DNS_TYPE_RP:
 				used_len += snprintf(buf+used_len, buflen-used_len, "[mailbox: %s, txt_rr: %s]\n",
 								dns_rr->rdata.rp->mailbox, dns_rr->rdata.rp->txt_rr);
+
+				cJSON_AddStringToObject(dns_rr_object, "mailbox", (const char *)(dns_rr->rdata.rp->mailbox));
+				cJSON_AddStringToObject(dns_rr_object, "txt_rr", (const char *)(dns_rr->rdata.rp->txt_rr));
 				break;
 			case DNS_TYPE_AAAA:
 				inet_ntop(AF_INET6, dns_rr->rdata.aaaa, ip_str, sizeof(ip_str));
 				used_len += snprintf(buf+used_len, buflen-used_len, "[AAAA: %s]\n", ip_str);
+				cJSON_AddStringToObject(dns_rr_object, "aaaa", ip_str);
 				break;
 			case DNS_TYPE_OPT:
 				break;
@@ -189,6 +279,11 @@ int rr_print(dns_info_t *dns_info, struct streaminfo *a_udp, int thread_seq, voi
 									"[DS key_tag: %u, algo: %u, digest_type: %u, digest: %s]\n",
 										dns_rr->rdata.ds->key_tag, dns_rr->rdata.ds->algo,
 										dns_rr->rdata.ds->digest_type, tmp_buf);
+
+				cJSON_AddNumberToObject(dns_rr_object, "key_tag", dns_rr->rdata.ds->key_tag);
+				cJSON_AddNumberToObject(dns_rr_object, "algo", dns_rr->rdata.ds->algo);
+				cJSON_AddNumberToObject(dns_rr_object, "digest_type", dns_rr->rdata.ds->digest_type);
+				cJSON_AddStringToObject(dns_rr_object, "digest", tmp_buf);
 				break;
 			case DNS_TYPE_RRSIG:
 				*dns_sec = 2;
@@ -204,6 +299,16 @@ int rr_print(dns_info_t *dns_info, struct streaminfo *a_udp, int thread_seq, voi
 										dns_rr->rdata.rrsig->labels, dns_rr->rdata.rrsig->original_ttl,
 										dns_rr->rdata.rrsig->sig_expiration, dns_rr->rdata.rrsig->sig_inception,
 										dns_rr->rdata.rrsig->key_tag, dns_rr->rdata.rrsig->signer_name, tmp_buf);
+
+				cJSON_AddNumberToObject(dns_rr_object, "type_covered", dns_rr->rdata.rrsig->type_covered);
+				cJSON_AddNumberToObject(dns_rr_object, "algo", dns_rr->rdata.rrsig->algo);
+				cJSON_AddNumberToObject(dns_rr_object, "labels", dns_rr->rdata.rrsig->labels);
+				cJSON_AddNumberToObject(dns_rr_object, "original_ttl", dns_rr->rdata.rrsig->original_ttl);
+				cJSON_AddNumberToObject(dns_rr_object, "sig_expiration", dns_rr->rdata.rrsig->sig_expiration);
+				cJSON_AddNumberToObject(dns_rr_object, "sig_inception", dns_rr->rdata.rrsig->sig_inception);
+				cJSON_AddNumberToObject(dns_rr_object, "key_tag", dns_rr->rdata.rrsig->key_tag);
+				cJSON_AddStringToObject(dns_rr_object, "signer_name", (const char *)(dns_rr->rdata.rrsig->signer_name));
+				cJSON_AddStringToObject(dns_rr_object, "signature", tmp_buf);
 				break;
 			case DNS_TYPE_NSEC:
 				*dns_sec = 2;
@@ -213,6 +318,9 @@ int rr_print(dns_info_t *dns_info, struct streaminfo *a_udp, int thread_seq, voi
 					len += snprintf(maps+len, sizeof(maps)-len, "%02x", dns_rr->rdata.nsec->type_bit_maps[j]);
 				}
 				used_len += snprintf(buf+used_len, buflen-used_len, "[NSEC next_domain: %s, type_bit_maps: %s]\n", dns_rr->rdata.nsec->next_domain, maps);
+
+				cJSON_AddStringToObject(dns_rr_object, "next_domain", (const char *)(dns_rr->rdata.nsec->next_domain));
+				cJSON_AddStringToObject(dns_rr_object, "type_bit_maps", maps);
 				break;
 			case DNS_TYPE_DNSKEY:
 				*dns_sec = 2;
@@ -224,6 +332,11 @@ int rr_print(dns_info_t *dns_info, struct streaminfo *a_udp, int thread_seq, voi
 				}
 				used_len += snprintf(buf+used_len, buflen-used_len, "[DNSKEY flags: %u, protocol: %u, algo: %u, public_key: %s]\n",
 							dns_rr->rdata.dnskey->flags, dns_rr->rdata.dnskey->protocol, dns_rr->rdata.dnskey->algo, tmp_buf);
+
+				cJSON_AddNumberToObject(dns_rr_object, "flags", dns_rr->rdata.dnskey->flags);
+				cJSON_AddNumberToObject(dns_rr_object, "protocol", dns_rr->rdata.dnskey->protocol);
+				cJSON_AddNumberToObject(dns_rr_object, "algo", dns_rr->rdata.dnskey->algo);
+				cJSON_AddStringToObject(dns_rr_object, "public_key", tmp_buf);
 				break;
 			case DNS_TYPE_NSEC3:
 				*dns_sec = 2;
@@ -251,6 +364,15 @@ int rr_print(dns_info_t *dns_info, struct streaminfo *a_udp, int thread_seq, voi
 										dns_rr->rdata.nsec3->hash_algo, dns_rr->rdata.nsec3->flags, 
 										dns_rr->rdata.nsec3->iteration, dns_rr->rdata.nsec3->salt_len, 
 										dns_rr->rdata.nsec3->hash_len, salt_value, tmp_buf, maps);
+
+				cJSON_AddNumberToObject(dns_rr_object, "hash_algo", dns_rr->rdata.nsec3->hash_algo);
+				cJSON_AddNumberToObject(dns_rr_object, "flags", dns_rr->rdata.nsec3->flags);
+				cJSON_AddNumberToObject(dns_rr_object, "iteration", dns_rr->rdata.nsec3->iteration);
+				cJSON_AddNumberToObject(dns_rr_object, "salt_len", dns_rr->rdata.nsec3->salt_len);
+				cJSON_AddNumberToObject(dns_rr_object, "hash_len", dns_rr->rdata.nsec3->hash_len);
+				cJSON_AddStringToObject(dns_rr_object, "salt_value", salt_value);
+				cJSON_AddStringToObject(dns_rr_object, "next_hash_owner", tmp_buf);
+				cJSON_AddStringToObject(dns_rr_object, "type_bit_maps", maps);
 				break;
 			case DNS_TYPE_NSEC3PARAM:
 				len = 0;
@@ -265,9 +387,16 @@ int rr_print(dns_info_t *dns_info, struct streaminfo *a_udp, int thread_seq, voi
 										dns_rr->rdata.nsec3param->hash_algo, dns_rr->rdata.nsec3param->flags,
 										dns_rr->rdata.nsec3param->iteration, dns_rr->rdata.nsec3param->salt_len,
 										tmp_buf);
+
+				cJSON_AddNumberToObject(dns_rr_object, "hash_algo", dns_rr->rdata.nsec3param->hash_algo);
+				cJSON_AddNumberToObject(dns_rr_object, "flags", dns_rr->rdata.nsec3param->flags);
+				cJSON_AddNumberToObject(dns_rr_object, "iteration", dns_rr->rdata.nsec3param->iteration);
+				cJSON_AddNumberToObject(dns_rr_object, "salt_len", dns_rr->rdata.nsec3param->salt_len);
+				cJSON_AddStringToObject(dns_rr_object, "salt_value", tmp_buf);
 				break;
 			case DNS_TYPE_UNKNOWN:
 				used_len += snprintf(buf+used_len, buflen-used_len, "[data: %s]\n", dns_rr->rdata.unknown_data);
+				cJSON_AddStringToObject(dns_rr_object, "data", (const char *)(dns_rr->rdata.unknown_data));
 				break;
 			case DNS_QTYPE_AXFR:
 				continue;
@@ -291,6 +420,18 @@ int rr_print(dns_info_t *dns_info, struct streaminfo *a_udp, int thread_seq, voi
 	fclose(fp);
 	fp = NULL;
 
+
+	//char *question_array=cJSON_Print(dns_info_object);
+	//char *rr_array=cJSON_Print(dns_info_object);
+
+	//cJSON_AddArrayToObject(dns_info_object, question_array);
+	//cJSON_AddArrayToObject(dns_info_object, rr_array);
+
+	char *outout1=cJSON_PrintUnformatted(dns_info_object);
+	char *outout2=cJSON_Print(dns_info_object);
+
+	printf("%s\n", outout1);
+	printf("%s\n", outout2);
 	return 0;
 }