if (p + rr->rdlength > max)	return PJLIB_UTIL_EDNSINSIZE;    /* Parse some well known records */    if (rr->type == PJ_DNS_TYPE_A) {	pj_memcpy(&rr->rdata.a.ip_addr, p, 4);	p += 4;    } else if (rr->type == PJ_DNS_TYPE_CNAME ||	       rr->type == PJ_DNS_TYPE_NS ||	       rr->type == PJ_DNS_TYPE_PTR)     {	/* Get the length of the target name */	status = get_name_len(0, pkt, p, max, &name_part_len, &name_len);	if (status != PJ_SUCCESS)	    return status;	/* Allocate memory for the name */	rr->rdata.cname.name.ptr = pj_pool_alloc(pool, name_len);	rr->rdata.cname.name.slen = 0;	/* Get the name */	status = get_name(0, pkt, p, max, &rr->rdata.cname.name);	if (status != PJ_SUCCESS)	    return status;	p += name_part_len;    } else if (rr->type == PJ_DNS_TYPE_SRV) {	/* Priority */	pj_memcpy(&rr->rdata.srv.prio, p, 2);	rr->rdata.srv.prio = pj_ntohs(rr->rdata.srv.prio);	p += 2;	/* Weight */	pj_memcpy(&rr->rdata.srv.weight, p, 2);	rr->rdata.srv.weight = pj_ntohs(rr->rdata.srv.weight);	p += 2;	/* Port */	pj_memcpy(&rr->rdata.srv.port, p, 2);	rr->rdata.srv.port = pj_ntohs(rr->rdata.srv.port);	p += 2;		/* Get the length of the target name */	status = get_name_len(0, pkt, p, max, &name_part_len, &name_len);	if (status != PJ_SUCCESS)	    return status;	/* Allocate memory for the name */	rr->rdata.srv.target.ptr = pj_pool_alloc(pool, name_len);	rr->rdata.srv.target.slen = 0;	/* Get the name */	status = get_name(0, pkt, p, max, &rr->rdata.srv.target);	if (status != PJ_SUCCESS)	    return status;	p += name_part_len;    } else {	/* Copy the raw data */	rr->data = pj_pool_alloc(pool, rr->rdlength);	pj_memcpy(rr->data, p, rr->rdlength);	p += rr->rdlength;    }    *parsed_len = (int)(p - start);    return PJ_SUCCESS;}/* * Parse raw DNS packet into DNS packet structure. */PJ_DEF(pj_status_t) pj_dns_parse_packet( pj_pool_t *pool,				  	 const void *packet,					 unsigned size,					 pj_dns_parsed_packet **p_res){    pj_dns_parsed_packet *res;    char *start, *end;    pj_status_t status;    unsigned i;    /* Sanity checks */    PJ_ASSERT_RETURN(pool && packet && size && p_res, PJ_EINVAL);    /* Packet size must be at least as big as the header */    if (size < sizeof(pj_dns_hdr))	return PJLIB_UTIL_EDNSINSIZE;    /* Create the structure */    res = pj_pool_zalloc(pool, sizeof(pj_dns_parsed_packet));    /* Copy the DNS header, and convert endianness to host byte order */    pj_memcpy(&res->hdr, packet, sizeof(pj_dns_hdr));    res->hdr.id	      = pj_ntohs(res->hdr.id);    res->hdr.flags    = pj_ntohs(res->hdr.flags);    res->hdr.qdcount  = pj_ntohs(res->hdr.qdcount);    res->hdr.anscount = pj_ntohs(res->hdr.anscount);    res->hdr.nscount  = pj_ntohs(res->hdr.nscount);    res->hdr.arcount  = pj_ntohs(res->hdr.arcount);    /* Mark start and end of payload */    start = ((char*)packet) + sizeof(pj_dns_hdr);    end = ((char*)packet) + size;    /* Parse query records (if any).     */    if (res->hdr.qdcount) {	res->q = pj_pool_zalloc(pool, res->hdr.qdcount *				      sizeof(pj_dns_parsed_query));	for (i=0; i<res->hdr.qdcount; ++i) {	    int parsed_len = 0;	    	    status = parse_query(&res->q[i], pool, packet, start, end,				 &parsed_len);	    if (status != PJ_SUCCESS)		return status;	    start += parsed_len;	}    }    /* Parse answer, if any */    if (res->hdr.anscount) {	res->ans = pj_pool_zalloc(pool, res->hdr.anscount * 					sizeof(pj_dns_parsed_rr));	for (i=0; i<res->hdr.anscount; ++i) {	    int parsed_len;	    status = parse_rr(&res->ans[i], pool, packet, start, end, 			      &parsed_len);	    if (status != PJ_SUCCESS)		return status;	    start += parsed_len;	}    }    /* Parse authoritative NS records, if any */    if (res->hdr.nscount) {	res->ns = pj_pool_zalloc(pool, res->hdr.nscount *				       sizeof(pj_dns_parsed_rr));	for (i=0; i<res->hdr.nscount; ++i) {	    int parsed_len;	    status = parse_rr(&res->ns[i], pool, packet, start, end, 			      &parsed_len);	    if (status != PJ_SUCCESS)		return status;	    start += parsed_len;	}    }    /* Parse additional RR answer, if any */    if (res->hdr.arcount) {	res->arr = pj_pool_zalloc(pool, res->hdr.arcount *					sizeof(pj_dns_parsed_rr));	for (i=0; i<res->hdr.arcount; ++i) {	    int parsed_len;	    status = parse_rr(&res->arr[i], pool, packet, start, end, 			      &parsed_len);	    if (status != PJ_SUCCESS)		return status;	    start += parsed_len;	}    }    /* Looks like everything is okay */    *p_res = res;    return PJ_SUCCESS;}/* Perform name compression scheme. * If a name is already in the nametable, when no need to duplicate * the string with the pool, but rather just use the pointer there. */static void apply_name_table( unsigned *count,			      pj_str_t nametable[],		    	      const pj_str_t *src,			      pj_pool_t *pool,			      pj_str_t *dst){    unsigned i;    /* Scan strings in nametable */    for (i=0; i<*count; ++i) {	if (pj_stricmp(&nametable[i], src) == 0)	    break;    }    /* If name is found in nametable, use the pointer in the nametable */    if (i != *count) {	dst->ptr = nametable[i].ptr;	dst->slen = nametable[i].slen;	return;    }    /* Otherwise duplicate the string, and insert new name in nametable */    pj_strdup(pool, dst, src);    if (*count < PJ_DNS_MAX_NAMES_IN_NAMETABLE) {	nametable[*count].ptr = dst->ptr;	nametable[*count].slen = dst->slen;	++(*count);    }}static void copy_query(pj_pool_t *pool, pj_dns_parsed_query *dst,		       const pj_dns_parsed_query *src,		       unsigned *nametable_count,		       pj_str_t nametable[]){    pj_memcpy(dst, src, sizeof(*src));    apply_name_table(nametable_count, nametable, &src->name, pool, &dst->name);}static void copy_rr(pj_pool_t *pool, pj_dns_parsed_rr *dst,		    const pj_dns_parsed_rr *src,		    unsigned *nametable_count,		    pj_str_t nametable[]){    pj_memcpy(dst, src, sizeof(*src));    apply_name_table(nametable_count, nametable, &src->name, pool, &dst->name);    if (src->data) {	dst->data = pj_pool_alloc(pool, src->rdlength);	pj_memcpy(dst->data, src->data, src->rdlength);    }    if (src->type == PJ_DNS_TYPE_SRV) {	apply_name_table(nametable_count, nametable, &src->rdata.srv.target, 			 pool, &dst->rdata.srv.target);    } else if (src->type == PJ_DNS_TYPE_A) {	dst->rdata.a.ip_addr.s_addr =  src->rdata.a.ip_addr.s_addr;    } else if (src->type == PJ_DNS_TYPE_CNAME) {	pj_strdup(pool, &dst->rdata.cname.name, &src->rdata.cname.name);    } else if (src->type == PJ_DNS_TYPE_NS) {	pj_strdup(pool, &dst->rdata.ns.name, &src->rdata.ns.name);    } else if (src->type == PJ_DNS_TYPE_PTR) {	pj_strdup(pool, &dst->rdata.ptr.name, &src->rdata.ptr.name);    }}/* * Duplicate DNS packet. */PJ_DEF(void) pj_dns_packet_dup(pj_pool_t *pool,			       const pj_dns_parsed_packet*p,			       unsigned options,			       pj_dns_parsed_packet **p_dst){    pj_dns_parsed_packet *dst;    unsigned nametable_count = 0;#if PJ_DNS_MAX_NAMES_IN_NAMETABLE    pj_str_t nametable[PJ_DNS_MAX_NAMES_IN_NAMETABLE];#else    pj_str_t *nametable = NULL;#endif    unsigned i;    PJ_ASSERT_ON_FAIL(pool && p && p_dst, return);    /* Create packet and copy header */    *p_dst = dst = pj_pool_zalloc(pool, sizeof(pj_dns_parsed_packet));    pj_memcpy(&dst->hdr, &p->hdr, sizeof(p->hdr));    /* Initialize section counts in the target packet to zero.     * If memory allocation fails during copying process, the target packet     * should have a correct section counts.     */    dst->hdr.qdcount = 0;    dst->hdr.anscount = 0;    dst->hdr.nscount = 0;    dst->hdr.arcount = 0;	    /* Copy query section */    if (p->hdr.qdcount && (options & PJ_DNS_NO_QD)==0) {	dst->q = pj_pool_alloc(pool, p->hdr.qdcount * 				     sizeof(pj_dns_parsed_query));	for (i=0; i<p->hdr.qdcount; ++i) {	    copy_query(pool, &dst->q[i], &p->q[i], 		       &nametable_count, nametable);	    ++dst->hdr.qdcount;	}    }    /* Copy answer section */    if (p->hdr.anscount && (options & PJ_DNS_NO_ANS)==0) {	dst->ans = pj_pool_alloc(pool, p->hdr.anscount * 				       sizeof(pj_dns_parsed_rr));	for (i=0; i<p->hdr.anscount; ++i) {	    copy_rr(pool, &dst->ans[i], &p->ans[i],		    &nametable_count, nametable);	    ++dst->hdr.anscount;	}    }    /* Copy NS section */    if (p->hdr.nscount && (options & PJ_DNS_NO_NS)==0) {	dst->ns = pj_pool_alloc(pool, p->hdr.nscount * 				      sizeof(pj_dns_parsed_rr));	for (i=0; i<p->hdr.nscount; ++i) {	    copy_rr(pool, &dst->ns[i], &p->ns[i],		    &nametable_count, nametable);	    ++dst->hdr.nscount;	}    }    /* Copy additional info section */    if (p->hdr.arcount && (options & PJ_DNS_NO_AR)==0) {	dst->arr = pj_pool_alloc(pool, p->hdr.arcount * 				       sizeof(pj_dns_parsed_rr));	for (i=0; i<p->hdr.arcount; ++i) {	    copy_rr(pool, &dst->arr[i], &p->arr[i],		    &nametable_count, nametable);	    ++dst->hdr.arcount;	}    }}