Source code
Revision control
Copy as Markdown
Other Tools
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
/*
** File: pripv6.c
** Description: Support for various functions unique to IPv6
*/
#include "primpl.h"
#include <string.h>
#if !defined(_PR_INET6) || defined(_PR_INET6_PROBE)
static PRIOMethods ipv6_to_v4_tcpMethods;
static PRIOMethods ipv6_to_v4_udpMethods;
static PRDescIdentity _pr_ipv6_to_ipv4_id;
extern PRBool IsValidNetAddr(const PRNetAddr* addr);
extern const PRIPv6Addr _pr_in6addr_any;
extern const PRIPv6Addr _pr_in6addr_loopback;
/*
* convert an IPv4-mapped IPv6 addr to an IPv4 addr
*/
static void _PR_ConvertToIpv4NetAddr(const PRNetAddr* src_v6addr,
PRNetAddr* dst_v4addr) {
const PRUint8* srcp;
PR_ASSERT(PR_AF_INET6 == src_v6addr->ipv6.family);
if (PR_IsNetAddrType(src_v6addr, PR_IpAddrV4Mapped)) {
srcp = src_v6addr->ipv6.ip.pr_s6_addr;
memcpy((char*)&dst_v4addr->inet.ip, srcp + 12, 4);
} else if (PR_IsNetAddrType(src_v6addr, PR_IpAddrAny)) {
dst_v4addr->inet.ip = htonl(INADDR_ANY);
} else if (PR_IsNetAddrType(src_v6addr, PR_IpAddrLoopback)) {
dst_v4addr->inet.ip = htonl(INADDR_LOOPBACK);
}
dst_v4addr->inet.family = PR_AF_INET;
dst_v4addr->inet.port = src_v6addr->ipv6.port;
}
/*
* convert an IPv4 addr to an IPv4-mapped IPv6 addr
*/
static void _PR_ConvertToIpv6NetAddr(const PRNetAddr* src_v4addr,
PRNetAddr* dst_v6addr) {
PRUint8* dstp;
PR_ASSERT(PR_AF_INET == src_v4addr->inet.family);
dst_v6addr->ipv6.family = PR_AF_INET6;
dst_v6addr->ipv6.port = src_v4addr->inet.port;
if (htonl(INADDR_ANY) == src_v4addr->inet.ip) {
dst_v6addr->ipv6.ip = _pr_in6addr_any;
} else {
dstp = dst_v6addr->ipv6.ip.pr_s6_addr;
memset(dstp, 0, 10);
memset(dstp + 10, 0xff, 2);
memcpy(dstp + 12, (char*)&src_v4addr->inet.ip, 4);
}
}
static PRStatus PR_CALLBACK Ipv6ToIpv4SocketBind(PRFileDesc* fd,
const PRNetAddr* addr) {
PRNetAddr tmp_ipv4addr;
const PRNetAddr* tmp_addrp;
PRFileDesc* lo = fd->lower;
if (PR_AF_INET6 != addr->raw.family) {
PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, 0);
return PR_FAILURE;
}
if (PR_IsNetAddrType(addr, PR_IpAddrV4Mapped) ||
PR_IsNetAddrType(addr, PR_IpAddrAny)) {
_PR_ConvertToIpv4NetAddr(addr, &tmp_ipv4addr);
tmp_addrp = &tmp_ipv4addr;
} else {
PR_SetError(PR_NETWORK_UNREACHABLE_ERROR, 0);
return PR_FAILURE;
}
return ((lo->methods->bind)(lo, tmp_addrp));
}
static PRStatus PR_CALLBACK Ipv6ToIpv4SocketConnect(PRFileDesc* fd,
const PRNetAddr* addr,
PRIntervalTime timeout) {
PRNetAddr tmp_ipv4addr;
const PRNetAddr* tmp_addrp;
if (PR_AF_INET6 != addr->raw.family) {
PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, 0);
return PR_FAILURE;
}
if (PR_IsNetAddrType(addr, PR_IpAddrV4Mapped) ||
PR_IsNetAddrType(addr, PR_IpAddrLoopback)) {
_PR_ConvertToIpv4NetAddr(addr, &tmp_ipv4addr);
tmp_addrp = &tmp_ipv4addr;
} else {
PR_SetError(PR_NETWORK_UNREACHABLE_ERROR, 0);
return PR_FAILURE;
}
return (fd->lower->methods->connect)(fd->lower, tmp_addrp, timeout);
}
static PRInt32 PR_CALLBACK Ipv6ToIpv4SocketSendTo(PRFileDesc* fd,
const void* buf,
PRInt32 amount, PRIntn flags,
const PRNetAddr* addr,
PRIntervalTime timeout) {
PRNetAddr tmp_ipv4addr;
const PRNetAddr* tmp_addrp;
if (PR_AF_INET6 != addr->raw.family) {
PR_SetError(PR_ADDRESS_NOT_SUPPORTED_ERROR, 0);
return PR_FAILURE;
}
if (PR_IsNetAddrType(addr, PR_IpAddrV4Mapped) ||
PR_IsNetAddrType(addr, PR_IpAddrLoopback)) {
_PR_ConvertToIpv4NetAddr(addr, &tmp_ipv4addr);
tmp_addrp = &tmp_ipv4addr;
} else {
PR_SetError(PR_NETWORK_UNREACHABLE_ERROR, 0);
return PR_FAILURE;
}
return (fd->lower->methods->sendto)(fd->lower, buf, amount, flags, tmp_addrp,
timeout);
}
static PRFileDesc* PR_CALLBACK Ipv6ToIpv4SocketAccept(PRFileDesc* fd,
PRNetAddr* addr,
PRIntervalTime timeout) {
PRStatus rv;
PRFileDesc* newfd;
PRFileDesc* newstack;
PRNetAddr tmp_ipv4addr;
PRNetAddr* addrlower = NULL;
PR_ASSERT(fd != NULL);
PR_ASSERT(fd->lower != NULL);
newstack = PR_NEW(PRFileDesc);
if (NULL == newstack) {
PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
return NULL;
}
*newstack = *fd; /* make a copy of the accepting layer */
if (addr) {
addrlower = &tmp_ipv4addr;
}
newfd = (fd->lower->methods->accept)(fd->lower, addrlower, timeout);
if (NULL == newfd) {
PR_DELETE(newstack);
return NULL;
}
if (addr) {
_PR_ConvertToIpv6NetAddr(&tmp_ipv4addr, addr);
}
rv = PR_PushIOLayer(newfd, PR_TOP_IO_LAYER, newstack);
PR_ASSERT(PR_SUCCESS == rv);
return newfd; /* that's it */
}
static PRInt32 PR_CALLBACK Ipv6ToIpv4SocketAcceptRead(PRFileDesc* sd,
PRFileDesc** nd,
PRNetAddr** ipv6_raddr,
void* buf, PRInt32 amount,
PRIntervalTime timeout) {
PRInt32 nbytes;
PRStatus rv;
PRNetAddr tmp_ipv4addr;
PRFileDesc* newstack;
PR_ASSERT(sd != NULL);
PR_ASSERT(sd->lower != NULL);
newstack = PR_NEW(PRFileDesc);
if (NULL == newstack) {
PR_SetError(PR_OUT_OF_MEMORY_ERROR, 0);
return -1;
}
*newstack = *sd; /* make a copy of the accepting layer */
nbytes = sd->lower->methods->acceptread(sd->lower, nd, ipv6_raddr, buf,
amount, timeout);
if (-1 == nbytes) {
PR_DELETE(newstack);
return nbytes;
}
tmp_ipv4addr = **ipv6_raddr; /* copy */
_PR_ConvertToIpv6NetAddr(&tmp_ipv4addr, *ipv6_raddr);
/* this PR_PushIOLayer call cannot fail */
rv = PR_PushIOLayer(*nd, PR_TOP_IO_LAYER, newstack);
PR_ASSERT(PR_SUCCESS == rv);
return nbytes;
}
static PRStatus PR_CALLBACK Ipv6ToIpv4SocketGetName(PRFileDesc* fd,
PRNetAddr* ipv6addr) {
PRStatus result;
PRNetAddr tmp_ipv4addr;
result = (fd->lower->methods->getsockname)(fd->lower, &tmp_ipv4addr);
if (PR_SUCCESS == result) {
_PR_ConvertToIpv6NetAddr(&tmp_ipv4addr, ipv6addr);
PR_ASSERT(IsValidNetAddr(ipv6addr) == PR_TRUE);
}
return result;
}
static PRStatus PR_CALLBACK Ipv6ToIpv4SocketGetPeerName(PRFileDesc* fd,
PRNetAddr* ipv6addr) {
PRStatus result;
PRNetAddr tmp_ipv4addr;
result = (fd->lower->methods->getpeername)(fd->lower, &tmp_ipv4addr);
if (PR_SUCCESS == result) {
_PR_ConvertToIpv6NetAddr(&tmp_ipv4addr, ipv6addr);
PR_ASSERT(IsValidNetAddr(ipv6addr) == PR_TRUE);
}
return result;
}
static PRInt32 PR_CALLBACK Ipv6ToIpv4SocketRecvFrom(PRFileDesc* fd, void* buf,
PRInt32 amount,
PRIntn flags,
PRNetAddr* ipv6addr,
PRIntervalTime timeout) {
PRNetAddr tmp_ipv4addr;
PRInt32 result;
result = (fd->lower->methods->recvfrom)(fd->lower, buf, amount, flags,
&tmp_ipv4addr, timeout);
if (-1 != result) {
_PR_ConvertToIpv6NetAddr(&tmp_ipv4addr, ipv6addr);
PR_ASSERT(IsValidNetAddr(ipv6addr) == PR_TRUE);
}
return result;
}
# if defined(_PR_INET6_PROBE)
static PRBool ipv6_is_present;
PR_EXTERN(PRBool) _pr_test_ipv6_socket(void);
# if !defined(_PR_INET6) && defined(_PR_HAVE_GETIPNODEBYNAME)
extern PRStatus _pr_find_getipnodebyname(void);
# endif
# if !defined(_PR_INET6) && defined(_PR_HAVE_GETADDRINFO)
extern PRStatus _pr_find_getaddrinfo(void);
# endif
static PRBool _pr_probe_ipv6_presence(void) {
# if !defined(_PR_INET6) && defined(_PR_HAVE_GETIPNODEBYNAME)
if (_pr_find_getipnodebyname() != PR_SUCCESS) {
return PR_FALSE;
}
# endif
# if !defined(_PR_INET6) && defined(_PR_HAVE_GETADDRINFO)
if (_pr_find_getaddrinfo() != PR_SUCCESS) {
return PR_FALSE;
}
# endif
return _pr_test_ipv6_socket();
}
# endif /* _PR_INET6_PROBE */
static PRCallOnceType _pr_init_ipv6_once;
static PRStatus PR_CALLBACK _pr_init_ipv6(void) {
const PRIOMethods* stubMethods;
# if defined(_PR_INET6_PROBE)
ipv6_is_present = _pr_probe_ipv6_presence();
if (ipv6_is_present) {
return PR_SUCCESS;
}
# endif
_pr_ipv6_to_ipv4_id = PR_GetUniqueIdentity("Ipv6_to_Ipv4 layer");
PR_ASSERT(PR_INVALID_IO_LAYER != _pr_ipv6_to_ipv4_id);
stubMethods = PR_GetDefaultIOMethods();
ipv6_to_v4_tcpMethods = *stubMethods; /* first get the entire batch */
/* then override the ones we care about */
ipv6_to_v4_tcpMethods.connect = Ipv6ToIpv4SocketConnect;
ipv6_to_v4_tcpMethods.bind = Ipv6ToIpv4SocketBind;
ipv6_to_v4_tcpMethods.accept = Ipv6ToIpv4SocketAccept;
ipv6_to_v4_tcpMethods.acceptread = Ipv6ToIpv4SocketAcceptRead;
ipv6_to_v4_tcpMethods.getsockname = Ipv6ToIpv4SocketGetName;
ipv6_to_v4_tcpMethods.getpeername = Ipv6ToIpv4SocketGetPeerName;
/*
ipv6_to_v4_tcpMethods.getsocketoption = Ipv6ToIpv4GetSocketOption;
ipv6_to_v4_tcpMethods.setsocketoption = Ipv6ToIpv4SetSocketOption;
*/
ipv6_to_v4_udpMethods = *stubMethods; /* first get the entire batch */
/* then override the ones we care about */
ipv6_to_v4_udpMethods.connect = Ipv6ToIpv4SocketConnect;
ipv6_to_v4_udpMethods.bind = Ipv6ToIpv4SocketBind;
ipv6_to_v4_udpMethods.sendto = Ipv6ToIpv4SocketSendTo;
ipv6_to_v4_udpMethods.recvfrom = Ipv6ToIpv4SocketRecvFrom;
ipv6_to_v4_udpMethods.getsockname = Ipv6ToIpv4SocketGetName;
ipv6_to_v4_udpMethods.getpeername = Ipv6ToIpv4SocketGetPeerName;
/*
ipv6_to_v4_udpMethods.getsocketoption = Ipv6ToIpv4GetSocketOption;
ipv6_to_v4_udpMethods.setsocketoption = Ipv6ToIpv4SetSocketOption;
*/
return PR_SUCCESS;
}
# if defined(_PR_INET6_PROBE)
PRBool _pr_ipv6_is_present(void) {
if (PR_CallOnce(&_pr_init_ipv6_once, _pr_init_ipv6) != PR_SUCCESS) {
return PR_FALSE;
}
return ipv6_is_present;
}
# endif
PR_IMPLEMENT(PRStatus) _pr_push_ipv6toipv4_layer(PRFileDesc* fd) {
PRFileDesc* ipv6_fd = NULL;
if (PR_CallOnce(&_pr_init_ipv6_once, _pr_init_ipv6) != PR_SUCCESS) {
return PR_FAILURE;
}
/*
* For platforms with no support for IPv6
* create layered socket for IPv4-mapped IPv6 addresses
*/
if (fd->methods->file_type == PR_DESC_SOCKET_TCP)
ipv6_fd = PR_CreateIOLayerStub(_pr_ipv6_to_ipv4_id, &ipv6_to_v4_tcpMethods);
else
ipv6_fd = PR_CreateIOLayerStub(_pr_ipv6_to_ipv4_id, &ipv6_to_v4_udpMethods);
if (NULL == ipv6_fd) {
goto errorExit;
}
ipv6_fd->secret = NULL;
if (PR_PushIOLayer(fd, PR_TOP_IO_LAYER, ipv6_fd) == PR_FAILURE) {
goto errorExit;
}
return PR_SUCCESS;
errorExit:
if (ipv6_fd) {
ipv6_fd->dtor(ipv6_fd);
}
return PR_FAILURE;
}
#endif /* !defined(_PR_INET6) || defined(_PR_INET6_PROBE) */