static void dump_answer(unsigned index, const pj_dns_parsed_rr *rr) { const pj_str_t root_name = { "<Root>", 6 }; const pj_str_t *name = &rr->name; char ttl_words[32]; char addr[PJ_INET6_ADDRSTRLEN]; if (name->slen == 0) name = &root_name; PJ_LOG(3,(THIS_FILE, " %d. %s record (type=%d)", index, pj_dns_get_type_name(rr->type), rr->type)); PJ_LOG(3,(THIS_FILE, " Name: %.*s", (int)name->slen, name->ptr)); PJ_LOG(3,(THIS_FILE, " TTL: %u (%s)", rr->ttl, spell_ttl(ttl_words, sizeof(ttl_words), rr->ttl))); PJ_LOG(3,(THIS_FILE, " Data length: %u", rr->rdlength)); if (rr->type == PJ_DNS_TYPE_SRV) { PJ_LOG(3,(THIS_FILE, " SRV: prio=%d, weight=%d %.*s:%d", rr->rdata.srv.prio, rr->rdata.srv.weight, (int)rr->rdata.srv.target.slen, rr->rdata.srv.target.ptr, rr->rdata.srv.port)); } else if (rr->type == PJ_DNS_TYPE_CNAME || rr->type == PJ_DNS_TYPE_NS || rr->type == PJ_DNS_TYPE_PTR) { PJ_LOG(3,(THIS_FILE, " Name: %.*s", (int)rr->rdata.cname.name.slen, rr->rdata.cname.name.ptr)); } else if (rr->type == PJ_DNS_TYPE_A) { PJ_LOG(3,(THIS_FILE, " IP address: %s", pj_inet_ntop2(pj_AF_INET(), &rr->rdata.a.ip_addr, addr, sizeof(addr)))); } else if (rr->type == PJ_DNS_TYPE_AAAA) { PJ_LOG(3,(THIS_FILE, " IPv6 address: %s", pj_inet_ntop2(pj_AF_INET6(), &rr->rdata.aaaa.ip_addr, addr, sizeof(addr)))); } }
/* Read UDP packet */ PJ_DEF(pj_status_t) pj_pcap_read_udp(pj_pcap_file *file, pj_pcap_udp_hdr *udp_hdr, pj_uint8_t *udp_payload, pj_size_t *udp_payload_size) { PJ_ASSERT_RETURN(file && udp_payload && udp_payload_size, PJ_EINVAL); PJ_ASSERT_RETURN(*udp_payload_size, PJ_EINVAL); /* Check data link type in PCAP file header */ if ((file->filter.link && file->hdr.network != (pj_uint32_t)file->filter.link) || file->hdr.network != PJ_PCAP_LINK_TYPE_ETH) { /* Link header other than Ethernet is not supported for now */ return PJ_ENOTSUP; } /* Loop until we have the packet */ for (;;) { union { pj_pcap_rec_hdr rec; pj_pcap_eth_hdr eth; pj_pcap_ip_hdr ip; pj_pcap_udp_hdr udp; } tmp; unsigned rec_incl; pj_ssize_t sz; pj_size_t sz_read = 0; char addr[PJ_INET_ADDRSTRLEN]; pj_status_t status; TRACE_((file->obj_name, "Reading packet..")); pj_bzero(&addr, sizeof(addr)); /* Read PCAP packet header */ sz = sizeof(tmp.rec); status = read_file(file, &tmp.rec, &sz); if (status != PJ_SUCCESS) { TRACE_((file->obj_name, "read_file() error: %d", status)); return status; } rec_incl = tmp.rec.incl_len; /* Swap byte ordering */ if (file->swap) { tmp.rec.incl_len = pj_ntohl(tmp.rec.incl_len); tmp.rec.orig_len = pj_ntohl(tmp.rec.orig_len); tmp.rec.ts_sec = pj_ntohl(tmp.rec.ts_sec); tmp.rec.ts_usec = pj_ntohl(tmp.rec.ts_usec); } /* Read link layer header */ switch (file->hdr.network) { case PJ_PCAP_LINK_TYPE_ETH: sz = sizeof(tmp.eth); status = read_file(file, &tmp.eth, &sz); break; default: TRACE_((file->obj_name, "Error: link layer not Ethernet")); return PJ_ENOTSUP; } if (status != PJ_SUCCESS) { TRACE_((file->obj_name, "Error reading Eth header: %d", status)); return status; } sz_read += sz; /* Read IP header */ sz = sizeof(tmp.ip); status = read_file(file, &tmp.ip, &sz); if (status != PJ_SUCCESS) { TRACE_((file->obj_name, "Error reading IP header: %d", status)); return status; } sz_read += sz; /* Skip if IP source mismatch */ if (file->filter.ip_src && tmp.ip.ip_src != file->filter.ip_src) { TRACE_((file->obj_name, "IP source %s mismatch, skipping", pj_inet_ntop2(pj_AF_INET(), (pj_in_addr*)&tmp.ip.ip_src, addr, sizeof(addr)))); SKIP_PKT(); continue; } /* Skip if IP destination mismatch */ if (file->filter.ip_dst && tmp.ip.ip_dst != file->filter.ip_dst) { TRACE_((file->obj_name, "IP detination %s mismatch, skipping", pj_inet_ntop2(pj_AF_INET(), (pj_in_addr*)&tmp.ip.ip_dst, addr, sizeof(addr)))); SKIP_PKT(); continue; } /* Skip if proto mismatch */ if (file->filter.proto && tmp.ip.proto != file->filter.proto) { TRACE_((file->obj_name, "IP proto %d mismatch, skipping", tmp.ip.proto)); SKIP_PKT(); continue; } /* Read transport layer header */ switch (tmp.ip.proto) { case PJ_PCAP_PROTO_TYPE_UDP: sz = sizeof(tmp.udp); status = read_file(file, &tmp.udp, &sz); if (status != PJ_SUCCESS) { TRACE_((file->obj_name, "Error reading UDP header: %d",status)); return status; } sz_read += sz; /* Skip if source port mismatch */ if (file->filter.src_port && tmp.udp.src_port != file->filter.src_port) { TRACE_((file->obj_name, "UDP src port %d mismatch, skipping", pj_ntohs(tmp.udp.src_port))); SKIP_PKT(); continue; } /* Skip if destination port mismatch */ if (file->filter.dst_port && tmp.udp.dst_port != file->filter.dst_port) { TRACE_((file->obj_name, "UDP dst port %d mismatch, skipping", pj_ntohs(tmp.udp.dst_port))); SKIP_PKT(); continue; } /* Copy UDP header if caller wants it */ if (udp_hdr) { pj_memcpy(udp_hdr, &tmp.udp, sizeof(*udp_hdr)); } /* Calculate payload size */ sz = pj_ntohs(tmp.udp.len) - sizeof(tmp.udp); break; default: TRACE_((file->obj_name, "Not UDP, skipping")); SKIP_PKT(); continue; } /* Check if payload fits the buffer */ if (sz > (pj_ssize_t)*udp_payload_size) { TRACE_((file->obj_name, "Error: packet too large (%d bytes required)", sz)); SKIP_PKT(); return PJ_ETOOSMALL; } /* Read the payload */ status = read_file(file, udp_payload, &sz); if (status != PJ_SUCCESS) { TRACE_((file->obj_name, "Error reading payload: %d", status)); return status; } sz_read += sz; *udp_payload_size = sz; // Some layers may have trailer, e.g: link eth2. /* Check that we've read all the packets */ //PJ_ASSERT_RETURN(sz_read == rec_incl, PJ_EBUG); /* Skip trailer */ while (sz_read < rec_incl) { sz = rec_incl - sz_read; status = read_file(file, &tmp.eth, &sz); if (status != PJ_SUCCESS) { TRACE_((file->obj_name, "Error reading trailer: %d", status)); return status; } sz_read += sz; } return PJ_SUCCESS; } /* Does not reach here */ }
/* * This is the main function for performing server resolution. */ PJ_DEF(void) pjsip_resolve( pjsip_resolver_t *resolver, pj_pool_t *pool, const pjsip_host_info *target, void *token, pjsip_resolver_callback *cb) { pjsip_server_addresses svr_addr; pj_status_t status = PJ_SUCCESS; int ip_addr_ver; struct query *query; pjsip_transport_type_e type = target->type; /* Is it IP address or hostname? And if it's an IP, which version? */ ip_addr_ver = get_ip_addr_ver(&target->addr.host); /* Set the transport type if not explicitly specified. * RFC 3263 section 4.1 specify rules to set up this. */ if (type == PJSIP_TRANSPORT_UNSPECIFIED) { if (ip_addr_ver || (target->addr.port != 0)) { #if PJ_HAS_TCP if (target->flag & PJSIP_TRANSPORT_SECURE) { type = PJSIP_TRANSPORT_TLS; } else if (target->flag & PJSIP_TRANSPORT_RELIABLE) { type = PJSIP_TRANSPORT_TCP; } else #endif { type = PJSIP_TRANSPORT_UDP; } } else { /* No type or explicit port is specified, and the address is * not IP address. * In this case, full resolution must be performed. * But we don't support it (yet). */ #if PJ_HAS_TCP if (target->flag & PJSIP_TRANSPORT_SECURE) { type = PJSIP_TRANSPORT_TLS; } else if (target->flag & PJSIP_TRANSPORT_RELIABLE) { type = PJSIP_TRANSPORT_TCP; } else #endif { type = PJSIP_TRANSPORT_UDP; } } /* Add IPv6 flag for IPv6 address */ if (ip_addr_ver == 6) type = (pjsip_transport_type_e)((int)type + PJSIP_TRANSPORT_IPV6); } /* If target is an IP address, or if resolver is not configured, * we can just finish the resolution now using pj_gethostbyname() */ if (ip_addr_ver || resolver->res == NULL) { char ip_addr[PJ_INET6_ADDRSTRLEN]; int af; pj_addrinfo ai; unsigned count; pj_uint16_t srv_port; if (!ip_addr_ver) { PJ_LOG(5,(THIS_FILE, "DNS resolver not available, target '%.*s:%d' type=%s " "will be resolved with gethostbyname()", target->addr.host.slen, target->addr.host.ptr, target->addr.port, pjsip_transport_get_type_name(target->type))); } /* Set the port number if not specified. */ if (target->addr.port == 0) { srv_port = (pj_uint16_t) pjsip_transport_get_default_port_for_type(type); } else { srv_port = (pj_uint16_t)target->addr.port; } if (type & PJSIP_TRANSPORT_IPV6) { af = pj_AF_INET6(); } else { af = pj_AF_INET(); } /* Resolve */ count = 1; status = pj_getaddrinfo(af, &target->addr.host, &count, &ai); if (status != PJ_SUCCESS) goto on_error; svr_addr.entry[0].addr.addr.sa_family = (pj_uint16_t)af; pj_memcpy(&svr_addr.entry[0].addr, &ai.ai_addr, sizeof(pj_sockaddr)); if (af == pj_AF_INET6()) { svr_addr.entry[0].addr.ipv6.sin6_port = pj_htons(srv_port); } else { svr_addr.entry[0].addr.ipv4.sin_port = pj_htons(srv_port); } /* Call the callback. */ PJ_LOG(5,(THIS_FILE, "Target '%.*s:%d' type=%s resolved to " "'%s:%d' type=%s (%s)", (int)target->addr.host.slen, target->addr.host.ptr, target->addr.port, pjsip_transport_get_type_name(target->type), pj_inet_ntop2(af, pj_sockaddr_get_addr(&svr_addr.entry[0].addr), ip_addr, sizeof(ip_addr)), srv_port, pjsip_transport_get_type_name(type), pjsip_transport_get_type_desc(type))); svr_addr.count = 1; svr_addr.entry[0].priority = 0; svr_addr.entry[0].weight = 0; svr_addr.entry[0].type = type; svr_addr.entry[0].addr_len = pj_sockaddr_get_len(&svr_addr.entry[0].addr); (*cb)(status, token, &svr_addr); /* Done. */ return; } /* Target is not an IP address so we need to resolve it. */ #if PJSIP_HAS_RESOLVER /* Build the query state */ query = PJ_POOL_ZALLOC_T(pool, struct query); query->objname = THIS_FILE; query->token = token; query->cb = cb; query->req.target = *target; pj_strdup(pool, &query->req.target.addr.host, &target->addr.host); /* If port is not specified, start with SRV resolution * (should be with NAPTR, but we'll do that later) */ PJ_TODO(SUPPORT_DNS_NAPTR); /* Build dummy NAPTR entry */ query->naptr_cnt = 1; pj_bzero(&query->naptr[0], sizeof(query->naptr[0])); query->naptr[0].order = 0; query->naptr[0].pref = 0; query->naptr[0].type = type; pj_strdup(pool, &query->naptr[0].name, &target->addr.host); /* Start DNS SRV or A resolution, depending on whether port is specified */ if (target->addr.port == 0) { query->query_type = PJ_DNS_TYPE_SRV; query->req.def_port = 5060; if (type == PJSIP_TRANSPORT_TLS) { query->naptr[0].res_type = pj_str("_sips._tcp."); query->req.def_port = 5061; } else if (type == PJSIP_TRANSPORT_TCP) query->naptr[0].res_type = pj_str("_sip._tcp."); else if (type == PJSIP_TRANSPORT_UDP) query->naptr[0].res_type = pj_str("_sip._udp."); else { pj_assert(!"Unknown transport type"); query->naptr[0].res_type = pj_str("_sip._udp."); } } else { /* Otherwise if port is specified, start with A (or AAAA) host * resolution */ query->query_type = PJ_DNS_TYPE_A; query->naptr[0].res_type.slen = 0; query->req.def_port = target->addr.port; } /* Start the asynchronous query */ PJ_LOG(5, (query->objname, "Starting async DNS %s query: target=%.*s%.*s, transport=%s, " "port=%d", pj_dns_get_type_name(query->query_type), (int)query->naptr[0].res_type.slen, query->naptr[0].res_type.ptr, (int)query->naptr[0].name.slen, query->naptr[0].name.ptr, pjsip_transport_get_type_name(target->type), target->addr.port)); if (query->query_type == PJ_DNS_TYPE_SRV) { status = pj_dns_srv_resolve(&query->naptr[0].name, &query->naptr[0].res_type, query->req.def_port, pool, resolver->res, PJ_TRUE, query, &srv_resolver_cb, NULL); } else if (query->query_type == PJ_DNS_TYPE_A) { status = pj_dns_resolver_start_query(resolver->res, &query->naptr[0].name, PJ_DNS_TYPE_A, 0, &dns_a_callback, query, &query->object); } else { pj_assert(!"Unexpected"); status = PJ_EBUG; } if (status != PJ_SUCCESS) goto on_error; return; #else /* PJSIP_HAS_RESOLVER */ PJ_UNUSED_ARG(pool); PJ_UNUSED_ARG(query); PJ_UNUSED_ARG(srv_name); #endif /* PJSIP_HAS_RESOLVER */ on_error: if (status != PJ_SUCCESS) { char errmsg[PJ_ERR_MSG_SIZE]; PJ_LOG(4,(THIS_FILE, "Failed to resolve '%.*s'. Err=%d (%s)", (int)target->addr.host.slen, target->addr.host.ptr, status, pj_strerror(status,errmsg,sizeof(errmsg)).ptr)); (*cb)(status, token, NULL); return; } }