---

tcpsocket.cc

Go to the documentation of this file.

//**************************************************************************
// Parts of this code have been picked up from
// http://libsocket.sourceforge.net/
// written by Garrett Grice
//**************************************************************************
#include <string.h>
#include <strings.h>
#include <sys/socket.h>
#include <netdb.h>
#include <netinet/in.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <iostream.h>
#include <stdio.h>
#include "tcpsocket.h"
#include "errcode.h"
#include "misc.h"
//**************************************************************************
#if defined (HPUX) || defined (__CYGWIN32__)
#define RECV_FLAG 0
#define socklen_t int
#else
#define RECV_FLAG MSG_WAITALL
#endif
//**************************************************************************
int BlockSocket(int sockid);
int recv_all(int s, unsigned char *buf, int len, unsigned int flags);
int send_all(int s, unsigned char *buf, int len, unsigned int flags);
static double bytes_sent = 0.0, bytes_recd = 0.0;
static int time_to_send = 0, time_to_recv = 0;
//**************************************************************************
TCPSocket::TCPSocket()
{
recvfd = 0;
sockfd = 0;
}
//**************************************************************************
TCPSocket::~TCPSocket()
{
}
//**************************************************************************
bool TCPSocket::Create()
{
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd == -1)
        return false;

BlockSocket(sockfd);
return true;
}
//**************************************************************************
bool TCPSocket::Bind(int port)
{
Create();

INetAddress.sin_family = AF_INET;
INetAddress.sin_port = htons(port);
INetAddress.sin_addr.s_addr = INADDR_ANY;
bzero((char *) &(INetAddress.sin_zero), 8);

if (bind(sockfd, (struct sockaddr *) &INetAddress, sizeof(struct sockaddr)) == -1)
        {
         perror("TCPSocket::Bind");
         return false;
        }

return true;
}
//**************************************************************************
bool TCPSocket::Connect(char *server, int port)
{
hostent *Host;

Create();

if ((Host = gethostbyname(server)) == NULL)
        {
#ifndef HPUX
         perror("gethostbyname");
#endif
         return false;
        }

INetAddress.sin_family = AF_INET;
INetAddress.sin_port = htons(port);
INetAddress.sin_addr = *((struct in_addr *) Host->h_addr);
bzero((char *) &(INetAddress.sin_zero), 8);

if (connect(sockfd, (struct sockaddr *) &INetAddress, sizeof(struct sockaddr)) == -1)
        {
         perror("TCPSocket::Connect");
         return false;
        }

return true;
}
//**************************************************************************
int TCPSocket::SendBytes(int size, const void *data)
{
int sockid = recvfd ? recvfd : sockfd;
int nsent = send_all(sockid, (unsigned char*) data, size, 0);

if (nsent != size)
        {
         cout << "TCPSocket::Send: Error sending data!";
         if (nsent >= 0)
                cout << " (only " << nsent << " of " << size << " bytes sent)" << endl;
         cout << " Bad connection....throwing exception!" << endl << flush;
         int err = ERR_SEND_MESG;
         throw err;
        }

return nsent;
}
//**************************************************************************
int TCPSocket::RecvBytes(int size, void *data)
{
int sockid = recvfd ? recvfd : sockfd;
int nrecv = recv_all(sockid, (unsigned char *) data, size, RECV_FLAG);

if (nrecv != size)
        {
         cout << "TCPSocket::Recv: Error receiving data!";
         if (nrecv >= 0)
                cout << " (only " << nrecv << " of " << size << " bytes received)" << endl;
         cout << " Bad connection....throwing exception!" << endl << flush;
         int err = ERR_RECV_MESG;
         throw err;
        }

return nrecv;
}
//**************************************************************************
bool TCPSocket::Close()
{
return (close(recvfd ? recvfd : sockfd) != -1);
}
//**************************************************************************
bool TCPSocket::InboundClose()
{
return (close(recvfd) != -1);
}
//**************************************************************************
bool TCPSocket::Listen()
{
if (listen(sockfd, 5) == -1)
        {
         perror("TCPSocket::Listen");
         return false;
        }

return true;
}
//**************************************************************************
bool TCPSocket::Accept()
{
socklen_t sin_size = sizeof(struct sockaddr_in);
sockaddr_in RemoteAddress;
int maxtries = 10;
int num_tries = 0;

while (((recvfd = accept(sockfd, (struct sockaddr *) &RemoteAddress, &sin_size)) == -1) && num_tries < maxtries)
        {
         usleep(100000);
         ++num_tries;
        }
if (num_tries == maxtries)
        {
         perror("accept");
         return false;
        }
BlockSocket(recvfd);

return true;
}
//**************************************************************************
char *TCPSocket::PeerName()
{
int sockid = recvfd ? recvfd : sockfd;
static char *str = new char[100];
struct sockaddr_in name;
struct hostent *ent;
socklen_t len = sizeof(name);

getpeername(sockid, (struct sockaddr *) &name, &len);
ent = gethostbyaddr((const char *) &name.sin_addr.s_addr, sizeof(struct in_addr), AF_INET);
int size = strlen(ent->h_name);
memcpy(str, ent->h_name, size);
str[size] = '\0';

return str;
}
//**************************************************************************
int TCPSocket::PeerPort()
{
int sockid = recvfd ? recvfd : sockfd;
struct sockaddr_in name;
socklen_t len = sizeof(name);

getpeername(sockid, (struct sockaddr *) &name, &len);

return name.sin_port;
}
//**************************************************************************
char *TCPSocket::SocketName()
{
int sockid = recvfd ? recvfd : sockfd;
static char *str = new char[200];
struct sockaddr_in name;
socklen_t len = sizeof(name);
struct hostent *ent;

getsockname(sockid, (struct sockaddr *) &name, &len);
ent = gethostbyaddr((const char *) &name.sin_addr.s_addr, sizeof(struct in_addr), AF_INET);
int size = strlen(ent->h_name);
memcpy(str, ent->h_name, size);
str[size] = '\0';

return str;
}
//**************************************************************************
int TCPSocket::SocketPort()
{
int sockid = recvfd ? recvfd : sockfd;
struct sockaddr_in name;
socklen_t len = sizeof(name);

getsockname(sockid, (struct sockaddr *) &name, &len);

return name.sin_port;
}
//**************************************************************************
// Force blocking send/recv
int BlockSocket(int sockid)
{
int fflags = fcntl(sockid, F_GETFL);

fflags &= ~O_NONBLOCK;
fcntl(sockid, F_SETFL, fflags);

return 0;
}
//**************************************************************************
double TCPSocket::BytesSent()
{
return bytes_sent;
}
//**************************************************************************
double TCPSocket::BytesRecd()
{
return bytes_recd;
}
//**************************************************************************
int TCPSocket::SendTime()
{
return (time_to_send ? time_to_send : 1);
}
//**************************************************************************
int TCPSocket::RecvTime()
{
return (time_to_recv ? time_to_recv : 1);
}
//**************************************************************************
TCPSocket &TCPSocket::operator = (const TCPSocket & T)
{
if (this == &T)
        return *this;

sockfd = T.sockfd;
recvfd = T.recvfd;
memcpy(&INetAddress, &(T.INetAddress), sizeof(T.INetAddress));
memcpy(&RemoteAddress, &(T.RemoteAddress), sizeof(T.RemoteAddress));

return *this;
}
//**************************************************************************
int recv_all(int s, unsigned char *buf, int len, unsigned int flags)
{
int count;
int total = 0;
int tstart = myTimer();

while (len > 0)
        {
         count = recv(s, buf, len, flags);
         if (count == -1 && errno == EINTR)
                continue;
         if (count <= 0)
                return -1;
         buf += count;
         len -= count;
         total += count;
        }

time_to_recv += myTimer()-tstart;
bytes_recd += (double) total;
return total;
}
//**************************************************************************
int send_all(int s, unsigned char *buf, int len, unsigned int flags)
{
int count;
int total = 0;
int tstart = myTimer();

while (len > 0)
        {
         count = send(s, buf, len, flags);
         if (count == -1 && errno == EINTR)
                continue;
         if (count <= 0)
                return -1;
         buf += count;
         len -= count;
         total += count;
        }

time_to_send += myTimer()-tstart;
bytes_sent += (double) total;
return total;
}
//**************************************************************************

---