NETLIB_BOOLEAN is_local_udp_port_used(const char *itf, int port)
{
struct sockaddr_in raddr;
Socket localsock;
if (!itf) {
raddr.sin_addr.s_addr = htons(INADDR_ANY);
} else {
raddr.sin_addr.s_addr = inet_addr(itf);
}
raddr.sin_port = htons((short)port);
raddr.sin_family = AF_INET;
if ((localsock = socket(PF_INET, SOCK_DGRAM, 0)) == -1) {
NETLIB_LOG_ERROR(make_error_string("is_local_udp_port_used : socket"));
return NETLIB_TRUE;
}
if (allow_address_reuse(localsock) < 0) {
NETLIB_LOG_ERROR(make_error_string("is_local_udp_port_used : setsockopt"));
closesocket(localsock);
return NETLIB_TRUE;
}
if (bind(localsock, (struct sockaddr *)&raddr, sizeof (raddr)) < 0) {
NETLIB_LOG_ERROR(make_error_string("is_local_udp_port_used : bind"));
closesocket(localsock);
return NETLIB_TRUE;
}
closesocket(localsock);
return NETLIB_FALSE;
}
void PacketSender::close_socket(SocketType type, const NetworkInterface &iface) {
if(type == ETHER_SOCKET) {
#if defined(BSD) || defined(__FreeBSD_kernel__)
BSDEtherSockets::iterator it = _ether_socket.find(iface.id());
if(it == _ether_socket.end())
throw invalid_socket_type();
if(::close(it->second) == -1)
throw socket_close_error(make_error_string());
_ether_socket.erase(it);
#elif !defined(WIN32)
if(_ether_socket == INVALID_RAW_SOCKET)
throw invalid_socket_type();
if(::close(_ether_socket) == -1)
throw socket_close_error(make_error_string());
_ether_socket = INVALID_RAW_SOCKET;
#endif
}
else {
if(type >= SOCKETS_END || _sockets[type] == INVALID_RAW_SOCKET)
throw invalid_socket_type();
#ifndef WIN32
if(close(_sockets[type]) == -1)
throw socket_close_error(make_error_string());
#else
closesocket(_sockets[type]);
#endif
_sockets[type] = INVALID_RAW_SOCKET;
}
}
void PacketSender::open_l2_socket(const NetworkInterface& iface) {
#if defined(BSD) || defined(__FreeBSD_kernel__)
int sock = -1;
// At some point, there should be an available device
for (int i = 0; sock == -1;i++) {
std::ostringstream oss;
oss << "/dev/bpf" << i;
sock = open(oss.str().c_str(), O_RDWR);
}
if(sock == -1)
throw socket_open_error(make_error_string());
struct ifreq ifr;
strncpy(ifr.ifr_name, iface.name().c_str(), sizeof(ifr.ifr_name) - 1);
if(ioctl(sock, BIOCSETIF, (caddr_t)&ifr) < 0) {
::close(sock);
throw socket_open_error(make_error_string());
}
_ether_socket[iface.id()] = sock;
#else
if (_ether_socket == INVALID_RAW_SOCKET) {
_ether_socket = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_ALL));
if (_ether_socket == -1)
throw socket_open_error(make_error_string());
}
#endif
}
NETLIB_BOOLEAN is_connection_available()
{
#if defined(OS_WIN32)
DWORD flags;
if(!InternetGetConnectedState(&flags, 0))
return false;
return (flags & INTERNET_CONNECTION_LAN
|| flags & INTERNET_CONNECTION_MODEM);
#elif defined(OS_MACOSX)
// TODO: to be implemented
return NETLIB_TRUE;
#else
NETLIB_BOOLEAN res = NETLIB_FALSE;
int sock;
char buf[BUFSIZ];
struct ifconf ifc;
memset(&ifc, 0, sizeof ifc);
ifc.ifc_len = sizeof buf;
ifc.ifc_buf = (char *)buf;
if ((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
NETLIB_LOG_ERROR(make_error_string("is_connection_available : socket"));
return NETLIB_FALSE;
}
if (ioctl(sock, SIOCGIFCONF, &ifc) == -1) {
closesocket(sock);
NETLIB_LOG_ERROR(make_error_string("is_connection_available : ioctl"));
return NETLIB_FALSE;
}
for (unsigned int i = 0; i < (ifc.ifc_len / sizeof(struct ifreq)); i++) {
if (ioctl(sock, SIOCGIFFLAGS, &ifc.ifc_req[i]) == 0) {
if ((ifc.ifc_req[i]).ifr_ifru.ifru_flags & IFF_LOOPBACK) {
continue;
}
if ((ifc.ifc_req[i]).ifr_ifru.ifru_flags & IFF_RUNNING) {
res = NETLIB_TRUE;
}
}
}
closesocket(sock);
return res;
#endif
}
void PacketSender::send_l3(PDU &pdu, struct sockaddr* link_addr, uint32_t len_addr, SocketType type) {
open_l3_socket(type);
int sock = _sockets[type];
PDU::serialization_type buffer = pdu.serialize();
if(sendto(sock, (const char*)&buffer[0], buffer.size(), 0, link_addr, len_addr) == -1)
throw socket_write_error(make_error_string());
}
int get_local_free_udp_port(const char *itf)
{
struct sockaddr_in raddr;
struct sockaddr_in name;
int name_size = sizeof (struct sockaddr_in);
Socket localsock;
if (!itf) {
raddr.sin_addr.s_addr = htons(INADDR_ANY);
} else {
raddr.sin_addr.s_addr = inet_addr(itf);
}
raddr.sin_port = htons(0);
raddr.sin_family = AF_INET;
if ((localsock = socket(PF_INET, SOCK_DGRAM, 0)) == -1) {
NETLIB_LOG_ERROR(make_error_string("get_local_free_udp_port : socket"));
return -1;
}
if (allow_address_reuse(localsock) < 0) {
NETLIB_LOG_ERROR(make_error_string("is_local_udp_port_used : setsockopt"));
closesocket(localsock);
return -1;
}
if (bind(localsock, (struct sockaddr *)&raddr, sizeof (raddr)) < 0) {
NETLIB_LOG_ERROR(make_error_string("get_local_free_udp_port : bind"));
closesocket(localsock);
return -1;
}
if (getsockname(localsock, (struct sockaddr *) &name, (socklen_t *)&name_size) < 0) {
NETLIB_LOG_ERROR(make_error_string("get_local_free_udp_port : getsockname"));
closesocket(localsock);
return -1;
}
closesocket(localsock);
return ntohs(name.sin_port);
}
void PacketSender::send_l2(PDU &pdu, struct sockaddr* link_addr,
uint32_t len_addr, const NetworkInterface &iface)
{
int sock = get_ether_socket(iface);
PDU::serialization_type buffer = pdu.serialize();
if(!buffer.empty()) {
#if defined(BSD) || defined(__FreeBSD_kernel__)
if(::write(sock, &buffer[0], buffer.size()) == -1)
#else
if(::sendto(sock, &buffer[0], buffer.size(), 0, link_addr, len_addr) == -1)
#endif
throw socket_write_error(make_error_string());
}
}
void PacketSender::open_l3_socket(SocketType type) {
int socktype = find_type(type);
if(socktype == -1)
throw invalid_socket_type();
if(_sockets[type] == INVALID_RAW_SOCKET) {
int sockfd;
sockfd = socket((type == IPV6_SOCKET) ? AF_INET6 : AF_INET, SOCK_RAW, socktype);
if (sockfd < 0)
throw socket_open_error(make_error_string());
const int on = 1;
#ifndef WIN32
typedef const void* option_ptr;
#else
typedef const char* option_ptr;
#endif
setsockopt(sockfd, IPPROTO_IP, IP_HDRINCL,(option_ptr)&on,sizeof(on));
_sockets[type] = sockfd;
}
}
NETLIB_BOOLEAN
udp_sip_ping
(
const char * sip_server,
unsigned short sip_port,
unsigned short local_port,
int ping_timeout,
const char * sip_address,
const char * sip_realm
)
{
int return_code ;
OWSLSocket udp_socket ;
struct sockaddr * local_address ;
struct sockaddr * remote_address ;
char * ip = OWSL_LOCAL_ADDRESS ;
char public_ip [OWSL_IP_MAX_SIZE] ;
if (owsl_address_public_ip_get (OWSL_AF_IPV4, public_ip, sizeof (public_ip)) == 0)
{
ip = public_ip ;
}
/* TODO: IPv6 support in netlib */
udp_socket = owsl_socket_by_type (OWSL_TYPE_IPV4_UDP) ;
if (udp_socket <= 0)
{
return NETLIB_FALSE ;
}
return_code = owsl_reuse_set (udp_socket) ;
if (return_code != 0)
{
owsl_close (udp_socket) ;
return NETLIB_FALSE ;
}
/* TODO: IPv6 support in netlib */
local_address = owsl_address_ip_port_new (OWSL_AF_IPV4, ip, local_port) ;
if (local_address == NULL)
{
owsl_close (udp_socket) ;
return NETLIB_FALSE ;
}
return_code = owsl_bind (udp_socket, local_address, /*OWSL_ADDRESS_SIZE*/sizeof(struct sockaddr)) ;
free (local_address) ;
if (return_code != 0)
{
owsl_close (udp_socket) ;
return NETLIB_FALSE ;
}
/* TODO: IPv6 support in netlib */
remote_address = owsl_address_port_new (OWSL_AF_IPV4, sip_server, sip_port) ;
if (remote_address == NULL)
{
owsl_close (udp_socket) ;
return NETLIB_FALSE ;
}
return_code = owsl_connect (udp_socket, remote_address, /*OWSL_ADDRESS_SIZE*/sizeof(struct sockaddr)) ;
free (remote_address) ;
if (return_code != 0)
{
NETLIB_LOG_ERROR (make_error_string ("udp_sip_ping : connect")) ;
owsl_close (udp_socket) ;
return NETLIB_FALSE ;
}
return_code = sip_ping (udp_socket, ping_timeout, sip_address, sip_realm) ;
owsl_close (udp_socket) ;
return return_code == 0 ? NETLIB_TRUE : NETLIB_FALSE ;
}
static int
sip_ping
(
OWSLSocket socket,
int ping_timeout,
const char * sip_login,
const char * sip_realm
)
{
int return_code ;
char * request ;
struct timeval timeout ;
fd_set read_sockets ;
char response [1024] ;
request = ping_request_new (sip_login, sip_realm, socket) ;
if (request == NULL)
{
return -1 ;
}
return_code = owsl_send (socket, request, strlen (request), 0) ;
if (return_code <= 0)
{
free (request) ;
return -1 ;
}
free (request) ;
timeout.tv_sec = ping_timeout ;
timeout.tv_usec = 0 ;
FD_ZERO (& read_sockets) ;
FD_SET (socket, & read_sockets) ;
return_code = owsl_select (socket + 1, & read_sockets, NULL, NULL, & timeout) ;
if (return_code < 1 || ! FD_ISSET (socket, & read_sockets))
{
if (return_code == 0)
{
NETLIB_LOG_ERROR ("sip_ping : select : timeout reached\n") ;
}
else
{
NETLIB_LOG_ERROR (make_error_string ("sip_ping : select")) ;
}
return -1 ;
}
return_code = owsl_recv (socket, response, sizeof (response), 0) ;
if (return_code < 1)
{
if (return_code == 0)
{
NETLIB_LOG_ERROR ("sip_ping : recv : returns 0\n") ;
}
else
{
NETLIB_LOG_ERROR (make_error_string ("sip_ping : recv")) ;
}
return -1 ;
}
return 0 ;
}
int _getProxyAddress()
{
#if defined OS_WIN32 && defined CC_MSVC
long ret;
HKEY result;
char url[1024];
DWORD size = 1024;
char TempPath[MAX_PATH];
char TempFile[MAX_PATH];
HMODULE hModJS;
DWORD enable;
DWORD enablesize = sizeof(DWORD);
/* MSDN EXAMPLE */
char url1[1025] = "http://www.google.fr/about.html";
char host[256] = "http://www.google.fr";
char proxyBuffer[1024];
char * proxy = proxyBuffer;
ZeroMemory(proxy, 1024);
DWORD dwProxyHostNameLength = 1024;
DWORD returnVal;
// Declare function pointers for the three autoproxy functions
pfnInternetInitializeAutoProxyDll pInternetInitializeAutoProxyDll;
pfnInternetDeInitializeAutoProxyDll pInternetDeInitializeAutoProxyDll;
pfnInternetGetProxyInfo pInternetGetProxyInfo;
/* ************ */
ret = RegOpenKeyExA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings", 0, KEY_QUERY_VALUE, & result);
ret = RegQueryValueExA(result, "ProxyEnable", 0, 0, (LPBYTE) & enable, & enablesize);
ret = RegQueryValueExA(result, "ProxyServer", 0, 0, (LPBYTE)url, & size);
if (ret == ERROR_SUCCESS && enable == 1) {
if (_parseProxyUrl(url) == 0) {
RegCloseKey(result);
return 0;
}
}
ZeroMemory(url, 1024);
size = 1024;
ret = RegQueryValueExA(result, "AutoConfigURL", 0, 0, (LPBYTE)url, & size);
RegCloseKey(result);
if (ret != ERROR_SUCCESS) {
if (DetectAutoProxyUrl(url, size, PROXY_AUTO_DETECT_TYPE_DHCP | PROXY_AUTO_DETECT_TYPE_DNS_A) == false) {
NETLIB_LOG_ERROR(make_error_string("_getProxyAddress : DetectAutoProxyUrl"));
return -1;
}
}
GetTempPathA(sizeof(TempPath), TempPath);
GetTempFileNameA(TempPath, NULL, 0, TempFile);
if (URLDownloadToFileA(NULL, url, TempFile, NULL, NULL) != S_OK) {
NETLIB_LOG_ERROR(make_error_string("_getProxyAddress : URLDownloadToFileA"));
return -1;
}
if (!(hModJS = LoadLibraryA("jsproxy.dll"))) {
NETLIB_LOG_ERROR(make_error_string("_getProxyAddress : LoadLibrary"));
return -1;
}
if (!(pInternetInitializeAutoProxyDll = (pfnInternetInitializeAutoProxyDll)
GetProcAddress(hModJS, "InternetInitializeAutoProxyDll")) ||
!(pInternetDeInitializeAutoProxyDll = (pfnInternetDeInitializeAutoProxyDll)
GetProcAddress(hModJS, "InternetDeInitializeAutoProxyDll")) ||
!(pInternetGetProxyInfo = (pfnInternetGetProxyInfo)
GetProcAddress(hModJS, "InternetGetProxyInfo"))) {
NETLIB_LOG_ERROR(make_error_string("_getProxyAddress : GetProcAddress"));
return -1;
}
if (!(returnVal = pInternetInitializeAutoProxyDll(0, TempFile, NULL, 0, NULL))) {
NETLIB_LOG_ERROR(make_error_string("_getProxyAddress : pInternetInitializeAutoProxyDll"));
return -1;
}
DeleteFileA(TempFile);
if (!pInternetGetProxyInfo((LPSTR)url1, sizeof(url1),
(LPSTR)host, sizeof(host),
&proxy, &dwProxyHostNameLength)) {
NETLIB_LOG_ERROR(make_error_string("_getProxyAddress : pInternetGetProxyInfo"));
return -1;
}
if (strncmp("PROXY ", proxy, 6) == 0) {
if (_parseProxyUrl(proxy + 6) != 0) {
NETLIB_LOG_ERROR(make_error_string("_getProxyAddress : _parseProxyUrl"));
return -1;
}
}
else {
NETLIB_LOG_ERROR("_getProxyAddress : strncmp : PROXY doesn't match\n");
return -1;
}
if (!pInternetDeInitializeAutoProxyDll(NULL, 0)) {
NETLIB_LOG_ERROR(make_error_string("_getProxyAddress : pInternetDeInitializeAutoProxyDll"));
return -1;
}
#endif
return 0;
}
