bool netif_str_to_addr(struct sockaddr_storage *out, int *addr_len,
const char *addr)
{
bool ipv6;
memset(out, 0, sizeof(*out));
*addr_len = 0;
if (!addr)
return false;
ipv6 = (strchr(addr, ':') != NULL);
out->ss_family = ipv6 ? AF_INET6 : AF_INET;
*addr_len = sizeof(*out);
#ifdef _WIN32
int ret = WSAStringToAddressA((LPSTR)addr, out->ss_family, NULL,
(LPSOCKADDR)out, addr_len);
if (ret == SOCKET_ERROR)
warn("Could not parse address, error code: %d", GetLastError());
return ret != SOCKET_ERROR;
#else
struct sockaddr_in *sin = (struct sockaddr_in *)out;
if (inet_pton(out->ss_family, addr, &sin->sin_addr)) {
*addr_len = ipv6 ?
sizeof(struct sockaddr_in6) :
sizeof(struct sockaddr_in);
return true;
}
return false;
#endif
}
int
inet_pton (int af, const char* src, void* dest)
{
int destSize;
int rc;
int ret;
struct sockaddr_in sockAddr;
destSize = sizeof (sockAddr);
rc = WSAStringToAddressA ((char*)src,
af,
0,
(LPSOCKADDR)&sockAddr,
&destSize);
if (0 != rc)
{
if (WSAGetLastError () == WSAEINVAL) { ret = -1; }
else { ret = 0; }
}
else
{
memcpy (dest, &sockAddr.sin_addr, sizeof (sockAddr.sin_addr));
ret = 1;
}
return ret;
}
static int nn_inet_pton(int family, const char *src, void *dst)
{
int rc;
struct sockaddr_storage addr;
int addr_len = sizeof(addr);
if (nn_slow (family != AF_INET && family != AF_INET6)) {
errno = EAFNOSUPPORT;
return -1;
}
addr.ss_family = family;
rc = WSAStringToAddressA ((char*) src, family, NULL,
(struct sockaddr*) &addr, &addr_len);
if (rc != 0)
return 0;
if (family == AF_INET) {
memcpy(dst, &((struct sockaddr_in *) &addr)->sin_addr,
sizeof(struct in_addr));
} else if (family == AF_INET6) {
memcpy(dst, &((struct sockaddr_in6 *)&addr)->sin6_addr,
sizeof(struct in6_addr));
}
return 1;
}
bool NetlibStringToAddress(const char* str, SOCKADDR_INET_M* addr)
{
if (!str) return false;
int len = sizeof(SOCKADDR_INET_M);
return !WSAStringToAddressA((char*)str, AF_INET6, NULL, (PSOCKADDR)addr, &len);
}
int
__gnat_inet_pton (int af, const char *src, void *dst) {
switch (af) {
#if defined (_WIN32) && defined (AF_INET6)
case AF_INET6:
#endif
case AF_INET:
break;
default:
errno = EAFNOSUPPORT;
return -1;
}
#if defined (__vxworks)
return (inet_aton (src, dst) == OK);
#elif defined (_WIN32)
struct sockaddr_storage ss;
int sslen = sizeof ss;
int rc;
ss.ss_family = af;
rc = WSAStringToAddressA (src, af, NULL, (struct sockaddr *)&ss, &sslen);
if (rc == 0) {
switch (af) {
case AF_INET:
*(struct in_addr *)dst = ((struct sockaddr_in *)&ss)->sin_addr;
break;
#ifdef AF_INET6
case AF_INET6:
*(struct in6_addr *)dst = ((struct sockaddr_in6 *)&ss)->sin6_addr;
break;
#endif
}
}
return (rc == 0);
#elif defined (__hpux__)
in_addr_t addr;
int rc = -1;
if (src == NULL || dst == NULL) {
errno = EINVAL;
} else if (!strcmp (src, "255.255.255.255")) {
addr = 0xffffffff;
rc = 1;
} else {
addr = inet_addr (src);
rc = (addr != 0xffffffff);
}
if (rc == 1) {
*(in_addr_t *)dst = addr;
}
return rc;
#endif
}
/** @details This constructor attempts to parse a string into the given IP address version. The
* type given can either be IPAddressType::IPV4 or IPAddressType::IPV6. If the conversion fails,
* the resulting address is invalid.
* @param ip A parsable IP address of the given type.
* @param type The type of address to attempt to parse.
*/
_CGUL_EXPORT CGUL::Network::IPAddress::IPAddress(const CGUL::String& ip, UInt32 type)
{
__cgul_network_initiate();
this->type = IPAddressType::INVALID;
if (type == IPAddressType::IPV4)
{
# ifdef CGUL_WINDOWS
sockaddr_in addr;
int length = sizeof(sockaddr_in);
if (WSAStringToAddressA((char*)ip.GetCString(), AF_INET, NULL, (sockaddr*)&addr, &length) == 0)
{
this->type = IPAddressType::IPV4;
address[0] = addr.sin_addr.s_addr;
address[1] = 0;
}
# else
if (inet_pton(AF_INET, ip.GetCString(), &address) == 1)
{
this->type = IPAddressType::IPV4;
}
# endif
}
if (type == IPAddressType::IPV6)
{
# ifdef CGUL_WINDOWS
sockaddr_in6 addr;
int length = sizeof(sockaddr_in6);
if (WSAStringToAddressA((char*)ip.GetCString(), AF_INET6, NULL, (sockaddr*)&addr, &length) == 0)
{
this->type = IPAddressType::IPV6;
memcpy(&address, &addr.sin6_addr, sizeof(address));
}
# else
if (inet_pton(AF_INET6, ip.GetCString(), &address) == 1)
{
this->type = IPAddressType::IPV6;
}
# endif
}
}
VOID InitMcastAddr(SOCKADDR* pmcaddr,int size)
{
WSAStringToAddressA(MCAST_V6,
AF_INET6,
NULL,
pmcaddr,
&size
);
((SOCKADDR_IN6*)pmcaddr)->sin6_port = htons(DEFAULT_PORT);
}
CoreExport int insp_inet_pton(int af, const char *src, void *dst)
{
sockaddr_in sa;
int len = sizeof(SOCKADDR);
int rv = WSAStringToAddressA((LPSTR)src, af, NULL, (LPSOCKADDR)&sa, &len);
if(rv >= 0)
{
if(WSAGetLastError() == WSAEINVAL)
rv = 0;
else
rv = 1;
}
memcpy(dst, &sa.sin_addr, sizeof(struct in_addr));
return rv;
}
NetSocket* TCPNetworkEngine::connect(const char* uri)
{
if(strncmp(uri, "yc://", 5) == 0)
{
const char* host = uri + 5;
TCPNetSocket* s = new TCPNetSocket();
s->socket = socket(PF_INET, SOCK_STREAM, 0);
xerror(s->socket != SOCKET_ERROR, "Could not create a socket.");
struct hostent* hostaddr = gethostbyname(host);
xwarn(hostaddr->h_addr_list, "Could not retreive address for host %s", host);
if(!hostaddr->h_addr_list)
return NULL;
struct sockaddr_in saddr;
bzero(&saddr, sizeof(saddr));
saddr.sin_family = hostaddr->h_addrtype;
saddr.sin_port = htons(port);
#ifndef WIN32
inet_pton(hostaddr->h_addrtype, hostaddr->h_addr_list[0], &saddr.sin_addr);
#else
struct sockaddr_storage ss;
int sslen = sizeof(ss);
WSAStringToAddressA(hostaddr->h_addr_list[0], hostaddr->h_addrtype, NULL, (struct sockaddr*)&ss, &sslen);
saddr.sin_addr = ((struct sockaddr_in *)&ss)->sin_addr;
#endif
if(::connect(s->socket, (struct sockaddr *)&saddr, sizeof(saddr) ) == SOCKET_ERROR)
{
xwarn(false, "Could not connect to %s", host);
return NULL;
}
#ifdef WIN32
ULONG on=1;
ioctlsocket(s->socket, FIONBIO, &on);
#else
fcntl(s->socket, F_SETFL, O_NONBLOCK);
#endif
return s;
} else {
xwarn(false, "Unknown protocol : %s", uri);
return NULL;
}
}
static int sgs_socket_address( SGS_CTX )
{
struct sockaddr_storage ss;
char* buf;
sgs_SizeVal bufsize;
sgs_Int af;
uint16_t port = 0;
SGSFN( "socket_address" );
if( !sgs_LoadArgs( C, "im|+w", &af, &buf, &bufsize, &port ) )
return 0;
if( af != AF_INET && af != AF_INET6 )
STDLIB_WARN( "argument 1 (address family)"
" must be either AF_INET or AF_INET6" )
memset( &ss, 0, sizeof(ss) );
ss.ss_family = (sa_family_t) af;
port = htons( port );
{
#ifdef _WIN32
INT len = sizeof( ss );
int res = sockassert( C, WSAStringToAddressA( buf, (int16_t) af,
NULL, (struct sockaddr*) &ss, &len ) == 0 );
#else
int res = sockassert( C, inet_pton( (int16_t) af, buf, &ss ) == 1 );
#endif
if( !res )
STDLIB_WARN( "failed to generate address from string" )
}
if( af == AF_INET )
{
struct sockaddr_in* sai = (struct sockaddr_in*) &ss;
sai->sin_port = port;
}
else if( af == AF_INET6 )
{
struct sockaddr_in6* sai = (struct sockaddr_in6*) &ss;
sai->sin6_port = port;
}
else
STDLIB_WARN( "INTERNAL ERROR (unexpected AF value)" )
push_sockaddr( C, &ss, sizeof(ss) );
return 1;
}
int inet_pton( int af, const char *src, void *dst )
{
/* IPv6 is largest buffer, so use it for both */
struct sockaddr_in6 dst_sockaddr;
struct sockaddr_in6 *pDst_sockaddr;
int dst_size;
int result;
DWORD error;
pDst_sockaddr = &dst_sockaddr;
switch( af )
{
case AF_INET:
dst_size = sizeof( struct sockaddr_in );
break;
case AF_INET6:
dst_size = sizeof( struct sockaddr_in6 );
break;
default:
return 0;
}
result = WSAStringToAddressA( src, af, NULL,
(LPSOCKADDR)pDst_sockaddr, &dst_size );
if ( result != 0 )
{
error = GetLastError();
return error;
return 0;
}
switch( af )
{
case AF_INET:
memcpy( dst, &((struct sockaddr_in*)pDst_sockaddr)->sin_addr,
sizeof( struct in_addr ) );
break;
case AF_INET6:
memcpy( dst, &pDst_sockaddr->sin6_addr,
sizeof( struct in6_addr ) );
break;
}
return 1;
}
static int
inet_pton( int family, const char * addr, void * dst )
{
struct sockaddr_storage ss;
int sslen = sizeof( ss );
ZeroMemory( &ss, sizeof( ss ) );
ss.ss_family = family;
if ( WSAStringToAddressA( addr, family, NULL, ( struct sockaddr* ) &ss, &sslen ) == 0 )
{
if ( family == AF_INET ) { memcpy( dst, &( ( struct sockaddr_in* ) &ss)->sin_addr, sizeof( IN_ADDR ) ); return 1; }
else if ( family == AF_INET6 ) { memcpy( dst, &( ( struct sockaddr_in6* ) &ss)->sin6_addr, sizeof( IN6_ADDR ) ); return 1; }
else return 0;
}
else return 0;
}
int net_string_to_address(int af, const char* src, void* dst)
{
#ifdef WINSOCK
int ret, size;
struct sockaddr_in addr4;
struct sockaddr_in6 addr6;
struct sockaddr* addr = 0;
if (af == AF_INET6)
{
if (net_is_ipv6_supported() != 1) return -1;
size = sizeof(struct sockaddr_in6);
addr = (struct sockaddr*) &addr6;
}
else
{
size = sizeof(struct sockaddr_in);
addr = (struct sockaddr*) &addr4;
}
if (!net_initialized)
net_initialize();
ret = WSAStringToAddressA((char*) src, af, NULL, addr, &size);
if (ret == -1)
{
return -1;
}
if (af == AF_INET6)
{
memcpy(dst, &addr6.sin6_addr, sizeof(addr6.sin6_addr));
}
else
{
memcpy(dst, &addr4.sin_addr, sizeof(addr4.sin_addr));
}
return 1;
#else
return inet_pton(af, src, dst);
#endif
}
void IPV6Cidr::set(const char *cp)
{
char cbuf[INET_IPV6_ADDRESS_SIZE];
char *ep;
memset(&netmask, 0, sizeof(netmask));
bitset((bit_t *)&netmask, getMask(cp));
setString(cbuf, sizeof(cbuf), cp);
ep = (char *)strchr(cp, '/');
if(ep)
*ep = 0;
#ifdef _MSWINDOWS_
int slen = sizeof(network);
WSAStringToAddressA(cbuf, AF_INET6, NULL, (struct sockaddr*)&network, &slen);
#else
inet_pton(AF_INET6, cbuf, &network);
#endif
bitmask((bit_t *)&network, (bit_t *)&netmask, sizeof(network));
}
bool NetUtil::is_valid_ipv4(const char* ipstr)
{
#ifdef WIN32
WSADATA info;
memset(&info, 0, sizeof(info));
WSAStartup(MAKEWORD(2, 0), &info);
sockaddr sa;
int len = sizeof(sa);
int ret = WSAStringToAddressA(const_cast<char*>(ipstr), AF_INET, NULL, &sa, &len);
WSACleanup();
return ret == 0;
#else
struct in_addr ia;
if (inet_pton(AF_INET, ipstr, &ia) == 0) {
return false;
}
return true;
#endif
}
int inet_pton(int af, const char* src, void* dest)
{
if (af != AF_INET && af != AF_INET6)
{
return -1;
}
SOCKADDR_STORAGE address;
int address_length = sizeof(SOCKADDR_STORAGE);
int result = WSAStringToAddressA((char*)(src), af, 0,
(sockaddr*)(&address),
&address_length);
if (af == AF_INET)
{
if (result != SOCKET_ERROR)
{
sockaddr_in* ipv4_address =(sockaddr_in*)(&address);
memcpy(dest, &ipv4_address->sin_addr, sizeof(in_addr));
}
else if (strcmp(src, "255.255.255.255") == 0)
{
((in_addr*)(dest))->s_addr = INADDR_NONE;
}
}
else // AF_INET6
{
if (result != SOCKET_ERROR)
{
sockaddr_in6* ipv6_address = (sockaddr_in6*)(&address);
memcpy(dest, &ipv6_address->sin6_addr, sizeof(in6_addr));
}
}
return result == SOCKET_ERROR ? -1 : 1;
}
static int _inet_pton(int Family, const char * pszAddrString, void* pAddrBuf)
{
struct sockaddr_storage tmpholder;
int actualSize = sizeof(sockaddr_storage);
int result = WSAStringToAddressA((char *)pszAddrString, Family, NULL, (sockaddr*)&tmpholder, &actualSize);
if (result) return -1;
switch (Family) {
case AF_INET:
{
struct sockaddr_in * ipv4 = reinterpret_cast< struct sockaddr_in *>(&tmpholder);
memcpy(pAddrBuf, &(ipv4->sin_addr), sizeof(ipv4->sin_addr));
}
break;
case AF_INET6:
{
struct sockaddr_in6 * ipv6 = reinterpret_cast< struct sockaddr_in6 *>(&tmpholder);
memcpy(pAddrBuf, &(ipv6->sin6_addr), sizeof(ipv6->sin6_addr));
}
break;
}
return 1;
}
/**
* int inet_pton(int af, const char *src, void *dst);
*
* Compatible with inet_pton just replace inet_pton with xp_inet_pton
* and you are good to go. Uses WSAStringToAddressA instead of
* inet_pton, compatible with Windows 2000 +
*/
static int xp_inet_pton(int family, const char *src, void *dst)
{
int rc;
struct sockaddr_storage addr;
int addr_len = sizeof(addr);
addr.ss_family = family;
rc = WSAStringToAddressA((char *) src, family, NULL,
(struct sockaddr*) &addr, &addr_len);
if (rc != 0) {
return -1;
}
if (family == AF_INET) {
memcpy(dst, &((struct sockaddr_in *) &addr)->sin_addr,
sizeof(struct in_addr));
} else if (family == AF_INET6) {
memcpy(dst, &((struct sockaddr_in6 *)&addr)->sin6_addr,
sizeof(struct in6_addr));
}
return 1;
}
afs_int32 init_fs_channel(rpc_test_request_ctx **octx, char *cb_if,
char *listen_addr_s, char *prefix, char *fs_addr_s,
afs_uint32 flags)
{
char cmd[512];
rpc_test_request_ctx *ctx;
afs_int32 code = 0;
#ifdef AFS_NT40_ENV
afs_int32 sslen = sizeof(struct sockaddr);
#endif
ctx = *octx = (rpc_test_request_ctx *) malloc(sizeof(rpc_test_request_ctx));
memset(ctx, 0, sizeof(rpc_test_request_ctx));
/* initialize a local mutex */
code = pthread_mutex_init(&ctx->mtx, &rpc_test_params.mtx_attrs);
/* lock package before rx setup--which has global deps, atm */
pthread_mutex_lock(&rpc_test_params.mtx);
ctx->cno = rpc_test_params.next_cno++;
ctx->flags = flags;
/* afscbint (server) */
sprintf(ctx->cb_svc_name, "cb_%d", ctx->cno);
sprintf(ctx->cb_if_s, cb_if);
sprintf(ctx->cb_listen_addr_s, listen_addr_s);
sprintf(ctx->cb_prefix_s, prefix);
sprintf(ctx->fs_addr_s, fs_addr_s);
#if defined(RPC_TEST_ADD_ADDRESSES)
#if defined(AFS_LINUX26_ENV)
sprintf(cmd, "ip addr add %s/%s dev %s label %s", listen_addr_s, prefix,
cb_if, cb_if);
code = system(cmd);
#endif
#endif /* RPC_TEST_ADD_ADDRESSES */
/* lock this */
pthread_mutex_lock(&ctx->mtx);
/* set up rx */
ctx->cb_port = rpc_test_params.cb_next_port++;
ctx->cb_listen_addr.numberOfInterfaces = 1;
#ifdef AFS_NT40_ENV
code = WSAStringToAddressA(listen_addr_s, AF_INET, NULL,
(struct sockaddr*) &(ctx->cb_listen_addr), &sslen);
#else
code = inet_pton(AF_INET, listen_addr_s,
(void*) &(ctx->cb_listen_addr.addr_in[0]));
#endif
code = init_callback_service(ctx /* LOCKED, && rpc_test_params->mtx LOCKED */);
/* fsint (client) */
#ifdef AFS_NT40_ENV
code = WSAStringToAddressA(fs_addr_s, AF_INET, NULL,
(struct sockaddr*) &(ctx->fs_addr.addr_in[0]), &sslen);
#else
code = inet_pton(AF_INET, fs_addr_s, (void*) &(ctx->fs_addr.addr_in[0]));
#endif
ctx->sc = rxnull_NewClientSecurityObject();
ctx->sc_index = RX_SECIDX_NULL;
ctx->conn = rx_NewConnection(ctx->fs_addr.addr_in[0], (int) htons(fs_port),
1, ctx->sc, ctx->sc_index);
/* unlock this */
pthread_mutex_unlock(&ctx->mtx);
out:
return (code);
} /* init_fs_channel */
static int qt_serial_open(serial_t **out, dc_context_t *context, const char* devaddr)
{
if (out == NULL)
return DC_STATUS_INVALIDARGS;
// Allocate memory.
serial_t *serial_port = (serial_t *) malloc (sizeof (serial_t));
if (serial_port == NULL) {
return DC_STATUS_NOMEMORY;
}
// Library context.
serial_port->context = context;
// Default to blocking reads.
serial_port->timeout = -1;
#if defined(Q_OS_WIN)
// Create a RFCOMM socket
serial_port->socket = ::socket(AF_BTH, SOCK_STREAM, BTHPROTO_RFCOMM);
if (serial_port->socket == INVALID_SOCKET) {
free(serial_port);
return DC_STATUS_IO;
}
SOCKADDR_BTH socketBthAddress;
int socketBthAddressBth = sizeof (socketBthAddress);
char *address = strdup(devaddr);
ZeroMemory(&socketBthAddress, socketBthAddressBth);
qDebug() << "Trying to connect to address " << devaddr;
if (WSAStringToAddressA(address,
AF_BTH,
NULL,
(LPSOCKADDR) &socketBthAddress,
&socketBthAddressBth
) != 0) {
qDebug() << "FAiled to convert the address " << address;
free(address);
return DC_STATUS_IO;
}
free(address);
socketBthAddress.addressFamily = AF_BTH;
socketBthAddress.port = BT_PORT_ANY;
memset(&socketBthAddress.serviceClassId, 0, sizeof(socketBthAddress.serviceClassId));
socketBthAddress.serviceClassId = SerialPortServiceClass_UUID;
// Try to connect to the device
if (::connect(serial_port->socket,
(struct sockaddr *) &socketBthAddress,
socketBthAddressBth
) != 0) {
qDebug() << "Failed to connect to device";
return DC_STATUS_NODEVICE;
}
qDebug() << "Succesfully connected to device";
#else
// Create a RFCOMM socket
serial_port->socket = new QBluetoothSocket(QBluetoothServiceInfo::RfcommProtocol);
// Wait until the connection succeeds or until an error occurs
QEventLoop loop;
loop.connect(serial_port->socket, SIGNAL(connected()), SLOT(quit()));
loop.connect(serial_port->socket, SIGNAL(error(QBluetoothSocket::SocketError)), SLOT(quit()));
// Create a timer. If the connection doesn't succeed after five seconds or no error occurs then stop the opening step
QTimer timer;
int msec = 5000;
timer.setSingleShot(true);
loop.connect(&timer, SIGNAL(timeout()), SLOT(quit()));
#if defined(Q_OS_LINUX) && !defined(Q_OS_ANDROID)
// First try to connect on RFCOMM channel 1. This is the default channel for most devices
QBluetoothAddress remoteDeviceAddress(devaddr);
serial_port->socket->connectToService(remoteDeviceAddress, 1);
timer.start(msec);
loop.exec();
if (serial_port->socket->state() == QBluetoothSocket::ConnectingState) {
// It seems that the connection on channel 1 took more than expected. Wait another 15 seconds
qDebug() << "The connection on RFCOMM channel number 1 took more than expected. Wait another 15 seconds.";
timer.start(3 * msec);
loop.exec();
} else if (serial_port->socket->state() == QBluetoothSocket::UnconnectedState) {
// Try to connect on channel number 5. Maybe this is a Shearwater Petrel2 device.
qDebug() << "Connection on channel 1 failed. Trying on channel number 5.";
serial_port->socket->connectToService(remoteDeviceAddress, 5);
timer.start(msec);
loop.exec();
if (serial_port->socket->state() == QBluetoothSocket::ConnectingState) {
// It seems that the connection on channel 5 took more than expected. Wait another 15 seconds
qDebug() << "The connection on RFCOMM channel number 5 took more than expected. Wait another 15 seconds.";
timer.start(3 * msec);
loop.exec();
}
}
#elif defined(Q_OS_ANDROID) || (QT_VERSION >= 0x050500 && defined(Q_OS_MAC))
// Try to connect to the device using the uuid of the Serial Port Profile service
QBluetoothAddress remoteDeviceAddress(devaddr);
serial_port->socket->connectToService(remoteDeviceAddress, QBluetoothUuid(QBluetoothUuid::SerialPort));
timer.start(msec);
loop.exec();
if (serial_port->socket->state() == QBluetoothSocket::ConnectingState ||
serial_port->socket->state() == QBluetoothSocket::ServiceLookupState) {
// It seems that the connection step took more than expected. Wait another 20 seconds.
qDebug() << "The connection step took more than expected. Wait another 20 seconds";
timer.start(4 * msec);
loop.exec();
}
#endif
if (serial_port->socket->state() != QBluetoothSocket::ConnectedState) {
// Get the latest error and try to match it with one from libdivecomputer
QBluetoothSocket::SocketError err = serial_port->socket->error();
qDebug() << "Failed to connect to device " << devaddr << ". Device state " << serial_port->socket->state() << ". Error: " << err;
free (serial_port);
switch(err) {
case QBluetoothSocket::HostNotFoundError:
case QBluetoothSocket::ServiceNotFoundError:
return DC_STATUS_NODEVICE;
case QBluetoothSocket::UnsupportedProtocolError:
return DC_STATUS_PROTOCOL;
#if QT_VERSION >= 0x050400
case QBluetoothSocket::OperationError:
return DC_STATUS_UNSUPPORTED;
#endif
case QBluetoothSocket::NetworkError:
return DC_STATUS_IO;
default:
return QBluetoothSocket::UnknownSocketError;
}
}
#endif
*out = serial_port;
return DC_STATUS_SUCCESS;
}
int irc_connect6 (irc_session_t * session,
const char * server,
unsigned short port,
const char * server_password,
const char * nick,
const char * username,
const char * realname)
{
#if defined (ENABLE_IPV6)
struct sockaddr_in6 saddr;
struct addrinfo ainfo, *res = NULL;
char portStr[32];
#if defined (_WIN32)
int addrlen = sizeof(saddr);
HMODULE hWsock;
getaddrinfo_ptr_t getaddrinfo_ptr;
freeaddrinfo_ptr_t freeaddrinfo_ptr;
int resolvesuccess = 0;
#endif // _WIN32
sprintf(portStr, "%u", (unsigned)port);
// Check and copy all the specified fields
if ( !server || !nick )
{
session->lasterror = LIBIRC_ERR_INVAL;
return 1;
}
if ( session->state != LIBIRC_STATE_INIT )
{
session->lasterror = LIBIRC_ERR_STATE;
return 1;
}
if ( username )
session->username = strdup (username);
if ( server_password )
session->server_password = strdup (server_password);
if ( realname )
session->realname = strdup (realname);
session->nick = strdup (nick);
session->server = strdup (server);
memset( &saddr, 0, sizeof(saddr) );
saddr.sin6_family = AF_INET6;
saddr.sin6_port = htons (port);
#if defined (_WIN32)
if ( WSAStringToAddressA( (LPSTR)server, AF_INET6, NULL, (struct sockaddr *)&saddr, &addrlen ) == SOCKET_ERROR )
{
hWsock = LoadLibraryA("ws2_32");
if (hWsock)
{
/* Determine functions at runtime, because windows systems < XP do not
* support getaddrinfo. */
getaddrinfo_ptr = (getaddrinfo_ptr_t)GetProcAddress(hWsock, "getaddrinfo");
freeaddrinfo_ptr = (freeaddrinfo_ptr_t)GetProcAddress(hWsock, "freeaddrinfo");
if (getaddrinfo_ptr && freeaddrinfo_ptr)
{
memset(&ainfo, 0, sizeof(ainfo));
ainfo.ai_family = AF_INET6;
ainfo.ai_socktype = SOCK_STREAM;
ainfo.ai_protocol = 0;
if ( getaddrinfo_ptr(server, portStr, &ainfo, &res) == 0 && res )
{
resolvesuccess = 1;
memcpy( &saddr, res->ai_addr, res->ai_addrlen );
freeaddrinfo_ptr( res );
}
}
FreeLibrary(hWsock);
}
if (!resolvesuccess)
{
session->lasterror = LIBIRC_ERR_RESOLV;
return 1;
}
}
#else
if ( inet_pton( AF_INET6, server, (void*) &saddr.sin6_addr ) <= 0 )
{
memset( &ainfo, 0, sizeof(ainfo) );
ainfo.ai_family = AF_INET6;
ainfo.ai_socktype = SOCK_STREAM;
ainfo.ai_protocol = 0;
if ( getaddrinfo( server, portStr, &ainfo, &res ) || !res )
{
session->lasterror = LIBIRC_ERR_RESOLV;
return 1;
}
memcpy( &saddr, res->ai_addr, res->ai_addrlen );
freeaddrinfo( res );
}
#endif // _WIN32
// create the IRC server socket
if ( socket_create( PF_INET6, SOCK_STREAM, &session->sock)
|| socket_make_nonblocking (&session->sock) )
{
session->lasterror = LIBIRC_ERR_SOCKET;
return 1;
}
// and connect to the IRC server
if ( socket_connect (&session->sock, (struct sockaddr *) &saddr, sizeof(saddr)) )
{
session->lasterror = LIBIRC_ERR_CONNECT;
return 1;
}
session->state = LIBIRC_STATE_CONNECTING;
session->motd_received = 0; // reset in case of reconnect
return 0;
#else
session->lasterror = LIBIRC_ERR_NOIPV6;
return 1;
#endif // ENABLE_IPV6
}
/*
* Returns: [interfaces (table)]
*/
static int
sock_getifaddrs (lua_State *L)
{
struct sock_addr *sap;
int i, res;
#ifndef _WIN32
struct ifaddrs *result, *rp;
sys_vm_leave(L);
res = getifaddrs(&result);
sys_vm_enter(L);
#else
INTERFACE_INFO result[8192], *rp;
SOCKET sd = WSASocketW(AF_INET, SOCK_STREAM, 0, NULL, 0, WSA_FLAGS);
DWORD n;
sys_vm_leave(L);
res = WSAIoctl(sd, SIO_GET_INTERFACE_LIST, NULL, 0,
result, sizeof(result), &n, NULL, NULL);
closesocket(sd);
sys_vm_enter(L);
#endif
if (res == -1)
return sys_seterror(L, 0);
lua_createtable(L, 8, 0);
rp = result;
#ifndef _WIN32
for (i = 0; rp; rp = rp->ifa_next) {
#else
for (i = 0; n--; ++rp) {
#endif
#ifndef _WIN32
sap = (struct sock_addr *) rp->ifa_addr;
#else
sap = (struct sock_addr *) &rp->iiAddress;
#endif
if (!sap || sap->u.addr.sa_family == AF_UNSPEC)
continue;
lua_newtable(L);
{
const int af = sap->u.addr.sa_family;
if (af == AF_INET
#ifdef AF_INET6
|| af == AF_INET6
#endif
) {
sock_pushaddr(L, sap);
lua_setfield(L, -2, "addr");
}
{
const char *s = NULL;
switch (af) {
case AF_INET: s = "INET"; break;
#ifdef AF_INET6
case AF_INET6: s = "INET6"; break;
#endif
#ifdef AF_LOCAL
case AF_LOCAL: s = "LOCAL"; break;
#endif
#ifdef AF_AX25
case AF_AX25: s = "AX25"; break;
#endif
#ifdef AF_IPX
case AF_IPX: s = "IPX"; break;
#endif
#ifdef AF_APPLETALK
case AF_APPLETALK: s = "APPLETALK"; break;
#endif
#ifdef AF_NETROM
case AF_NETROM: s = "NETROM"; break;
#endif
#ifdef AF_BRIDGE
case AF_BRIDGE: s = "BRIDGE"; break;
#endif
#ifdef AF_ATMPVC
case AF_ATMPVC: s = "ATMPVC"; break;
#endif
#ifdef AF_X25
case AF_X25: s = "X25"; break;
#endif
#ifdef AF_ROSE
case AF_ROSE: s = "ROSE"; break;
#endif
#ifdef AF_DECnet
case AF_DECnet: s = "DECnet"; break;
#endif
#ifdef AF_NETBEUI
case AF_NETBEUI: s = "NETBEUI"; break;
#endif
#ifdef AF_SECURITY
case AF_SECURITY: s = "SECURITY"; break;
#endif
#ifdef AF_KEY
case AF_KEY: s = "KEY"; break;
#endif
#ifdef AF_NETLINK
case AF_NETLINK: s = "NETLINK"; break;
#endif
#ifdef AF_PACKET
case AF_PACKET: s = "PACKET"; break;
#endif
#ifdef AF_ASH
case AF_ASH: s = "ASH"; break;
#endif
#ifdef AF_ECONET
case AF_ECONET: s = "ECONET"; break;
#endif
#ifdef AF_ATMSVC
case AF_ATMSVC: s = "ATMSVC"; break;
#endif
#ifdef AF_RDS
case AF_RDS: s = "RDS"; break;
#endif
#ifdef AF_SNA
case AF_SNA: s = "SNA"; break;
#endif
#ifdef AF_IRDA
case AF_IRDA: s = "IRDA"; break;
#endif
#ifdef AF_PPPOX
case AF_PPPOX: s = "PPPOX"; break;
#endif
#ifdef AF_WANPIPE
case AF_WANPIPE: s = "WANPIPE"; break;
#endif
#ifdef AF_LLC
case AF_LLC: s = "LLC"; break;
#endif
#ifdef AF_CAN
case AF_CAN: s = "CAN"; break;
#endif
#ifdef AF_TIPC
case AF_TIPC: s = "TIPC"; break;
#endif
#ifdef AF_BLUETOOTH
case AF_BLUETOOTH: s = "BLUETOOTH"; break;
#endif
#ifdef AF_IUCV
case AF_IUCV: s = "IUCV"; break;
#endif
#ifdef AF_RXRPC
case AF_RXRPC: s = "RXRPC"; break;
#endif
#ifdef AF_ISDN
case AF_ISDN: s = "ISDN"; break;
#endif
#ifdef AF_PHONET
case AF_PHONET: s = "PHONET"; break;
#endif
#ifdef AF_IEEE802154
case AF_IEEE802154: s = "IEEE802154"; break;
#endif
default: s = "UNKNOWN";
}
if (s) {
lua_pushstring(L, s);
lua_setfield(L, -2, "family");
}
}
#ifndef _WIN32
sap = (struct sock_addr *) rp->ifa_netmask;
#else
sap = (struct sock_addr *) &rp->iiNetmask;
#endif
if (sap) {
sock_pushaddr(L, sap);
lua_setfield(L, -2, "netmask");
}
#ifndef _WIN32
sap = (struct sock_addr *) rp->ifa_broadaddr;
#else
sap = (struct sock_addr *) &rp->iiBroadcastAddress;
#endif
if (sap) {
sock_pushaddr(L, sap);
lua_setfield(L, -2, "broadaddr");
}
lua_createtable(L, 0, 5);
{
#ifndef _WIN32
const int flags = rp->ifa_flags;
#else
const int flags = rp->iiFlags;
#endif
lua_pushboolean(L, flags & IFF_UP);
lua_setfield(L, -2, "up");
lua_pushboolean(L, flags & IFF_BROADCAST);
lua_setfield(L, -2, "broadcast");
lua_pushboolean(L, flags & IFF_LOOPBACK);
lua_setfield(L, -2, "loopback");
lua_pushboolean(L, flags & IFF_POINTOPOINT);
lua_setfield(L, -2, "pointtopoint");
lua_pushboolean(L, flags & IFF_MULTICAST);
lua_setfield(L, -2, "multicast");
}
lua_setfield(L, -2, "flags");
}
lua_rawseti(L, -2, ++i);
}
#ifndef _WIN32
freeifaddrs(result);
#endif
return 1;
}
/*
* Arguments: text_address (string), [ip4_tonumber (true)]
* Returns: [binary_address (string | number)]
*/
static int
sock_inet_pton (lua_State *L)
{
const char *src = luaL_checkstring(L, 1);
const int to_ip4 = lua_toboolean(L, 2);
const int af = (!to_ip4 && strchr(src, ':')) ? AF_INET6 : AF_INET;
struct sock_addr sa;
void *inp = sock_addr_get_inp(&sa, af);
const int in_len = sock_addr_get_inlen(af);
#ifdef _WIN32
union sys_rwptr src_ptr; /* to avoid "const cast" warning */
#endif
memset(&sa, 0, sizeof(struct sock_addr));
if (*src == '*') goto end;
#ifndef _WIN32
if (inet_pton(af, src, inp) == 1) {
#else
sa.addrlen = sizeof(sa);
src_ptr.r = src;
if (!WSAStringToAddressA(src_ptr.w, af, NULL,
&sa.u.addr, &sa.addrlen)) {
#endif
end:
if (to_ip4)
lua_pushnumber(L, ntohl(*((unsigned long *) inp)));
else
lua_pushlstring(L, inp, in_len);
return 1;
}
return sys_seterror(L, 0);
}
/*
* Arguments: binary_address (string | number)
* Returns: [text_address (string)]
*/
static int
sock_inet_ntop (lua_State *L)
{
const int is_ip4 = (lua_type(L, 1) == LUA_TNUMBER);
unsigned long ip4;
int in_len, af;
const char *src;
char buf[48];
if (is_ip4) {
const lua_Number num = lua_tonumber(L, 1);
in_len = 4;
af = AF_INET;
ip4 = htonl((unsigned long) num);
src = (const char *) &ip4;
} else {
src = sock_checkladdr(L, 1, &in_len, &af);
}
#ifndef _WIN32
if (inet_ntop(af, src, buf, sizeof(buf)) == NULL)
goto err;
#else
{
struct sock_addr sa;
void *inp = sock_addr_get_inp(&sa, af);
const int sl = (af == AF_INET) ? sizeof(struct sockaddr_in)
: sizeof(struct sockaddr_in6);
DWORD buflen = sizeof(buf);
memset(&sa, 0, sizeof(struct sock_addr));
memcpy(inp, src, in_len);
sa.u.addr.sa_family = (short) af;
if (WSAAddressToStringA(&sa.u.addr, sl, NULL, buf, &buflen)
|| buflen >= sizeof(buf))
goto err;
}
#endif
lua_pushstring(L, buf);
return 1;
err:
return sys_seterror(L, 0);
}
/*
* Returns: sock_addr_udata
*/
static int
sock_addr_new (lua_State *L)
{
lua_newuserdata(L, sizeof(struct sock_addr));
luaL_getmetatable(L, SA_TYPENAME);
lua_setmetatable(L, -2);
return 1;
}
/*
* Arguments: sock_addr_udata, [port (number), binary_address (string)]
* Returns: sock_addr_udata | port (number), binary_address (string)
*/
static int
sock_addr_inet (lua_State *L)
{
struct sock_addr *sap = checkudata(L, 1, SA_TYPENAME);
if (lua_gettop(L) == 1) {
const int af = sap->u.addr.sa_family;
if (af == AF_INET) {
lua_pushinteger(L, ntohs(sap->u.in.sin_port));
lua_pushlstring(L, (char *) &sap->u.in.sin_addr,
sizeof(struct in_addr));
} else if (af == AF_INET6) {
lua_pushinteger(L, ntohs(sap->u.in6.sin6_port));
lua_pushlstring(L, (char *) &sap->u.in6.sin6_addr,
sizeof(struct in6_addr));
} else
return 0;
return 2;
} else {
const int port = (int) lua_tointeger(L, 2);
int in_len = SOCK_ADDR_LEN, af = AF_INET;
const char *addr = lua_isnoneornil(L, 3) ? NULL
: sock_checkladdr(L, 3, &in_len, &af);
memset(sap, 0, sizeof(struct sock_addr));
sap->u.addr.sa_family = (short) af;
if (af == AF_INET) {
sap->u.in.sin_port = htons((unsigned short) port);
if (addr)
memcpy(&sap->u.in.sin_addr, addr, in_len);
sap->addrlen = sizeof(struct sockaddr_in);
} else {
sap->u.in6.sin6_port = htons((unsigned short) port);
if (addr)
memcpy(&sap->u.in6.sin6_addr, addr, in_len);
sap->addrlen = sizeof(struct sockaddr_in6);
}
lua_settop(L, 1);
return 1;
};
}
/*
* Arguments: sock_addr_udata, [path (string)]
* Returns: sock_addr_udata | path (string)
*/
static int
sock_addr_file (lua_State *L)
{
struct sock_addr *sap = checkudata(L, 1, SA_TYPENAME);
#ifndef _WIN32
if (lua_gettop(L) == 1) {
if (sap->u.addr.sa_family == AF_LOCAL) {
lua_pushstring(L, sap->u.un.sun_path);
return 1;
}
} else {
size_t len;
const char *path = luaL_checklstring(L, 2, &len);
if (len < sizeof(sap->u.un.sun_path)) {
sap->u.un.sun_family = AF_LOCAL;
sap->addrlen = ++len;
memcpy(sap->u.un.sun_path, path, len);
lua_settop(L, 1);
return 1;
}
};
#else
(void) sap;
#endif
return 0;
}
/*
* Arguments: sock_addr_udata, sd_udata
* Returns: [sock_addr_udata]
*/
static int
sock_addr_getsockname (lua_State *L)
{
struct sock_addr *sap = checkudata(L, 1, SA_TYPENAME);
sd_t sd = (sd_t) lua_unboxinteger(L, 2, SD_TYPENAME);
sap->addrlen = SOCK_ADDR_LEN;
if (!getsockname(sd, &sap->u.addr, &sap->addrlen)) {
lua_settop(L, 1);
return 1;
}
return sys_seterror(L, 0);
}
/*
* Arguments: sock_addr_udata, sd_udata
* Returns: [sock_addr_udata]
*/
static int
sock_addr_getpeername (lua_State *L)
{
struct sock_addr *sap = checkudata(L, 1, SA_TYPENAME);
sd_t sd = (sd_t) lua_unboxinteger(L, 2, SD_TYPENAME);
sap->addrlen = SOCK_ADDR_LEN;
if (!getpeername(sd, &sap->u.addr, &sap->addrlen)) {
lua_settop(L, 1);
return 1;
}
return sys_seterror(L, 0);
}
/*
* Arguments: sock_addr_udata
* Returns: string
*/
static int
sock_addr_tostring (lua_State *L)
{
struct sock_addr *sap = checkudata(L, 1, SA_TYPENAME);
lua_pushfstring(L, SA_TYPENAME " (%p)", sap);
return 1;
}
#define ADDR_METHODS \
{"getaddrinfo", sock_getaddrinfo}, \
{"getnameinfo", sock_getnameinfo}, \
{"getifaddrs", sock_getifaddrs}, \
{"inet_pton", sock_inet_pton}, \
{"inet_ntop", sock_inet_ntop}, \
{"addr", sock_addr_new}
static luaL_Reg addr_meth[] = {
{"inet", sock_addr_inet},
{"file", sock_addr_file},
{"getsockname", sock_addr_getsockname},
{"getpeername", sock_addr_getpeername},
{"__tostring", sock_addr_tostring},
{NULL, NULL}
};
int irc_connect6 (irc_session_t * session,
const char * server,
unsigned short port,
const char * server_password,
const char * nick,
const char * username,
const char * realname)
{
#if defined (ENABLE_IPV6)
struct sockaddr_in6 saddr;
struct addrinfo ainfo, *res = NULL;
char portStr[32], *p;
#if defined (_WIN32)
int addrlen = sizeof(saddr);
HMODULE hWsock;
getaddrinfo_ptr_t getaddrinfo_ptr;
freeaddrinfo_ptr_t freeaddrinfo_ptr;
int resolvesuccess = 0;
#endif
// Check and copy all the specified fields
if ( !server || !nick )
{
session->lasterror = LIBIRC_ERR_INVAL;
return 1;
}
if ( session->state != LIBIRC_STATE_INIT )
{
session->lasterror = LIBIRC_ERR_STATE;
return 1;
}
// Free the strings if defined; may be the case when the session is reused after the connection fails
free_ircsession_strings( session );
// Handle the server # prefix (SSL)
if ( server[0] == SSL_PREFIX )
{
#if defined (ENABLE_SSL)
server++;
session->flags |= SESSIONFL_SSL_CONNECTION;
#else
session->lasterror = LIBIRC_ERR_SSL_NOT_SUPPORTED;
return 1;
#endif
}
if ( username )
session->username = strdup (username);
if ( server_password )
session->server_password = strdup (server_password);
if ( realname )
session->realname = strdup (realname);
session->nick = strdup (nick);
session->server = strdup (server);
// If port number is zero and server contains the port, parse it
if ( port == 0 && (p = strchr( session->server, ':' )) != 0 )
{
// Terminate the string and parse the port number
*p++ = '\0';
port = atoi( p );
}
memset( &saddr, 0, sizeof(saddr) );
saddr.sin6_family = AF_INET6;
saddr.sin6_port = htons (port);
sprintf( portStr, "%u", (unsigned)port );
#if defined (_WIN32)
if ( WSAStringToAddressA( (LPSTR)session->server, AF_INET6, NULL, (struct sockaddr *)&saddr, &addrlen ) == SOCKET_ERROR )
{
hWsock = LoadLibraryA("ws2_32");
if (hWsock)
{
/* Determine functions at runtime, because windows systems < XP do not
* support getaddrinfo. */
getaddrinfo_ptr = (getaddrinfo_ptr_t)GetProcAddress(hWsock, "getaddrinfo");
freeaddrinfo_ptr = (freeaddrinfo_ptr_t)GetProcAddress(hWsock, "freeaddrinfo");
if (getaddrinfo_ptr && freeaddrinfo_ptr)
{
memset(&ainfo, 0, sizeof(ainfo));
ainfo.ai_family = AF_INET6;
ainfo.ai_socktype = SOCK_STREAM;
ainfo.ai_protocol = 0;
if ( getaddrinfo_ptr(session->server, portStr, &ainfo, &res) == 0 && res )
{
resolvesuccess = 1;
memcpy( &saddr, res->ai_addr, res->ai_addrlen );
freeaddrinfo_ptr( res );
}
}
FreeLibrary(hWsock);
}
if (!resolvesuccess)
{
session->lasterror = LIBIRC_ERR_RESOLV;
return 1;
}
}
#else
if ( inet_pton( AF_INET6, session->server, (void*) &saddr.sin6_addr ) <= 0 )
{
memset( &ainfo, 0, sizeof(ainfo) );
ainfo.ai_family = AF_INET6;
ainfo.ai_socktype = SOCK_STREAM;
ainfo.ai_protocol = 0;
if ( getaddrinfo( session->server, portStr, &ainfo, &res ) || !res )
{
session->lasterror = LIBIRC_ERR_RESOLV;
return 1;
}
memcpy( &saddr, res->ai_addr, res->ai_addrlen );
freeaddrinfo( res );
}
#endif
// create the IRC server socket
if ( socket_create( PF_INET6, SOCK_STREAM, &session->sock)
|| socket_make_nonblocking (&session->sock) )
{
session->lasterror = LIBIRC_ERR_SOCKET;
return 1;
}
#if defined (ENABLE_SSL)
// Init the SSL stuff
if ( session->flags & SESSIONFL_SSL_CONNECTION )
{
int rc = ssl_init( session );
if ( rc != 0 )
return rc;
}
#endif
// and connect to the IRC server
if ( socket_connect (&session->sock, (struct sockaddr *) &saddr, sizeof(saddr)) )
{
session->lasterror = LIBIRC_ERR_CONNECT;
return 1;
}
session->state = LIBIRC_STATE_CONNECTING;
session->flags = 0; // reset in case of reconnect
return 0;
#else
session->lasterror = LIBIRC_ERR_NOIPV6;
return 1;
#endif
}
