--- /dev/null
+#include "socks.h"
+#include <signal.h>
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+
+
+#if defined(__sparc__)
+#include <sys/filio.h>
+#endif
+
+#if defined(__sparc__) || (defined(WIN32) && !defined(__CYGWIN__))
+#define SOCKOPT_TYPE char *
+#else
+#define SOCKOPT_TYPE void *
+#endif
+
+#if defined(linux)
+#define SOCKOPT_LEN_TYPE unsigned
+#else
+#define SOCKOPT_LEN_TYPE int
+#endif
+
+
+
+template <typename A, typename B> bool MIN(const A &a, const B &b) {
+ return ((a < b) ? a : b);
+}
+
+
+int GetSockType(const SOCK fd) {
+ int type;
+ SOCKOPT_LEN_TYPE len = sizeof(int);
+
+ if (getsockopt(fd, SOL_SOCKET, SO_TYPE, (SOCKOPT_TYPE)&type, &len)) {
+ return -1;
+ } else {
+ return type;
+ }
+}
+
+
+int IsSocket(const SOCK fd) {
+ return (GetSockType(fd) >= 0);
+}
+
+int IsStreamSocket(const SOCK fd) {
+ return (GetSockType(fd) == SOCK_STREAM);
+}
+
+int IsDatagramSocket(const SOCK fd) {
+ return (GetSockType(fd) == SOCK_DGRAM);
+}
+
+#ifdef linux
+int IsVirtualSocket(const SOCK fd) {
+ struct stat mystat;
+ fstat(fd, &mystat);
+
+ return S_ISFIFO(mystat.st_mode);
+}
+#endif
+
+int IsValidIPMulticastAddress(const unsigned adx) {
+
+ //int x=(ntohl(port)>>24)&0xff;
+ int x = (adx >> 24) & 0xff;
+
+ if ((x < 224) || (x > 239)) {
+ return 0;
+ } else {
+ return 1;
+ }
+}
+
+void IPToHostname(const unsigned ip, char *name, const int namesize) {
+ struct in_addr ia;
+ struct hostent * he;
+
+ ia.s_addr = ip;
+
+ he = gethostbyaddr((const char *)&ia, sizeof(ia), AF_INET);
+
+ strncpy(name, he ? he->h_name : "UNKNOWN HOST", namesize - 1);
+}
+
+
+void PrintIPAddress(const unsigned adx, FILE *out) {
+ fprintf(out,"%3d.%3d.%3d.%3d",
+ (adx >> 24) & 0xff,
+ (adx >> 16) & 0xff,
+ (adx >> 8) & 0xff,
+ (adx) & 0xff);
+}
+
+unsigned ToIPAddress(const char * hostname) {
+ unsigned x;
+
+ if ((x = inet_addr(hostname)) != INADDR_NONE) {
+ return ntohl(x);
+ } else {
+ struct hostent * he;
+
+ if ((he = gethostbyname(hostname)) == NULL) {
+ return INADDR_NONE;
+ } else {
+ memcpy(&x, he->h_addr, 4);
+ x = ntohl(x);
+ return x;
+ }
+ }
+}
+
+unsigned long GetRemoteSockAddress(SOCK sock) {
+ struct sockaddr_in remote_addr;
+ unsigned long remote_ip;
+
+ if (GetRemoteSockAddress(sock, (struct sockaddr *)&remote_addr) == -1) {
+ return 0;
+ }
+
+ assert(remote_addr.sin_family == AF_INET);
+ remote_ip = ntohl(remote_addr.sin_addr.s_addr);
+ return remote_ip;
+}
+
+int GetRemoteSockAddress(SOCK sock, struct sockaddr * addr) {
+ SOCKOPT_LEN_TYPE addr_len = sizeof(struct sockaddr);
+
+ if (addr == NULL) {
+ return -1;
+ }
+
+ if (getpeername(sock, addr, &addr_len) == -1) {
+ return -1;
+ }
+
+ return 0;
+}
+
+
+unsigned long GetLocalSockAddress(SOCK sock) {
+ struct sockaddr_in local_addr;
+ unsigned long local_ip;
+
+ if (GetLocalSockAddress(sock, (struct sockaddr *)&local_addr) == -1) {
+ return 0;
+ }
+
+ assert(local_addr.sin_family == AF_INET);
+ local_ip = ntohl(local_addr.sin_addr.s_addr);
+ return local_ip;
+}
+
+int GetLocalSockAddress(SOCK sock, struct sockaddr * addr) {
+ SOCKOPT_LEN_TYPE addr_len = sizeof(struct sockaddr);
+
+ if (addr == NULL) {
+ return -1;
+ }
+
+ if (getsockname(sock, addr, &addr_len) == -1) {
+ return -1;
+ }
+
+ return 0;
+}
+
+
+int GetLocalMacAddress(const string dev_name, char * buf) {
+ return GetLocalMacAddress(dev_name.c_str(), buf);
+}
+
+int GetLocalMacAddress(const char * dev_name, char * buf) {
+#ifdef linux
+ struct ifreq mac_req;
+ SOCK fd = socket(AF_INET, SOCK_STREAM, 0);
+
+ snprintf(mac_req.ifr_name, IF_NAMESIZE, "%s", dev_name);
+
+ if (ioctl(fd, SIOCGIFHWADDR, &mac_req) < 0) {
+ cerr << "Error Could not get the local MAC Address" << endl;
+ perror("perror: ");
+ return -1;
+ }
+
+ memcpy(buf, mac_req.ifr_hwaddr.sa_data, 6);
+#elif WIN32
+ char temp_dev_name[256];
+ PIP_ADAPTER_INFO temp_adapter;
+ IP_ADAPTER_INFO AdapterInfo[16]; // Allocate information
+ // for up to 16 NICs
+ DWORD dwBufLen = sizeof(AdapterInfo); // Save memory size of buffer
+
+ DWORD dwStatus = GetAdaptersInfo(AdapterInfo, // [out] buffer to receive data
+ &dwBufLen); // [in] size of receive data buffer
+
+ assert(dwStatus == ERROR_SUCCESS); // Verify return value
+
+ temp_adapter = AdapterInfo;
+
+ while(temp_adapter) {
+ sprintf(temp_dev_name, "\\Device\\NPF_%s", temp_adapter->AdapterName);
+
+ if (strcmp(dev_name, temp_dev_name) == 0) {
+ memcpy(buf, temp_adapter->Address, 6);
+ break;
+ }
+ temp_adapter = temp_adapter->Next;
+ }
+#endif
+ return 0;
+}
+
+
+int GetOpenTcpPorts(int ** ports) {
+#ifdef linux
+ int proc_fd;
+ int num_ports = 0;
+ unsigned long rxq, txq, time_len, retr, inode, local_addr, rem_addr;
+ int d, local_port, rem_port, scan_num, timer_run, uid, timeout, state;
+ string proc_str;
+ char more[512];
+
+
+ enum {
+ TCP_ESTABLISHED = 1,
+ TCP_SYN_SENT,
+ TCP_SYN_RECV,
+ TCP_FIN_WAIT1,
+ TCP_FIN_WAIT2,
+ TCP_TIME_WAIT,
+ TCP_CLOSE,
+ TCP_CLOSE_WAIT,
+ TCP_LAST_ACK,
+ TCP_LISTEN,
+ TCP_CLOSING /* now a valid state */
+ };
+
+ /*
+ We do this because we use realloc,
+ so the first ptr-value must be null or we will realloc on some randome address
+ */
+ *ports = NULL;
+
+ proc_fd = open("/proc/net/tcp", O_RDONLY);
+ if (proc_fd == -1) {
+
+ return -1;
+ }
+ /* This supports IPv6 which we will ignore for now...
+ num = sscanf(line,
+ "%d: %64[0-9A-Fa-f]:%X %64[0-9A-Fa-f]:%X %X %lX:%lX %X:%lX %lX %d %d %ld %512s\n",
+ &d, local_addr, &local_port, rem_addr, &rem_port, &state,
+ &txq, &rxq, &timer_run, &time_len, &retr, &uid, &timeout, &inode, more);
+ */
+ GetLine(proc_fd, proc_str);
+
+ while (GetLine(proc_fd, proc_str)) {
+
+ // We pretty much stole this from netstat.c in the net-tools package
+ scan_num = sscanf(proc_str.c_str(),
+ "%d: %lX:%X %lX:%X %X %lX:%lX %X:%lX %lX %d %d %ld %512s\n",
+ &d, &local_addr, &local_port, &rem_addr, &rem_port, &state,
+ &txq, &rxq, &timer_run, &time_len, &retr, &uid, &timeout, &inode, more);
+
+ if (state == TCP_LISTEN) {
+ //printf("%s (%d)\n", ip_to_string(ntohl(local_addr)), local_port);
+ *ports = (int *)realloc((*ports), sizeof(int) * (num_ports + 1));
+
+ (*ports)[num_ports] = local_port;
+
+ num_ports++;
+ }
+ }
+
+ close(proc_fd);
+ return num_ports;
+#elif WIN32
+ LPVOID error_msg;
+ DWORD table_size = 0;
+ PMIB_TCPTABLE tcp_table;
+ DWORD dwError;
+
+ // WINXP and higher
+ // AllocateAndGetTcpExTableFromStack(&tcp_table, TRUE, GetProcessHeap(), 2, 2);
+
+ dwError = GetTcpTable(NULL, &table_size, TRUE);
+ if (dwError != ERROR_INSUFFICIENT_BUFFER) {
+ cerr << "Error: " <<dwError << endl;
+ FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
+ NULL, dwError,
+ MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+ (LPTSTR) &error_msg, 0, NULL );
+ cerr << (char *)error_msg << endl;
+ return -1;
+ }
+
+ tcp_table = (PMIB_TCPTABLE)malloc(table_size);
+
+ if (GetTcpTable(tcp_table, &table_size, TRUE)) {
+ return -1;
+ }
+
+ *ports = (int *)malloc(sizeof(int) * tcp_table->dwNumEntries);
+
+ for (unsigned int i = 0; i < tcp_table->dwNumEntries; i++) {
+ //cerr << htons((WORD)tcp_table->table[i].dwLocalPort) << endl;
+ (*ports)[i] = ntohs((WORD)tcp_table->table[i].dwLocalPort);
+ }
+
+ return tcp_table->dwNumEntries;
+#endif
+}
+
+int GetOpenUdpPorts(int ** ports) {
+#ifdef linux
+ int proc_fd;
+ int num_ports = 0;
+ char more[512];
+ int local_port, rem_port, d, state, timer_run, uid, timeout;
+ unsigned long local_addr, rem_addr;
+ unsigned long rxq, txq, time_len, retr, inode;
+ int scan_num;
+ string proc_str;
+ /*
+ We do this because we use realloc,
+ so the first ptr-value must be null or we will realloc on some randome address
+ */
+ *ports = NULL;
+
+ proc_fd = open("/proc/net/udp", O_RDONLY);
+ if (proc_fd == -1) {
+
+ return -1;
+ }
+
+ GetLine(proc_fd, proc_str);
+
+ while (GetLine(proc_fd, proc_str)) {
+
+ // We pretty much stole this from netstat.c in the net-tools package
+ scan_num = sscanf(proc_str.c_str(),
+ "%d: %lX:%X %lX:%X %X %lX:%lX %X:%lX %lX %d %d %ld %512s\n",
+ &d, &local_addr, &local_port,
+ &rem_addr, &rem_port, &state,
+ &txq, &rxq, &timer_run, &time_len, &retr, &uid, &timeout, &inode, more);
+
+
+
+ //printf("%s (%d)\n", ip_to_string(ntohl(local_addr)), local_port);
+ if (state == 0x07) {
+ *ports = (int *)realloc((*ports), sizeof(int) * (num_ports + 1));
+
+ (*ports)[num_ports] = local_port;
+
+ num_ports++;
+ }
+ }
+
+ close(proc_fd);
+ return num_ports;
+#elif WIN32
+ LPVOID error_msg;
+ DWORD table_size = 0;
+ PMIB_UDPTABLE udp_table;
+ DWORD dwError;
+
+ // WINXP and higher
+ // AllocateAndGetTcpExTableFromStack(&tcp_table, TRUE, GetProcessHeap(), 2, 2);
+
+ dwError = GetUdpTable(NULL, &table_size, TRUE);
+ if (dwError != ERROR_INSUFFICIENT_BUFFER) {
+ cerr << "Error: " <<dwError << endl;
+ FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
+ NULL, dwError,
+ MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+ (LPTSTR) &error_msg, 0, NULL );
+ cerr << (char *)error_msg << endl;
+ return -1;
+ }
+
+ udp_table = (PMIB_UDPTABLE)malloc(table_size);
+
+ if (GetUdpTable(udp_table, &table_size, TRUE)) {
+ return -1;
+ }
+
+ *ports = (int *)malloc(sizeof(int) * udp_table->dwNumEntries);
+
+ for (unsigned int i = 0; i < udp_table->dwNumEntries; i++) {
+ //cerr << htons((WORD)udp_table->table[i].dwLocalPort) << endl;
+ (*ports)[i] = ntohs((WORD)udp_table->table[i].dwLocalPort);
+ }
+
+ return udp_table->dwNumEntries;
+#endif
+}
+
+
+
+#define WELL_KNOWN_HOST ((char*)"www.cnn.com")
+#define WELL_KNOWN_PORT 80
+
+unsigned GetMyIPAddress() {
+ static unsigned adx = 0;
+ //static bool setup = false;
+ char * host;
+ short port;
+ SOCK fd;
+
+ host = getenv("RPS_WELL_KNOWN_HOST") ? getenv("RPS_WELL_KNOWN_HOST") : WELL_KNOWN_HOST;
+ port = getenv("RPS_WELL_KNOWN_PORT") ? atoi(getenv("RPS_WELL_KNOWN_PORT")) : WELL_KNOWN_PORT;
+
+ // if (setup) {
+ // return adx;
+ // } else {
+ // Connect to a well known machine and check out our socket's address
+ if ((fd = CreateAndSetupTcpSocket()) == -1) {
+ return adx;
+ } else {
+ if (ConnectToHost(fd, host, port) == -1) {
+ CLOSE(fd);
+ return adx;
+ }
+
+ adx = GetLocalSockAddress(fd);
+
+ CLOSE(fd);
+ return adx;
+ }
+ //}
+}
+
+SOCK CreateAndSetupUdpSocket(const int bufsize, const bool nonblocking) {
+ SOCK mysocket;
+ int val = 0;
+
+ // create socket for connections
+ if ((mysocket = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
+ return -1;
+ }
+
+ // set reuseaddr to avoid binding problems
+ if (setsockopt(mysocket, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(int))) {
+ return -1;
+ }
+
+ val = bufsize;
+
+ if (setsockopt(mysocket, SOL_SOCKET, SO_SNDBUF,
+ (const char*) &val, sizeof(val)) < 0) {
+ CLOSE(mysocket);
+ return -1;
+ }
+
+ val = bufsize;
+
+ if (setsockopt(mysocket, SOL_SOCKET, SO_RCVBUF,
+ (const char*)&val, sizeof(val)) < 0) {
+ CLOSE(mysocket);
+ return -1;
+ }
+
+ if (nonblocking) {
+ val = 1;
+ if (IOCTL(mysocket, FIONBIO, &val)) {
+ CLOSE(mysocket);
+ return -1;
+ }
+ }
+
+ return mysocket;
+}
+
+
+SOCK CreateAndSetupTcpSocket(const int bufsize, const bool nodelay, const bool nonblocking) {
+ SOCK mysocket;
+ int val = 1;
+
+ // create socket for connections
+ if ((mysocket = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
+ return -1;
+ }
+
+ // set reuseaddr to avoid binding problems
+ if (setsockopt(mysocket, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(int))) {
+ return -1;
+ }
+
+ // Set nodelay so that our messages get
+ if (nodelay) {
+ val = 1;
+ if (setsockopt(mysocket, IPPROTO_TCP, TCP_NODELAY, (const char *)&val, sizeof(int))) {
+ CLOSE(mysocket);
+ return -1;
+ }
+ }
+
+ val = bufsize;
+
+ if (setsockopt(mysocket, SOL_SOCKET, SO_SNDBUF,
+ (const char*) &val, sizeof(val)) < 0) {
+ CLOSE(mysocket);
+ return -1;
+ }
+
+ val = bufsize;
+
+ if (setsockopt(mysocket, SOL_SOCKET, SO_RCVBUF,
+ (const char*)&val, sizeof(val)) < 0) {
+ CLOSE(mysocket);
+ return -1;
+ }
+
+ if (nonblocking) {
+ val = 1;
+ if (IOCTL(mysocket, FIONBIO, &val)) {
+ CLOSE(mysocket);
+ return -1;
+ }
+ }
+
+ return mysocket;
+}
+
+
+SOCK CreateAndSetupUnixDomainSocket(const int bufsize, const bool nonblocking) {
+ SOCK mysocket;
+ int val;
+
+ // create socket for connections
+ if ((mysocket = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
+ return -1;
+ }
+
+ // set reuseaddr to avoid binding problems
+ if (setsockopt(mysocket, SOL_SOCKET, SO_REUSEADDR, (const char *)&val, sizeof(int))) {
+ return -1;
+ }
+
+ val = bufsize;
+
+ if (setsockopt(mysocket, SOL_SOCKET, SO_SNDBUF,
+ (const char*)&val, sizeof(val)) < 0) {
+ CLOSE(mysocket);
+ return -1;
+ }
+
+ val = bufsize;
+
+ if (setsockopt(mysocket, SOL_SOCKET, SO_RCVBUF,
+ (const char*)&val, sizeof(val)) < 0) {
+ CLOSE(mysocket);
+ return -1;
+ }
+
+ if (nonblocking) {
+ val = 1;
+ if (IOCTL(mysocket, FIONBIO, &val)) {
+ CLOSE(mysocket);
+ return -1;
+ }
+ }
+
+ return mysocket;
+}
+
+
+int SetNoDelaySocket(const SOCK fd, const bool nodelay) {
+ int val = nodelay == true;
+
+ // Set nodelay so that our messages get
+ return setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, (const char *)&val, sizeof(int));
+}
+
+
+int BindSocket(const SOCK mysocket, const unsigned adx, const int myport) {
+ struct sockaddr_in my_sa;
+
+ memset(&my_sa, 0, sizeof(my_sa));
+ my_sa.sin_port = htons(myport);
+ my_sa.sin_addr.s_addr = htonl(adx);
+ my_sa.sin_family = AF_INET;
+
+ if (bind(mysocket, (struct sockaddr *)&my_sa, sizeof(my_sa))) {
+ return -1;
+ }
+ return 0;
+}
+
+int BindSocket(const SOCK mysocket, const int myport) {
+ return BindSocket(mysocket, (unsigned)INADDR_ANY, myport);
+}
+
+int BindSocket(const SOCK mysocket, const char *host_or_ip, const int myport) {
+ return BindSocket(mysocket, ToIPAddress(host_or_ip), myport);
+}
+
+int BindSocket(const SOCK mysocket, const char *pathname) {
+#if defined(WIN32) && !defined(__CYGWIN__)
+ return -1;
+#else
+ struct sockaddr_un my_sa;
+ int len;
+
+ memset(&my_sa, 0, sizeof(my_sa));
+ my_sa.sun_family = AF_UNIX;
+ strcpy(my_sa.sun_path, pathname);
+ len = strlen(my_sa.sun_path) + sizeof(my_sa.sun_family);
+
+ if (bind(mysocket, (struct sockaddr *)&my_sa,len)) {
+ return -1;
+ }
+ return 0;
+#endif
+}
+
+
+int ListenSocket(const SOCK mysocket, const int maxc) {
+ int maxcon = MIN(maxc, SOMAXCONN);
+ return listen(mysocket, maxcon);
+}
+
+int ConnectToHost(const SOCK mysocket, const int hostip, const int port) {
+ struct sockaddr_in sa;
+
+ memset(&sa, 0, sizeof(sa));
+ sa.sin_port = htons(port);
+ sa.sin_addr.s_addr = htonl(hostip);
+ sa.sin_family = AF_INET;
+
+ return connect(mysocket, (struct sockaddr *)&sa, sizeof(sa));
+}
+
+
+int ConnectToHost(const SOCK mysocket, const char *host, const int port) {
+ return ConnectToHost(mysocket, ToIPAddress(host), port);
+}
+
+
+int ConnectToPath(const SOCK mysocket, const char *pathname) {
+#if defined(WIN32) && !defined(__CYGWIN__)
+ return -1;
+#else
+ struct sockaddr_un my_sa;
+ int len;
+
+ memset(&my_sa, 0, sizeof(my_sa));
+ my_sa.sun_family = AF_UNIX;
+ strcpy(my_sa.sun_path, pathname);
+ len = strlen(my_sa.sun_path) + sizeof(my_sa.sun_family);
+
+ if (connect(mysocket, (struct sockaddr *)&my_sa,len)) {
+ return -1;
+ }
+ return 0;
+#endif
+}
+
+
+
+int JoinMulticastGroup(const SOCK mysocket, const unsigned adx) {
+ if (!IsValidIPMulticastAddress(adx)) {
+ return -1;
+ }
+
+ struct ip_mreq req;
+
+ memset(&req, 0, sizeof(req));
+
+ req.imr_multiaddr.s_addr = htonl(adx);
+ req.imr_interface.s_addr = htonl(INADDR_ANY);
+
+ if (setsockopt(mysocket, IPPROTO_IP, IP_ADD_MEMBERSHIP,
+ (const char*)&req, sizeof(req)) < 0) {
+ return -1;
+ }
+ return 0;
+}
+
+int JoinMulticastGroup(const SOCK mysocket, const char *IP) {
+ return JoinMulticastGroup(mysocket, ToIPAddress(IP));
+}
+
+
+int LeaveMulticastGroup(const SOCK mysocket, const unsigned adx) {
+ if (!IsValidIPMulticastAddress(adx)) {
+ return -1;
+ }
+
+ struct ip_mreq req;
+
+ memset(&req, 0, sizeof(req));
+
+ req.imr_multiaddr.s_addr = htonl(adx);
+ req.imr_interface.s_addr = htonl(INADDR_ANY);
+
+ if (setsockopt(mysocket, IPPROTO_IP, IP_DROP_MEMBERSHIP,
+ (const char *) &req, sizeof(req)) < 0) {
+ return -1;
+ }
+
+ return 0;
+}
+
+
+int LeaveMulticastGroup(const SOCK mysocket, const char *IP) {
+ return LeaveMulticastGroup(mysocket, ToIPAddress(IP));
+}
+
+
+
+int SetMulticastTimeToLive(const SOCK mysocket, const unsigned char ttl) {
+ if (setsockopt(mysocket, IPPROTO_IP, IP_MULTICAST_TTL,
+ (SOCKOPT_TYPE)&ttl, (SOCKOPT_LEN_TYPE)sizeof(ttl)) < 0) {
+ return -1;
+ }
+ return 0;
+}
+
+int SendTo(const SOCK mysocket,
+ const unsigned ip, const int port,
+ const char *buf, const int len, const bool sendall) {
+ struct sockaddr_in sa;
+
+ memset(&sa, 0, sizeof(sockaddr_in));
+ sa.sin_family = AF_INET;
+ sa.sin_addr.s_addr = htonl(ip);
+ sa.sin_port = htons(port);
+
+ if (!sendall) {
+ return sendto(mysocket, buf, len, 0, (struct sockaddr *)&sa, sizeof(sockaddr_in));
+ } else {
+ int left = len;
+ int sent;
+ while (left > 0) {
+ sent = sendto(mysocket, &(buf[len - left]), left, 0, (struct sockaddr *)&sa, sizeof(sockaddr_in));
+ if (sent < 0) {
+ if (errno == EINTR) {
+ continue;
+ } else {
+ return -1;
+ }
+ } else {
+ left -= sent;
+ }
+ }
+ return len;
+ }
+}
+
+
+int ReceiveFrom(const SOCK mysocket,
+ const unsigned ip, const int port,
+ char *buf, const int len,
+ const bool recvall)
+{
+ struct sockaddr_in sa;
+ SOCKOPT_LEN_TYPE size = sizeof(sockaddr_in);
+
+ memset(&sa, 0, sizeof(sockaddr_in));
+ sa.sin_family = AF_INET;
+ sa.sin_addr.s_addr = htonl(ip);
+ sa.sin_port = htons(port);
+
+ if (!recvall) {
+ return recvfrom(mysocket, buf, len, 0, (struct sockaddr *)&sa, &size);
+ } else {
+ int left = len;
+ int received;
+ while (left > 0) {
+ received = recvfrom(mysocket, &(buf[len - left]), left, 0, (struct sockaddr *)&sa, &size);
+ if (received < 0) {
+ if (errno == EINTR) {
+ continue;
+ } else {
+ return -1;
+ }
+ } else if (received == 0) {
+ break;
+ } else {
+ left -= received;
+ }
+ }
+ return len - left;
+ }
+}
+
+int SendTo(const SOCK mysocket,
+ const char *host_or_ip, const int port,
+ const char *buf, const int len, const bool sendall) {
+ return SendTo(mysocket, ToIPAddress(host_or_ip), port, buf, len, sendall);
+}
+
+int ReceiveFrom(const SOCK mysocket,
+ const char *host_or_ip, const int port,
+ char *buf, const int len, const bool recvall) {
+ return ReceiveFrom(mysocket, ToIPAddress(host_or_ip), port, buf, len, recvall);
+}
+
+
+#if defined(USE_SSL)
+
+int Send(SOCK fd, SSL *ssl, const char *buf, const int len, const bool sendall) {
+ if (!sendall) {
+ if (ssl != NULL) {
+ return SSL_write(ssl, buf, len);
+ } else {
+ return write(fd, buf, len);
+ }
+ } else {
+ int left = len;
+ int sent;
+ while (left > 0) {
+ if (ssl != NULL) {
+ sent = SSL_write(ssl, &(buf[len - left]), left);
+ } else {
+ sent = write(fd, &(buf[len - left]), left);
+ }
+
+ if (sent < 0) {
+ if (errno == EINTR) {
+ continue;
+ } else {
+ return -1;
+ }
+ } else if (sent == 0) {
+ break;
+ } else {
+ left -= sent;
+ }
+ }
+ return len - left;
+ }
+}
+
+int Receive(SOCK fd, SSL *ssl, char *buf, const int len, const bool recvall) {
+ if (!recvall) {
+ if (ssl != NULL) {
+ return SSL_read(ssl, buf, len);
+ } else {
+ return read(fd, buf, len);
+ }
+ } else {
+ int left = len;
+ int received;
+
+ while (left > 0) {
+ if (ssl != NULL) {
+ received = SSL_read(ssl, &(buf[len - left]), left);
+ } else {
+ received = read(fd, &(buf[len - left]), left);
+ }
+
+ if (received < 0) {
+ if (errno == EINTR) {
+ continue;
+ } else {
+ return -1;
+ }
+ } else if (received == 0) {
+ return 0;
+ } else {
+ left -= received;
+ }
+ }
+ return len - left;
+ }
+}
+
+
+int GetLine(SOCK fd, SSL *ssl, string &s) {
+ char c;
+ s.erase(s.begin(), s.end());
+ while (1) {
+ int rc = Receive(fd, ssl, &c, 1, true);
+ if (rc < 0) {
+ return rc;
+ }
+ if ((rc == 0) || (c == '\n')) {
+ return s.size();
+ }
+ s += c;
+ }
+}
+
+
+int PutLine(SOCK fd, SSL *ssl, const string &s) {
+ string s2 = s;
+ s2 += '\n';
+ return (Send(fd, ssl, s2.c_str(), s2.size(), true) - 1);
+}
+#endif
+
+int Send(SOCK fd, const char *buf, const int len, const bool sendall) {
+ if (!sendall) {
+ return WRITE(fd, buf, len);
+ } else {
+ int left = len;
+ int sent;
+ while (left > 0) {
+ sent = WRITE(fd, &(buf[len - left]), left);
+
+ if (sent < 0) {
+ if (errno == EINTR) {
+ continue;
+ } else {
+ return -1;
+ }
+ } else if (sent == 0) {
+ break;
+ } else {
+ left -= sent;
+ }
+ }
+ return len - left;
+ }
+}
+
+int Receive(SOCK fd, char *buf, const int len, const bool recvall) {
+ if (!recvall) {
+ return READ(fd, buf, len);
+ } else {
+ int left = len;
+ int received;
+
+ while (left > 0) {
+ received = READ(fd, &(buf[len - left]), left);
+
+ if (received < 0) {
+ if (errno == EINTR) {
+ continue;
+ } else {
+ return -1;
+ }
+ } else if (received == 0) {
+ return 0;
+ } else {
+ left -= received;
+ }
+ }
+ return len - left;
+ }
+}
+
+
+int GetLine(SOCK fd, string &s) {
+ char c;
+ s.erase(s.begin(), s.end());
+
+ while (1) {
+ int rc = Receive(fd, &c, 1, true);
+
+ if (rc < 0) {
+ return rc;
+ }
+
+ if ((rc == 0) || (c == '\n')) {
+ return s.size();
+ }
+
+ s += c;
+ }
+}
+
+
+int PutLine(SOCK fd, const string &s) {
+ string s2 = s;
+ s2 += '\n';
+ return (Send(fd, s2.c_str(), s2.size(), true) - 1);
+}
+
+
+
+
+int SetSignalHandler(const int signum, void (*handler)(int), const bool oneshot)
+{
+#if defined(WIN32) || defined(CYGWIN) // cygwin does not appear to have sigaction, so...
+ signal(signum,handler); //notice that this is oneshot
+ return 0;
+#else
+ struct sigaction sa;
+
+#if defined(__sparc__)
+ sa.sa_handler= (void (*)(...)) handler; // SUN FREAKS
+#else
+ sa.sa_handler=handler;
+#endif
+
+ sigemptyset(&(sa.sa_mask));
+#if defined(linux)
+#define SIGHAND_ONESHOT SA_ONESHOT
+#endif
+#if defined(__osf__) || defined(__FreeBSD__) || defined(__sparc__)
+#define SIGHAND_ONESHOT SA_RESETHAND
+#endif
+
+ sa.sa_flags = ((oneshot == true) ? SIGHAND_ONESHOT : 0);
+#if defined(linux)
+ sa.sa_restorer = 0;
+#endif
+
+ return sigaction(signum, &sa, 0);
+#endif
+}
+
+
+int IgnoreSignal(const int signum)
+{
+ return SetSignalHandler(signum, SIG_IGN);
+}
+
+int ListenToSignal(const int signum)
+{
+ return SetSignalHandler(signum, SIG_DFL);
+}
+
+#if defined(WIN32) && !defined(__CYGWIN__)
+
+class SockInit {
+public:
+ SockInit() {
+ WSADATA foo;
+ WSAStartup(MAKEWORD(2,0),&foo);
+ }
+ ~SockInit() {
+ if (WSAIsBlocking()) {
+ WSACancelBlockingCall();
+ }
+ WSACleanup();
+ }
+};
+
+SockInit thesockinit; // constructor should get called on startup.
+#endif
+
+
