bool nsHttpConnectionInfo::HostIsLocalIPLiteral() const { PRNetAddr prAddr; // If the host/proxy host is not an IP address literal, return false. if (ProxyHost()) { if (PR_StringToNetAddr(ProxyHost(), &prAddr) != PR_SUCCESS) { return false; } } else if (PR_StringToNetAddr(Origin(), &prAddr) != PR_SUCCESS) { return false; } NetAddr netAddr; PRNetAddrToNetAddr(&prAddr, &netAddr); return IsIPAddrLocal(&netAddr); }
static bool ConvertToIPV6Addr(const nsACString& aName, PRIPv6Addr* aAddr, int32_t* aMask) { PRNetAddr addr; // try to convert hostname to IP if (PR_StringToNetAddr(PromiseFlatCString(aName).get(), &addr) != PR_SUCCESS) return false; // convert parsed address to IPv6 if (addr.raw.family == PR_AF_INET) { // convert to IPv4-mapped address PR_ConvertIPv4AddrToIPv6(addr.inet.ip, aAddr); if (aMask) { if (*aMask <= 32) *aMask += 96; else return false; } } else if (addr.raw.family == PR_AF_INET6) { // copy the address memcpy(aAddr, &addr.ipv6.ip, sizeof(PRIPv6Addr)); } else { return false; } return true; }
static PRStatus PrintAddress(const PRNetAddr* address) { PRNetAddr translation; char buffer[ADDR_BUFFER]; PRStatus rv = PR_NetAddrToString(address, buffer, sizeof(buffer)); if (PR_FAILURE == rv) PL_FPrintError(err, "PR_NetAddrToString"); else { PR_fprintf(err, "\t%s\n", buffer); rv = PR_StringToNetAddr(buffer, &translation); if (PR_FAILURE == rv) PL_FPrintError(err, "PR_StringToNetAddr"); else { PRSize addr_len = PR_NETADDR_SIZE(address); if (0 != memcmp(address, &translation, addr_len)) { PR_fprintf(err, "Address translations do not match\n"); DumpAddr(address, "original"); DumpAddr(&translation, "translate"); rv = PR_FAILURE; } } } return rv; } /* PrintAddress */
nsresult UDPSocketParent::ConnectInternal(const nsCString& aHost, const uint16_t& aPort) { nsresult rv; UDPSOCKET_LOG(("%s: %s:%u", __FUNCTION__, nsCString(aHost).get(), aPort)); if (!mSocket) { return NS_ERROR_NOT_AVAILABLE; } PRNetAddr prAddr; memset(&prAddr, 0, sizeof(prAddr)); PR_InitializeNetAddr(PR_IpAddrAny, aPort, &prAddr); PRStatus status = PR_StringToNetAddr(aHost.BeginReading(), &prAddr); if (status != PR_SUCCESS) { return NS_ERROR_FAILURE; } mozilla::net::NetAddr addr; PRNetAddrToNetAddr(&prAddr, &addr); rv = mSocket->Connect(&addr); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } return NS_OK; }
PRStatus initAddr (PRNetAddr* addr, const char* host, int port = -1) { std::string sHost = host; if (PR_StringToNetAddr(sHost.c_str(), addr) == PR_FAILURE) { std::string sIp; std::string sPort; if (sHost[0] == '[') { sIp = sHost.substr(1, sHost.find_last_of("]")-1); sPort = sHost.substr(sHost.find_last_of("]")+2); } else { sIp = sHost.substr(0, sHost.find_last_of(":")); sPort = sHost.substr(sHost.find_last_of(":")+1); } if (!sPort.empty()) { int tmp = atoi(sPort.c_str()); if (tmp >= 1 && tmp <= 65536) { port = tmp; } } if (PR_StringToNetAddr(sIp.c_str(), addr) == PR_FAILURE) { char* ip = getHostByName(sIp.c_str()); if (ip == NULL) { return PR_FAILURE; } sIp = ip; delete [] ip; if (PR_StringToNetAddr(sIp.c_str(), addr) == PR_FAILURE) { return PR_FAILURE; } } } if (port >= 1 && port <= 65536) { PR_InitializeNetAddr(PR_IpAddrNull, port, addr); } return PR_SUCCESS; }
// callback while UDP socket is opened or closed NS_IMETHODIMP NrSocketIpc::CallListenerVoid(const nsACString &type) { ASSERT_ON_THREAD(main_thread_); if (type.EqualsLiteral("onopen")) { ReentrantMonitorAutoEnter mon(monitor_); uint16_t port; if (NS_FAILED(socket_child_->GetLocalPort(&port))) { err_ = true; MOZ_ASSERT(false, "Failed to get local port"); return NS_OK; } nsAutoCString address; if(NS_FAILED(socket_child_->GetLocalAddress(address))) { err_ = true; MOZ_ASSERT(false, "Failed to get local address"); return NS_OK; } PRNetAddr praddr; if (PR_SUCCESS != PR_InitializeNetAddr(PR_IpAddrAny, port, &praddr)) { err_ = true; MOZ_ASSERT(false, "Failed to set port in PRNetAddr"); return NS_OK; } if (PR_SUCCESS != PR_StringToNetAddr(address.BeginReading(), &praddr)) { err_ = true; MOZ_ASSERT(false, "Failed to convert local host to PRNetAddr"); return NS_OK; } nr_transport_addr expected_addr; if(nr_transport_addr_copy(&expected_addr, &my_addr_)) { err_ = true; MOZ_ASSERT(false, "Failed to copy my_addr_"); } if (nr_praddr_to_transport_addr(&praddr, &my_addr_, 1)) { err_ = true; MOZ_ASSERT(false, "Failed to copy local host to my_addr_"); } if (nr_transport_addr_cmp(&expected_addr, &my_addr_, NR_TRANSPORT_ADDR_CMP_MODE_ADDR)) { err_ = true; MOZ_ASSERT(false, "Address of opened socket is not expected"); } mon.NotifyAll(); } else if (type.EqualsLiteral("onclose")) { // Already handled in UpdateReadyState, nothing to do here } else { MOZ_ASSERT(false, "Received unexpected event"); } return NS_OK; }
bool UDPSocketParent::Init(const nsCString &aHost, const uint16_t aPort) { nsresult rv; NS_ASSERTION(mFilter, "No packet filter"); nsCOMPtr<nsIUDPSocket> sock = do_CreateInstance("@mozilla.org/network/udp-socket;1", &rv); if (NS_FAILED(rv)) { FireInternalError(this, __LINE__); return true; } if (aHost.IsEmpty()) { rv = sock->Init(aPort, false); } else { PRNetAddr prAddr; PR_InitializeNetAddr(PR_IpAddrAny, aPort, &prAddr); PRStatus status = PR_StringToNetAddr(aHost.BeginReading(), &prAddr); if (status != PR_SUCCESS) { FireInternalError(this, __LINE__); return true; } mozilla::net::NetAddr addr; PRNetAddrToNetAddr(&prAddr, &addr); rv = sock->InitWithAddress(&addr); } if (NS_FAILED(rv)) { FireInternalError(this, __LINE__); return true; } mSocket = sock; net::NetAddr localAddr; mSocket->GetAddress(&localAddr); uint16_t port; nsCString addr; rv = ConvertNetAddrToString(localAddr, &addr, &port); if (NS_FAILED(rv)) { FireInternalError(this, __LINE__); return true; } // register listener mSocket->AsyncListen(this); mozilla::unused << PUDPSocketParent::SendCallback(NS_LITERAL_CSTRING("onopen"), UDPAddressInfo(addr, port), NS_LITERAL_CSTRING("connected")); return true; }
int main(int argc, char **argv) #endif { const char **nexttestaddr = testaddrs; const char **nextbadaddr = badaddrs; const char *in, *expected_out; PRNetAddr addr; char buf[256]; PRStatus rv; while ((in = *nexttestaddr++) != 0) { expected_out = *nexttestaddr++; rv = PR_StringToNetAddr(in, &addr); if (rv) { printf("cannot convert %s to addr: %d\n", in, rv); failed_already = 1; continue; } rv = PR_NetAddrToString(&addr, buf, sizeof(buf)); if (rv) { printf("cannot convert %s back to string: %d\n", in, rv); failed_already = 1; continue; } if (strcmp(buf, expected_out)) { /* This is not necessarily an error */ printf("%s expected %s got %s\n", in, expected_out, buf); } } while ((in = *nextbadaddr++) != 0) { if (PR_StringToNetAddr(in, &addr) == PR_SUCCESS) { printf("converted bad addr %s\n", in); failed_already = 1; } } if (failed_already) { printf("FAIL\n"); return 1; } printf("PASS\n"); return 0; }
// callback while UDP socket is opened NS_IMETHODIMP NrSocketIpc::CallListenerOpened() { ASSERT_ON_THREAD(main_thread_); ReentrantMonitorAutoEnter mon(monitor_); uint16_t port; if (NS_FAILED(socket_child_->GetLocalPort(&port))) { err_ = true; MOZ_ASSERT(false, "Failed to get local port"); return NS_OK; } nsAutoCString address; if(NS_FAILED(socket_child_->GetLocalAddress(address))) { err_ = true; MOZ_ASSERT(false, "Failed to get local address"); return NS_OK; } PRNetAddr praddr; if (PR_SUCCESS != PR_InitializeNetAddr(PR_IpAddrAny, port, &praddr)) { err_ = true; MOZ_ASSERT(false, "Failed to set port in PRNetAddr"); return NS_OK; } if (PR_SUCCESS != PR_StringToNetAddr(address.BeginReading(), &praddr)) { err_ = true; MOZ_ASSERT(false, "Failed to convert local host to PRNetAddr"); return NS_OK; } nr_transport_addr expected_addr; if(nr_transport_addr_copy(&expected_addr, &my_addr_)) { err_ = true; MOZ_ASSERT(false, "Failed to copy my_addr_"); } if (nr_praddr_to_transport_addr(&praddr, &my_addr_, IPPROTO_UDP, 1)) { err_ = true; MOZ_ASSERT(false, "Failed to copy local host to my_addr_"); } if (nr_transport_addr_cmp(&expected_addr, &my_addr_, NR_TRANSPORT_ADDR_CMP_MODE_ADDR)) { err_ = true; MOZ_ASSERT(false, "Address of opened socket is not expected"); } mon.NotifyAll(); return NS_OK; }
static bool IsNonFqdn(nsIURI *uri) { nsAutoCString host; PRNetAddr addr; if (NS_FAILED(uri->GetAsciiHost(host))) return false; // return true if host does not contain a dot and is not an ip address return !host.IsEmpty() && host.FindChar('.') == kNotFound && PR_StringToNetAddr(host.BeginReading(), &addr) != PR_SUCCESS; }
nsresult UDPSocketParent::BindInternal(const nsCString& aHost, const uint16_t& aPort, const bool& aAddressReuse, const bool& aLoopback) { nsresult rv; UDPSOCKET_LOG(("%s: %s:%u", __FUNCTION__, nsCString(aHost).get(), aPort)); nsCOMPtr<nsIUDPSocket> sock = do_CreateInstance("@mozilla.org/network/udp-socket;1", &rv); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } if (aHost.IsEmpty()) { rv = sock->Init(aPort, false, mPrincipal, aAddressReuse, /* optional_argc = */ 1); } else { PRNetAddr prAddr; PR_InitializeNetAddr(PR_IpAddrAny, aPort, &prAddr); PRStatus status = PR_StringToNetAddr(aHost.BeginReading(), &prAddr); if (status != PR_SUCCESS) { return NS_ERROR_FAILURE; } mozilla::net::NetAddr addr; PRNetAddrToNetAddr(&prAddr, &addr); rv = sock->InitWithAddress(&addr, mPrincipal, aAddressReuse, /* optional_argc = */ 1); } if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } rv = sock->SetMulticastLoopback(aLoopback); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } // register listener rv = sock->AsyncListen(this); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } mSocket = sock; return NS_OK; }
bool nsHttpNegotiateAuth::TestNonFqdn(nsIURI *uri) { nsCAutoString host; PRNetAddr addr; if (!TestBoolPref(kNegotiateAuthAllowNonFqdn)) return false; if (NS_FAILED(uri->GetAsciiHost(host))) return false; // return true if host does not contain a dot and is not an ip address return !host.IsEmpty() && host.FindChar('.') == kNotFound && PR_StringToNetAddr(host.BeginReading(), &addr) != PR_SUCCESS; }
static LDAPHostEnt * prldap_gethostbyaddr( const char *addr, int length, int type, LDAPHostEnt *result, char *buffer, int buflen, int *statusp, void *extradata ) { PRHostEnt prhent; PRNetAddr iaddr; if ( PR_SetNetAddr(PR_IpAddrNull, PRLDAP_DEFAULT_ADDRESS_FAMILY, 0, &iaddr) == PR_FAILURE || PR_StringToNetAddr( addr, &iaddr ) == PR_FAILURE ) { return( NULL ); } if( !statusp || (*statusp = PR_GetHostByAddr(&iaddr, buffer, buflen, &prhent )) == PR_FAILURE ) { return( NULL ); } return( prldap_convert_hostent( result, &prhent )); }
static PRBool ConvertToIPV6Addr(const nsACString& aName, PRIPv6Addr* aAddr) { PRNetAddr addr; if (PR_StringToNetAddr(PromiseFlatCString(aName).get(), &addr) != PR_SUCCESS) return PR_FALSE; PRIPv6Addr ipv6; // convert parsed address to IPv6 if (addr.raw.family == PR_AF_INET) { // convert to IPv4-mapped address PR_ConvertIPv4AddrToIPv6(addr.inet.ip, &ipv6); } else if (addr.raw.family == PR_AF_INET6) { // copy the address memcpy(&ipv6, &addr.ipv6.ip, sizeof(PRIPv6Addr)); } else { return PR_FALSE; } return PR_TRUE; }
// callback while receiving UDP packet NS_IMETHODIMP NrSocketIpc::CallListenerReceivedData(const nsACString &type, const nsACString &host, uint16_t port, uint8_t *data, uint32_t data_length) { ASSERT_ON_THREAD(main_thread_); MOZ_ASSERT(type.EqualsLiteral("ondata")); PRNetAddr addr; memset(&addr, 0, sizeof(addr)); { ReentrantMonitorAutoEnter mon(monitor_); if (PR_SUCCESS != PR_StringToNetAddr(host.BeginReading(), &addr)) { err_ = true; MOZ_ASSERT(false, "Failed to convert remote host to PRNetAddr"); return NS_OK; } // Use PR_IpAddrNull to avoid address being reset to 0. if (PR_SUCCESS != PR_SetNetAddr(PR_IpAddrNull, addr.raw.family, port, &addr)) { err_ = true; MOZ_ASSERT(false, "Failed to set port in PRNetAddr"); return NS_OK; } } nsAutoPtr<DataBuffer> buf(new DataBuffer(data, data_length)); RefPtr<nr_udp_message> msg(new nr_udp_message(addr, buf)); RUN_ON_THREAD(sts_thread_, mozilla::WrapRunnable(nsRefPtr<NrSocketIpc>(this), &NrSocketIpc::recv_callback_s, msg), NS_DISPATCH_NORMAL); return NS_OK; }
char *dns_ip2host(const char *ip, int verify) { PRNetAddr iaddr; PRHostEnt *hptr; char *hn; #ifdef DNS_CACHE dns_cache_entry_t *dns_entry; #endif unsigned long laddr = 0; char myhostname[256]; PRHostEnt hent; char buf[PR_AR_MAXHOSTENTBUF]; PRInt32 err; if (PR_StringToNetAddr(ip, &iaddr) == PR_FAILURE) goto bong; #ifdef DNS_CACHE if ( (dns_entry = dns_cache_lookup_ip((unsigned int)iaddr.inet.ip)) ) { hn = NULL; if ( dns_entry->host && /* Only use entry if the cache entry has been verified or if * verify is off... */ (dns_entry->verified || !verify) ) { hn = STRDUP( dns_entry->host ); (void)dns_cache_use_decrement(dns_entry); return hn; } dns_cache_delete(dns_entry); dns_entry = 0; } #endif /* * See if it happens to be the localhost IP address, and try * the local host name if so. */ if (laddr == 0) { laddr = inet_addr("127.0.0.1"); myhostname[0] = 0; gethostname(myhostname, sizeof(myhostname)); } /* Have to match the localhost IP address and have a hostname */ if (((unsigned long)iaddr.inet.ip == laddr) && (myhostname[0] != 0)) { /* * Now try for a fully-qualified domain name, starting with * the local hostname. */ if (PR_AR_GetHostByName(myhostname, buf, PR_AR_MAXHOSTENTBUF, &hent, PR_AR_DEFAULT_TIMEOUT, AF_INET) == PR_AR_OK) { hptr = &hent; } else { hptr = 0; } /* Don't verify if we get a fully-qualified name this way */ verify = 0; } else { if (PR_AR_GetHostByAddr(&iaddr, buf, PR_AR_MAXHOSTENTBUF, &hent, PR_AR_DEFAULT_TIMEOUT) == PR_AR_OK) { hptr = &hent; } else { hptr = 0; } } if ((!hptr) || !(hn = net_find_fqdn(hptr))) goto bong; if(verify) { char **haddr = 0; if (PR_AR_GetHostByName(hn, buf, PR_AR_MAXHOSTENTBUF, &hent, PR_AR_DEFAULT_TIMEOUT, AF_INET) == PR_AR_OK) { hptr = &hent; } else { hptr = 0; } if(hptr) { for(haddr = hptr->h_addr_list; *haddr; haddr++) { if(((struct in_addr *)(*haddr))->s_addr == (unsigned long)iaddr.inet.ip) break; } } if((!hptr) || (!(*haddr))) goto bong; } #ifdef DNS_CACHE if ( (dns_entry = dns_cache_insert(hn, (unsigned int)iaddr.inet.ip, verify)) ) { (void) dns_cache_use_decrement(dns_entry); } #endif /* DNS_CACHE */ return hn; bong: #ifdef DNS_CACHE /* Insert the lookup failure */ if ( (dns_entry = dns_cache_insert(NULL, (unsigned int)iaddr.inet.ip, verify)) ) { (void) dns_cache_use_decrement(dns_entry); } #endif /* DNS_CACHE */ return NULL; }
/* * parseIp * This functions takes the IP address and netmask as set in ACL file * and converts them into PRNetAddr. Returns the type of address found or * LAS_EVAL_INVALID on error. * Input : * char *iIP : input ip address string * char *iNetmask : input netmask string * Output : * pointer to PRNetAddr IP Address * pointer to PRNetAddr netmask * Returns int * if IP Address passed is : * "*" - returns (PR_AF_INET + PR_AF_INET6) * a valid IPv4 address - returns PR_AF_INET * a valid IPv6 address - returns PR_AF_INET6 * if error returns LAS_EVAL_* codes */ int parseIp(char *iIP, char* iNetmask, PRNetAddr *pIP, PRNetAddr *pNetmask) { // Must not be null and MUST only have 0123456789.*:abcdefABCDEF characters if (iIP == NULL || strcspn(iIP, "0123456789.*:abcdefABCDEF/")) { ereport(LOG_VERBOSE, "ERROR Invalid IP Address %s.", iIP); return LAS_EVAL_INVALID; } // ip=* if (!strcmp(iIP,"*")) return (PR_AF_INET + PR_AF_INET6); int hasdot =0; if (strchr(iIP, '.')) hasdot=1; int hascolon=0; if (strchr(iIP, ':')) hascolon=1; if (!hasdot && !hascolon) { ereport(LOG_VERBOSE, "ERROR Invalid IP Address %s. MUST have either ':' or a '.'.", iIP); return LAS_EVAL_INVALID; } // Do not modify the original input string char ip[1024]; strcpy(ip,iIP); int prefix_length=-1; if (strchr(ip, '/')) { if (strchr(ip, '*')) { // ip=*/digits ereport(LOG_VERBOSE, "ERROR Invalid IP Address %s. Can not have * and / both", iIP); return LAS_EVAL_INVALID; } prefix_length = separateIpAndNetmaskPrefixLength(ip, hasdot?32:128); if (prefix_length == LAS_EVAL_INVALID) { return LAS_EVAL_INVALID; } } int wildcardPos=-1; if (strchr(ip, '*')) { if (hasdot) wildcardPos = handleIPv4Wildcard(ip); else wildcardPos = handleIPv6Wildcard(ip); if (wildcardPos == LAS_EVAL_INVALID) { return LAS_EVAL_INVALID; } } PRStatus status = PR_StringToNetAddr(ip, pIP); if (status != PR_SUCCESS) { ereport(LOG_VERBOSE, "ERROR Invalid IP Address %s.", ip); return LAS_EVAL_INVALID; } if (pIP->raw.family == PR_AF_INET6) convertToIPv4NetAddr(pIP, pIP); // Netmask Routines // Wildcards in the ip override the netmask where they conflict. if (wildcardPos != -1) { setNetmaskBits(pNetmask, wildcardPos, (pIP->raw.family == PR_AF_INET6)?128:32); } else if (prefix_length != -1) { setNetmaskBits(pNetmask, prefix_length, hascolon?128:32); } else if (iNetmask) { if (PR_StringToNetAddr(iNetmask, pNetmask) != PR_SUCCESS) { int err1 = PR_GetError(); /* NSPR issue PR_StringToNetAddr(255.255.255.255) is not a valid */ if (err1 == PR_INVALID_ARGUMENT_ERROR && !strcmp(iNetmask,ALL_255_IPV4)) { setNetmaskBits(pNetmask,32,32); } else if (err1 == PR_INVALID_ARGUMENT_ERROR && !strcasecmp(iNetmask,ALL_F_IPV6)) { setNetmaskBits(pNetmask,128,128); } else { ereport(LOG_VERBOSE, "ERROR Invalid netmask %s.", iNetmask); return LAS_EVAL_INVALID; } } // != PR_SUCCESS } else { // equivalent to setting "255.255.255.255" // or setting "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff" setNetmaskBits(pNetmask, (pIP->raw.family == PR_AF_INET6)?128:32, (pIP->raw.family == PR_AF_INET6)?128:32); } // if ip address passed is "::123.45.67.89/96" // convert netmask into 32 bit netmask also. if (pIP->raw.family == PR_AF_INET && pNetmask->raw.family == PR_AF_INET6) { convertIPv6NetmaskToIPv4(pNetmask, pNetmask); } else if (pIP->raw.family == PR_AF_INET6 && pNetmask->raw.family == PR_AF_INET) { ereport(LOG_VERBOSE, "ERROR Invalid netmask in %s. IPv6 Address should NOT have IPv4 Netmask.", iIP); return LAS_EVAL_INVALID; } PR_ASSERT(pIP->raw.family == PR_AF_INET || pIP->raw.family == PR_AF_INET6); return (pIP->raw.family); }
nsresult UDPSocketParent::BindInternal(const nsCString& aHost, const uint16_t& aPort, const bool& aAddressReuse, const bool& aLoopback, const uint32_t& recvBufferSize, const uint32_t& sendBufferSize) { nsresult rv; UDPSOCKET_LOG(("%s: [this=%p] %s:%u addressReuse: %d loopback: %d recvBufferSize: %lu, sendBufferSize: %lu", __FUNCTION__, this, nsCString(aHost).get(), aPort, aAddressReuse, aLoopback, recvBufferSize, sendBufferSize)); nsCOMPtr<nsIUDPSocket> sock = do_CreateInstance("@mozilla.org/network/udp-socket;1", &rv); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } if (aHost.IsEmpty()) { rv = sock->Init(aPort, false, mPrincipal, aAddressReuse, /* optional_argc = */ 1); } else { PRNetAddr prAddr; PR_InitializeNetAddr(PR_IpAddrAny, aPort, &prAddr); PRStatus status = PR_StringToNetAddr(aHost.BeginReading(), &prAddr); if (status != PR_SUCCESS) { return NS_ERROR_FAILURE; } mozilla::net::NetAddr addr; PRNetAddrToNetAddr(&prAddr, &addr); rv = sock->InitWithAddress(&addr, mPrincipal, aAddressReuse, /* optional_argc = */ 1); } if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } nsCOMPtr<nsINetAddr> laddr; rv = sock->GetLocalAddr(getter_AddRefs(laddr)); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } uint16_t family; rv = laddr->GetFamily(&family); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } if (family == nsINetAddr::FAMILY_INET) { rv = sock->SetMulticastLoopback(aLoopback); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } } // TODO: once bug 1252759 is fixed query buffer first and only increase if (recvBufferSize != 0) { rv = sock->SetRecvBufferSize(recvBufferSize); if (NS_WARN_IF(NS_FAILED(rv))) { UDPSOCKET_LOG(("%s: [this=%p] %s:%u failed to set recv buffer size to: %lu", __FUNCTION__, this, nsCString(aHost).get(), aPort, recvBufferSize)); } } if (sendBufferSize != 0) { rv = sock->SetSendBufferSize(sendBufferSize); if (NS_WARN_IF(NS_FAILED(rv))) { UDPSOCKET_LOG(("%s: [this=%p] %s:%u failed to set send buffer size to: %lu", __FUNCTION__, this, nsCString(aHost).get(), aPort, sendBufferSize)); } } // register listener rv = sock->AsyncListen(this); if (NS_WARN_IF(NS_FAILED(rv))) { return rv; } mSocket = sock; return NS_OK; }
static bool HostIsIPAddress(const char *hostname) { PRNetAddr hostAddr; return (PR_StringToNetAddr(hostname, &hostAddr) == PR_SUCCESS); }
char *dns_ip2host(char *ip, int verify) { PRNetAddr iaddr; PRHostEnt* hptr = NULL; char* hn = NULL; unsigned long laddr = 0; char myhostname[256]; PRHostEnt hent; char buf[PR_AR_MAXHOSTENTBUF]; PRInt32 err = 0; if (PR_StringToNetAddr(ip, &iaddr) == PR_FAILURE) goto bong; /* * See if it happens to be the localhost IP address, and try * the local host name if so. */ if (laddr == 0) { laddr = inet_addr("127.0.0.1"); myhostname[0] = 0; gethostname(myhostname, sizeof(myhostname)); } /* Have to match the localhost IP address and have a hostname */ if (((unsigned long)iaddr.inet.ip == laddr) && (myhostname[0] != 0)) { /* * Now try for a fully-qualified domain name, starting with * the local hostname. */ if (PR_AR_GetHostByName(myhostname, buf, PR_AR_MAXHOSTENTBUF, &hent, PR_AR_DEFAULT_TIMEOUT, AF_INET) == PR_AR_OK) { hptr = &hent; } else { hptr = 0; } /* Don't verify if we get a fully-qualified name this way */ verify = 0; } else { if (PR_AR_GetHostByAddr(&iaddr, buf, PR_AR_MAXHOSTENTBUF, &hent, PR_AR_DEFAULT_TIMEOUT) == PR_AR_OK) { hptr = &hent; } else { hptr = 0; } } if ((!hptr) || !(hn = net_find_fqdn(hptr))) goto bong; if(verify) { char **haddr = 0; if (PR_AR_GetHostByName(hn, buf, PR_AR_MAXHOSTENTBUF, &hent, PR_AR_DEFAULT_TIMEOUT, AF_INET) == PR_AR_OK) { hptr = &hent; } else { hptr = 0; } if(hptr) { for(haddr = hptr->h_addr_list; *haddr; haddr++) { if(((struct in_addr *)(*haddr))->s_addr == (unsigned long)iaddr.inet.ip) break; } } if((!hptr) || (!(*haddr))) goto bong; } return hn; bong: return NULL; }
PRIntn main(PRIntn argc, char **argv) { PRStatus rv; PRIntn mits; PLOptStatus os; PRFileDesc *client, *service; PRFileDesc *client_stack, *service_stack; PRNetAddr any_address; const char *server_name = NULL; const PRIOMethods *stubMethods; PRThread *client_thread, *server_thread; PRThreadScope thread_scope = PR_LOCAL_THREAD; PLOptState *opt = PL_CreateOptState(argc, argv, "dqGC:c:p:"); while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) { if (PL_OPT_BAD == os) continue; switch (opt->option) { case 0: server_name = opt->value; break; case 'd': /* debug mode */ if (verbosity < noisy) verbosity = ChangeVerbosity(verbosity, 1); break; case 'q': /* debug mode */ if (verbosity > silent) verbosity = ChangeVerbosity(verbosity, -1); break; case 'G': /* use global threads */ thread_scope = PR_GLOBAL_THREAD; break; case 'C': /* number of threads waiting */ major_iterations = atoi(opt->value); break; case 'c': /* number of client threads */ minor_iterations = atoi(opt->value); break; case 'p': /* default port */ default_port = atoi(opt->value); break; default: break; } } PL_DestroyOptState(opt); PR_STDIO_INIT(); logFile = PR_GetSpecialFD(PR_StandardError); identity = PR_GetUniqueIdentity("Dummy"); stubMethods = PR_GetDefaultIOMethods(); /* ** The protocol we're going to implement is one where in order to initiate ** a send, the sender must first solicit permission. Therefore, every ** send is really a send - receive - send sequence. */ myMethods = *stubMethods; /* first get the entire batch */ myMethods.recv = MyRecv; /* then override the ones we care about */ myMethods.send = MySend; /* then override the ones we care about */ if (NULL == server_name) rv = PR_InitializeNetAddr( PR_IpAddrLoopback, default_port, &server_address); else { rv = PR_StringToNetAddr(server_name, &server_address); PR_ASSERT(PR_SUCCESS == rv); rv = PR_InitializeNetAddr( PR_IpAddrNull, default_port, &server_address); } PR_ASSERT(PR_SUCCESS == rv); /* one type w/o layering */ mits = minor_iterations; while (major_iterations-- > 0) { if (verbosity > silent) PR_fprintf(logFile, "Beginning non-layered test\n"); client = PR_NewTCPSocket(); PR_ASSERT(NULL != client); service = PR_NewTCPSocket(); PR_ASSERT(NULL != service); rv = PR_InitializeNetAddr(PR_IpAddrAny, default_port, &any_address); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Bind(service, &any_address); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Listen(service, 10); PR_ASSERT(PR_SUCCESS == rv); minor_iterations = mits; server_thread = PR_CreateThread( PR_USER_THREAD, Server, service, PR_PRIORITY_HIGH, thread_scope, PR_JOINABLE_THREAD, 16 * 1024); PR_ASSERT(NULL != server_thread); client_thread = PR_CreateThread( PR_USER_THREAD, Client, client, PR_PRIORITY_NORMAL, thread_scope, PR_JOINABLE_THREAD, 16 * 1024); PR_ASSERT(NULL != client_thread); rv = PR_JoinThread(client_thread); PR_ASSERT(PR_SUCCESS == rv); rv = PR_JoinThread(server_thread); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Close(client); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Close(service); PR_ASSERT(PR_SUCCESS == rv); if (verbosity > silent) PR_fprintf(logFile, "Ending non-layered test\n"); /* with layering */ if (verbosity > silent) PR_fprintf(logFile, "Beginning layered test\n"); client = PR_NewTCPSocket(); PR_ASSERT(NULL != client); PushLayer(client); service = PR_NewTCPSocket(); PR_ASSERT(NULL != service); PushLayer(service); rv = PR_InitializeNetAddr(PR_IpAddrAny, default_port, &any_address); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Bind(service, &any_address); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Listen(service, 10); PR_ASSERT(PR_SUCCESS == rv); minor_iterations = mits; server_thread = PR_CreateThread( PR_USER_THREAD, Server, service, PR_PRIORITY_HIGH, thread_scope, PR_JOINABLE_THREAD, 16 * 1024); PR_ASSERT(NULL != server_thread); client_thread = PR_CreateThread( PR_USER_THREAD, Client, client, PR_PRIORITY_NORMAL, thread_scope, PR_JOINABLE_THREAD, 16 * 1024); PR_ASSERT(NULL != client_thread); rv = PR_JoinThread(client_thread); PR_ASSERT(PR_SUCCESS == rv); rv = PR_JoinThread(server_thread); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Close(client); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Close(service); PR_ASSERT(PR_SUCCESS == rv); /* with layering, using new style stack */ if (verbosity > silent) PR_fprintf(logFile, "Beginning layered test with new style stack\n"); client = PR_NewTCPSocket(); PR_ASSERT(NULL != client); client_stack = PR_CreateIOLayer(client); PushNewLayers(client_stack); service = PR_NewTCPSocket(); PR_ASSERT(NULL != service); service_stack = PR_CreateIOLayer(service); PushNewLayers(service_stack); rv = PR_InitializeNetAddr(PR_IpAddrAny, default_port, &any_address); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Bind(service, &any_address); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Listen(service, 10); PR_ASSERT(PR_SUCCESS == rv); minor_iterations = mits; server_thread = PR_CreateThread( PR_USER_THREAD, Server, service_stack, PR_PRIORITY_HIGH, thread_scope, PR_JOINABLE_THREAD, 16 * 1024); PR_ASSERT(NULL != server_thread); client_thread = PR_CreateThread( PR_USER_THREAD, Client, client_stack, PR_PRIORITY_NORMAL, thread_scope, PR_JOINABLE_THREAD, 16 * 1024); PR_ASSERT(NULL != client_thread); rv = PR_JoinThread(client_thread); PR_ASSERT(PR_SUCCESS == rv); rv = PR_JoinThread(server_thread); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Close(client_stack); PR_ASSERT(PR_SUCCESS == rv); rv = PR_Close(service_stack); PR_ASSERT(PR_SUCCESS == rv); if (verbosity > silent) PR_fprintf(logFile, "Ending layered test\n"); } return 0; } /* main */
int main(int argc, char **argv) #endif { const char *hostName = DEFAULT_HOST_NAME; PRHostEnt he, reversehe; char buf[PR_NETDB_BUF_SIZE]; char reversebuf[PR_NETDB_BUF_SIZE]; PRIntn idx; PRNetAddr addr; PLOptStatus os; PLOptState *opt = PL_CreateOptState(argc, argv, "h"); while (PL_OPT_EOL != (os = PL_GetNextOpt(opt))) { if (PL_OPT_BAD == os) continue; switch (opt->option) { case 0: /* naked */ hostName = opt->value; break; case 'h': /* Help message */ default: Help(); return 2; } } PL_DestroyOptState(opt); PR_STDIO_INIT(); outFile = PR_GetSpecialFD(PR_StandardError); if (PR_GetHostByName(hostName, buf, sizeof(buf), &he) == PR_FAILURE) { PR_fprintf(outFile, "PR_GetHostByName failed\n"); exit(1); } PrintHostent(&he); idx = 0; while (1) { idx = PR_EnumerateHostEnt(idx, &he, 0, &addr); if (idx == -1) { PR_fprintf(outFile, "PR_EnumerateHostEnt failed\n"); exit(1); } if (idx == 0) break; /* normal loop termination */ PR_fprintf(outFile, "reverse lookup\n"); if (PR_GetHostByAddr(&addr, reversebuf, sizeof(reversebuf), &reversehe) == PR_FAILURE) { PR_fprintf(outFile, "PR_GetHostByAddr failed\n"); exit(1); } PrintHostent(&reversehe); } PR_fprintf(outFile, "PR_GetIPNodeByName with PR_AF_INET\n"); if (PR_GetIPNodeByName(hostName, PR_AF_INET, PR_AI_DEFAULT, buf, sizeof(buf), &he) == PR_FAILURE) { PR_fprintf(outFile, "PR_GetIPNodeByName failed\n"); exit(1); } PrintHostent(&he); PR_fprintf(outFile, "PR_GetIPNodeByName with PR_AF_INET6\n"); if (PR_GetIPNodeByName(hostName, PR_AF_INET6, PR_AI_DEFAULT, buf, sizeof(buf), &he) == PR_FAILURE) { PR_fprintf(outFile, "PR_GetIPNodeByName failed\n"); exit(1); } PrintHostent(&he); idx = 0; PR_fprintf(outFile, "PR_GetHostByAddr with PR_AF_INET6\n"); while (1) { idx = PR_EnumerateHostEnt(idx, &he, 0, &addr); if (idx == -1) { PR_fprintf(outFile, "PR_EnumerateHostEnt failed\n"); exit(1); } if (idx == 0) break; /* normal loop termination */ PR_fprintf(outFile, "reverse lookup\n"); if (PR_GetHostByAddr(&addr, reversebuf, sizeof(reversebuf), &reversehe) == PR_FAILURE) { PR_fprintf(outFile, "PR_GetHostByAddr failed\n"); exit(1); } PrintHostent(&reversehe); } PR_fprintf(outFile, "PR_GetHostByAddr with PR_AF_INET6 done\n"); PR_StringToNetAddr("::1", &addr); if (PR_IsNetAddrType(&addr, PR_IpAddrV4Mapped) == PR_TRUE) { PR_fprintf(outFile, "addr should not be ipv4 mapped address\n"); exit(1); } if (PR_IsNetAddrType(&addr, PR_IpAddrLoopback) == PR_FALSE) { PR_fprintf(outFile, "addr should be loopback address\n"); exit(1); } PR_StringToNetAddr("127.0.0.1", &addr); if (PR_IsNetAddrType(&addr, PR_IpAddrLoopback) == PR_FALSE) { PR_fprintf(outFile, "addr should be loopback address\n"); exit(1); } PR_StringToNetAddr("::FFFF:127.0.0.1", &addr); if (PR_IsNetAddrType(&addr, PR_IpAddrV4Mapped) == PR_FALSE) { PR_fprintf(outFile, "addr should be ipv4 mapped address\n"); exit(1); } if (PR_IsNetAddrType(&addr, PR_IpAddrLoopback) == PR_FALSE) { PR_fprintf(outFile, "addr should be loopback address\n"); exit(1); } if (PR_InitializeNetAddr(PR_IpAddrAny, 0, &addr) == PR_FAILURE) { PR_fprintf(outFile, "PR_InitializeNetAddr failed\n"); exit(1); } if (PR_IsNetAddrType(&addr, PR_IpAddrAny) == PR_FALSE) { PR_fprintf(outFile, "addr should be unspecified address\n"); exit(1); } if (PR_InitializeNetAddr(PR_IpAddrLoopback, 0, &addr) == PR_FAILURE) { PR_fprintf(outFile, "PR_InitializeNetAddr failed\n"); exit(1); } if (PR_IsNetAddrType(&addr, PR_IpAddrLoopback) == PR_FALSE) { PR_fprintf(outFile, "addr should be loopback address\n"); exit(1); } if (PR_SetNetAddr(PR_IpAddrAny, PR_AF_INET, 0, &addr) == PR_FAILURE) { PR_fprintf(outFile, "PR_SetNetAddr failed\n"); exit(1); } if (PR_IsNetAddrType(&addr, PR_IpAddrAny) == PR_FALSE) { PR_fprintf(outFile, "addr should be unspecified address\n"); exit(1); } if (PR_SetNetAddr(PR_IpAddrLoopback, PR_AF_INET, 0, &addr) == PR_FAILURE) { PR_fprintf(outFile, "PR_SetNetAddr failed\n"); exit(1); } if (PR_IsNetAddrType(&addr, PR_IpAddrLoopback) == PR_FALSE) { PR_fprintf(outFile, "addr should be loopback address\n"); exit(1); } addr.inet.family = PR_AF_INET; addr.inet.port = 0; addr.inet.ip = PR_htonl(PR_INADDR_ANY); if (PR_IsNetAddrType(&addr, PR_IpAddrAny) == PR_FALSE) { PR_fprintf(outFile, "addr should be unspecified address\n"); exit(1); } { char buf[256]; PR_NetAddrToString(&addr, buf, 256); PR_fprintf(outFile, "IPv4 INADDRANY: %s\n", buf); } addr.inet.family = PR_AF_INET; addr.inet.port = 0; addr.inet.ip = PR_htonl(PR_INADDR_LOOPBACK); if (PR_IsNetAddrType(&addr, PR_IpAddrLoopback) == PR_FALSE) { PR_fprintf(outFile, "addr should be loopback address\n"); exit(1); } { char buf[256]; PR_NetAddrToString(&addr, buf, 256); PR_fprintf(outFile, "IPv4 LOOPBACK: %s\n", buf); } if (PR_SetNetAddr(PR_IpAddrAny, PR_AF_INET6, 0, &addr) == PR_FAILURE) { PR_fprintf(outFile, "PR_SetNetAddr failed\n"); exit(1); } if (PR_IsNetAddrType(&addr, PR_IpAddrAny) == PR_FALSE) { PR_fprintf(outFile, "addr should be unspecified address\n"); exit(1); } { char buf[256]; PR_NetAddrToString(&addr, buf, 256); PR_fprintf(outFile, "IPv6 INADDRANY: %s\n", buf); } if (PR_SetNetAddr(PR_IpAddrLoopback, PR_AF_INET6, 0, &addr) == PR_FAILURE) { PR_fprintf(outFile, "PR_SetNetAddr failed\n"); exit(1); } if (PR_IsNetAddrType(&addr, PR_IpAddrLoopback) == PR_FALSE) { PR_fprintf(outFile, "addr should be loopback address\n"); exit(1); } { char buf[256]; PR_NetAddrToString(&addr, buf, 256); PR_fprintf(outFile, "IPv6 LOOPBACK: %s\n", buf); } { PRIPv6Addr v6addr; char tmp_buf[256]; PR_SetNetAddr(PR_IpAddrLoopback, PR_AF_INET, 0, &addr); PR_ConvertIPv4AddrToIPv6(addr.inet.ip, &v6addr); PR_SetNetAddr(PR_IpAddrAny, PR_AF_INET6, 0, &addr); addr.ipv6.ip = v6addr; PR_NetAddrToString(&addr, tmp_buf, 256); PR_fprintf(outFile, "IPv4-mapped IPv6 LOOPBACK: %s\n", tmp_buf); } PR_fprintf(outFile, "PASS\n"); return 0; }
nsresult UDPSocket::InitLocal(const nsAString& aLocalAddress, const uint16_t& aLocalPort) { nsresult rv; nsCOMPtr<nsIUDPSocket> sock = do_CreateInstance("@mozilla.org/network/udp-socket;1", &rv); if (NS_FAILED(rv)) { return rv; } nsCOMPtr<nsIGlobalObject> global = do_QueryInterface(GetOwner(), &rv); if (NS_FAILED(rv)) { return rv; } nsCOMPtr<nsIPrincipal> principal = global->PrincipalOrNull(); if (!principal) { return NS_ERROR_FAILURE; } if (aLocalAddress.IsEmpty()) { rv = sock->Init(aLocalPort, /* loopback = */ false, principal, mAddressReuse, /* optionalArgc = */ 1); } else { PRNetAddr prAddr; PR_InitializeNetAddr(PR_IpAddrAny, aLocalPort, &prAddr); PR_StringToNetAddr(NS_ConvertUTF16toUTF8(aLocalAddress).BeginReading(), &prAddr); UDPSOCKET_LOG(("%s: %s:%u", __FUNCTION__, NS_ConvertUTF16toUTF8(aLocalAddress).get(), aLocalPort)); mozilla::net::NetAddr addr; PRNetAddrToNetAddr(&prAddr, &addr); rv = sock->InitWithAddress(&addr, principal, mAddressReuse, /* optionalArgc = */ 1); } if (NS_FAILED(rv)) { return rv; } rv = sock->SetMulticastLoopback(mLoopback); if (NS_FAILED(rv)) { return rv; } mSocket = sock; // Get real local address and local port nsCOMPtr<nsINetAddr> localAddr; rv = mSocket->GetLocalAddr(getter_AddRefs(localAddr)); if (NS_FAILED(rv)) { return rv; } nsCString localAddress; rv = localAddr->GetAddress(localAddress); if (NS_FAILED(rv)) { return rv; } mLocalAddress = NS_ConvertUTF8toUTF16(localAddress); uint16_t localPort; rv = localAddr->GetPort(&localPort); if (NS_FAILED(rv)) { return rv; } mLocalPort.SetValue(localPort); mListenerProxy = new ListenerProxy(this); rv = mSocket->AsyncListen(mListenerProxy); if (NS_FAILED(rv)) { return rv; } mReadyState = SocketReadyState::Open; rv = DoPendingMcastCommand(); if (NS_FAILED(rv)) { return rv; } mOpened->MaybeResolve(JS::UndefinedHandleValue); return NS_OK; }
int FileSSL_main(int argc, char * argv[]) { bool isServer = true; SECStatus rv = SECSuccess; char buffer[32] = {0}; PR_Init(PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 1); PK11_SetPasswordFunc(GetModulePassword); rv = NSS_Initialize(GetSystemDBDir(), "", "", "secmod.db", 0); rv = SSL_OptionSetDefault(SSL_SECURITY, PR_TRUE); rv = SSL_OptionSetDefault(SSL_SOCKS, PR_TRUE); rv = SSL_OptionSetDefault(SSL_ENABLE_SSL2, PR_TRUE); rv = SSL_OptionSetDefault(SSL_ENABLE_SSL3, PR_TRUE); rv = SSL_OptionSetDefault(SSL_ENABLE_FDX, PR_TRUE); rv = SSL_OptionSetDefault(SSL_ENABLE_TLS, PR_TRUE); rv = NSS_SetDomesticPolicy(); rv = NSS_SetExportPolicy(); rv = NSS_SetFrancePolicy(); // rv = SSL_CipherPolicySet(); SSL_ClearSessionCache(); rv = SSL_ConfigServerSessionIDCache(10, 30 , 30, "."); PRFileDesc * socket = PR_NewTCPSocket(); socket = SSL_ImportFD(NULL,socket); if (isServer) { CERTCertDBHandle *certHandle; certHandle = CERT_GetDefaultCertDB(); char * nickname = "itrus Certificate DB:2013-11-15 12:44:10";/*nickname*/ CERTCertificate* cert = NULL; cert = CERT_FindCertByNicknameOrEmailAddr(certHandle, nickname); SECKEYPrivateKey *prvKey = NULL; prvKey = PK11_FindKeyByAnyCert(cert, NULL); rv = SSL_ConfigSecureServer(socket, cert,prvKey,ssl_kea_rsa); PRNetAddr netAddr; PRNetAddr netAddrLocal; rv = PR_InitializeNetAddr(0, 8888, &netAddr); rv = PR_StringToNetAddr("127.0.0.1", &netAddrLocal); rv = PR_Bind(socket,&netAddr); rv = PR_Listen(socket, 100); while (1) { PRFileDesc * client = PR_Accept(socket, &netAddr, 6000000); PRNetAddr addr; rv = PR_GetSockName(client, &addr); rv = SSL_ForceHandshake(client); rv = PR_Write(client,"123", 4); sleep(1); } } else { rv = SSL_SetURL(socket, "127.0.0.1"); PRNetAddr netAddr; PRNetAddr netAddrLocal; rv = PR_InitializeNetAddr(0, 8888, &netAddr); rv = PR_StringToNetAddr("127.0.0.1", &netAddrLocal); // rv = PR_GetHostByName(); // PR_EnumerateHostEnt rv = PR_Connect(socket,&netAddr, 300000); rv = SSL_AuthCertificateHook(socket, OwnAuthCertHandler, NULL); rv = SSL_ForceHandshake(socket); while (1) { rv = PR_Read(socket,buffer, 32); sleep(1); } } return 0; }
int FileSSLDoublePoint_main(char * strUserPin, char * strNickName) { #if 1 int isServer = 0; SECStatus rv = SECSuccess; char * buffer = malloc(1024 * 1024); PR_Init(PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 1); PK11_SetPasswordFunc(GetModulePassword); rv = NSS_Initialize(GetSystemDBDir(), "", "", "secmod.db", 0); rv = SSL_OptionSetDefault(SSL_SECURITY, PR_TRUE); rv = SSL_OptionSetDefault(SSL_SOCKS, PR_TRUE); rv = SSL_OptionSetDefault(SSL_ENABLE_SSL2, PR_TRUE); rv = SSL_OptionSetDefault(SSL_ENABLE_SSL3, PR_TRUE); rv = SSL_OptionSetDefault(SSL_ENABLE_FDX, PR_TRUE); rv = SSL_OptionSetDefault(SSL_ENABLE_TLS, PR_TRUE); rv = NSS_SetDomesticPolicy(); rv = NSS_SetExportPolicy(); rv = NSS_SetFrancePolicy(); // rv = SSL_CipherPolicySet(); SSL_ClearSessionCache(); rv = SSL_ConfigServerSessionIDCache(10, 30 , 30, "."); PRFileDesc * tcp_socket = PR_NewTCPSocket(); PRFileDesc * ssl_socket = SSL_ImportFD(NULL,tcp_socket); if (isServer) { CERTCertDBHandle *certHandle; certHandle = CERT_GetDefaultCertDB(); char * nickname = "4914afeedee988071490b98f1120ddac_e73f20c7-176d-4342-ac89-ea7c00bb570a";/*nickname*/ CERTCertificate* cert = NULL; cert = CERT_FindCertByNicknameOrEmailAddr(certHandle, nickname); SECKEYPrivateKey *prvKey = NULL; prvKey = PK11_FindKeyByAnyCert(cert, NULL); rv = SSL_ConfigSecureServer(ssl_socket, cert,prvKey,ssl_kea_rsa); PRNetAddr netAddr; PRNetAddr netAddrLocal; rv = PR_InitializeNetAddr(0, 8888, &netAddr); rv = PR_StringToNetAddr("127.0.0.1", &netAddrLocal); rv = PR_Bind(tcp_socket,&netAddr); rv = PR_Listen(tcp_socket, 100); while (1) { PRFileDesc * client = PR_Accept(tcp_socket, &netAddr, 6000000); PRNetAddr addr; rv = PR_GetSockName(client, &addr); rv = SSL_ForceHandshake(client); rv = PR_Write(client,"123", 4); sleep(1); } } else { rv = SSL_AuthCertificateHook(ssl_socket, OwnAuthCertHandler, NULL); char * nickname = "nickname";/*nickname*/ rv = SSL_SetURL(ssl_socket, "192.168.18.22"); char * str = malloc(1024) ; memset(str, 0, 1024); strcpy(str ,"GET /test/test2.html HTTP/1.1\r\n");//注意\r\n为回车换行 // str = [str stringByAppendingString:@"Accept-Language: zh-cn\r\n"]; // str = [str stringByAppendingString:@"Connection: Keep-Alive\r\n"]; //str = [str stringByAppendingString:@"Host: 192.168.0.106\r\n"]; strcat(str ,"Host: 192.168.18.22:8443\r\n"); // str = [str stringByAppendingString:@"Content-Length: 0\r\n"]; strcat(str ,"\r\n"); // str = [str stringByAppendingString:@"userName=liqiangqiang&password=new_andy\r\n"]; // str = [str stringByAppendingString:@"\r\n"]; PRNetAddr netAddr; rv = PR_StringToNetAddr("192.168.18.22", &netAddr); rv = PR_InitializeNetAddr(0, 8443, &netAddr); // rv = PR_GetHostByName(); // PR_EnumerateHostEnt rv = PR_Connect(tcp_socket,&netAddr, 300000); FILE_LOG_NUMBER("/sdcard/ssl.log", rv); rv = SSL_GetClientAuthDataHook(ssl_socket,NSS_GetClientAuthData,strNickName); FILE_LOG_NUMBER("/sdcard/ssl.log", rv); rv = SSL_ForceHandshake(ssl_socket); FILE_LOG_NUMBER("/sdcard/ssl.log", rv); rv = PR_Write(tcp_socket, str, strlen(str)); FILE_LOG_NUMBER("/sdcard/ssl.log", rv); rv = PR_Read(tcp_socket,buffer, 1024 * 1024); FILE_LOG_NUMBER("/sdcard/ssl.log", rv); FILE * file = fopen("/sdcard/ssl_read.txt", "wb"); //fwrite(buffer, 1, rv, file); //rv = PR_Read(tcp_socket,buffer, 1024 * 1024); fwrite(buffer, 1, rv, file); fclose(file); sleep(1); rv = SSL_InvalidateSession(ssl_socket); rv = PR_Shutdown(tcp_socket, PR_SHUTDOWN_BOTH); rv = PR_Close(tcp_socket); rv = ssl_FreeSessionCacheLocks(); rv = NSS_Shutdown(); } #endif return 0; }
/* static */ nsresult sbURIChecker::CheckDomain( nsACString &aDomain, nsIURI *aSiteURI ) { NS_ENSURE_ARG_POINTER(aSiteURI); LOG(( "sbURIChecker::CheckDomain(%s)", aDomain.BeginReading() )); // get host from URI nsCString host; nsresult rv = aSiteURI->GetHost(host); NS_ENSURE_SUCCESS( rv, rv ); nsCString fixedHost; rv = sbURIChecker::FixupDomain( host, fixedHost ); NS_ENSURE_SUCCESS( rv, rv ); host.Assign(fixedHost); if ( !aDomain.IsEmpty() ) { LOG(("sbURIChecker::CheckDomain() -- Have a domain from the user")); // remove trailing dots, lowercase it nsCString fixedDomain; rv = sbURIChecker::FixupDomain( aDomain, fixedDomain ); NS_ENSURE_SUCCESS( rv, rv ); aDomain.Assign(fixedDomain); // Deal first with numerical ip addresses PRNetAddr addr; if ( PR_StringToNetAddr( host.get(), &addr ) == PR_SUCCESS ) { // numerical ip address LOG(("sbURIChecker::CheckDomain() -- Numerical Address ")); if ( !aDomain.Equals(host) ) { LOG(("sbURIChecker::CheckDomain() -- FAILED ip address check")); return NS_ERROR_FAILURE; } } else { // domain based host, check it against host from URI LOG(("sbURIChecker::CheckDomain() -- Domain based host ")); // make sure the domain wasn't '.com' - it should have a dot in it // we need to skip this check if the host is localhost PRInt32 dot = aDomain.FindChar('.'); if ( dot < 0 && !host.Equals("localhost")) { LOG(("sbURIChecker::CheckDomain() -- FAILED dot test ")); return NS_ERROR_FAILURE; } // prepend a dot so bar.com doesn't match foobar.com but does foo.bar.com aDomain.Insert( NS_LITERAL_CSTRING("."), 0 ); PRInt32 domainLength = aDomain.Length(); PRInt32 lengthDiff = host.Length() - domainLength; if ( lengthDiff == -1 ) { LOG(("sbURIChecker::CheckDomain() -- long domain check")); // special case: from user: .bar.com vs. from URI: bar.com // XXXredfive - I actually think we'll see this most often because // of the prepending of the dot to the user supplied domain if ( !StringEndsWith(aDomain, host) ) { LOG(("sbURIChecker::CheckDomain() -- FAILED long domain check")); return NS_ERROR_FAILURE; } } else if ( lengthDiff == 0 ) { LOG(("sbURIChecker::CheckDomain() -- same length check")); // same length better be the same strings if ( !aDomain.Equals(host) ) { LOG(("sbURIChecker::CheckDomain() -- FAILED same length check")); return NS_ERROR_FAILURE; } } else if ( lengthDiff > 0 ) { LOG(("sbURIChecker::CheckDomain() -- parent domain check")); // normal case URI host is longer that host from user // from user: .bar.com from URI: foo.bar.com if ( !StringEndsWith(host, aDomain) ) { LOG(("sbURIChecker::CheckDomain() -- FAILED parent domain check")); return NS_ERROR_FAILURE; } } else { // domains are WAY off, the user domain is more than 1 char longer than // the URI domain. ie: user: jgaunt.com URI: "" LOG(("sbURIChecker::CheckDomain() -- FAILED, user domain is superset")); return NS_ERROR_FAILURE; } // remove the leading dot we added aDomain.Cut( 0, 1 ); } } else { LOG(( "sbURIChecker::CheckDomain() -- NO domain from the user")); // If the user didn't specify a host // if the URI host is empty, make sure we're file:// if ( host.IsEmpty() ) { PRBool isFileURI; rv = aSiteURI->SchemeIs( "file", &isFileURI ); NS_ENSURE_SUCCESS( rv, rv ); if (!isFileURI) { // non-file URI without a host!!! LOG(("sbURIChecker::CheckDomain() -- FAILED file scheme check")); return NS_ERROR_FAILURE; } // clear the isVoid flag if set aDomain.Truncate(); } else { // no domain from the user but there is a domain from the URI aDomain.Assign(host); } } LOG(("sbURIChecker::CheckDomain() -- PASSED match test")); return NS_OK; }
bool TCPSocketParent::RecvOpenBind(const nsCString& aRemoteHost, const uint16_t& aRemotePort, const nsCString& aLocalAddr, const uint16_t& aLocalPort, const bool& aUseSSL, const bool& aUseArrayBuffers, const nsCString& aFilter) { if (net::UsingNeckoIPCSecurity() && !AssertAppProcessPermission(Manager()->Manager(), "tcp-socket")) { FireInteralError(this, __LINE__); return true; } nsresult rv; nsCOMPtr<nsISocketTransportService> sts = do_GetService("@mozilla.org/network/socket-transport-service;1", &rv); if (NS_FAILED(rv)) { FireInteralError(this, __LINE__); return true; } nsCOMPtr<nsISocketTransport> socketTransport; rv = sts->CreateTransport(nullptr, 0, aRemoteHost, aRemotePort, nullptr, getter_AddRefs(socketTransport)); if (NS_FAILED(rv)) { FireInteralError(this, __LINE__); return true; } PRNetAddr prAddr; if (PR_SUCCESS != PR_InitializeNetAddr(PR_IpAddrAny, aLocalPort, &prAddr)) { FireInteralError(this, __LINE__); return true; } if (PR_SUCCESS != PR_StringToNetAddr(aLocalAddr.BeginReading(), &prAddr)) { FireInteralError(this, __LINE__); return true; } mozilla::net::NetAddr addr; PRNetAddrToNetAddr(&prAddr, &addr); rv = socketTransport->Bind(&addr); if (NS_FAILED(rv)) { FireInteralError(this, __LINE__); return true; } if (!aFilter.IsEmpty()) { nsAutoCString contractId(NS_NETWORK_TCP_SOCKET_FILTER_HANDLER_PREFIX); contractId.Append(aFilter); nsCOMPtr<nsISocketFilterHandler> filterHandler = do_GetService(contractId.get()); if (!filterHandler) { NS_ERROR("Content doesn't have a valid filter"); FireInteralError(this, __LINE__); return true; } rv = filterHandler->NewFilter(getter_AddRefs(mFilter)); if (NS_FAILED(rv)) { NS_ERROR("Cannot create filter that content specified"); FireInteralError(this, __LINE__); return true; } } // Obtain App ID uint32_t appId = nsIScriptSecurityManager::NO_APP_ID; bool inIsolatedMozBrowser = false; const PContentParent *content = Manager()->Manager(); if (PBrowserParent* browser = SingleManagedOrNull(content->ManagedPBrowserParent())) { // appId's are for B2G only currently, where managees.Count() == 1 // This is not guaranteed currently in Desktop, so skip this there. TabParent *tab = TabParent::GetFrom(browser); appId = tab->OwnAppId(); inIsolatedMozBrowser = tab->IsIsolatedMozBrowserElement(); } mSocket = new TCPSocket(nullptr, NS_ConvertUTF8toUTF16(aRemoteHost), aRemotePort, aUseSSL, aUseArrayBuffers); mSocket->SetAppIdAndBrowser(appId, inIsolatedMozBrowser); mSocket->SetSocketBridgeParent(this); rv = mSocket->InitWithUnconnectedTransport(socketTransport); NS_ENSURE_SUCCESS(rv, true); return true; }
PRStatus RCNetAddr::FromString(const char* string) { return PR_StringToNetAddr(string, &address); }