socket.cpp

#include "socket.h"

Socket::Socket()
{
    m_sock = FAIL; //sock is failed until you initialization
    memset ( &m_addr,0,sizeof ( m_addr ) ); //reset the sock's address to zero

}
Socket::~Socket()
{
    if ( is_valid() )
        ::close ( m_sock );
}

bool Socket::create()
{
    struct timeval timeout;      
    timeout.tv_sec = socketTimeOut;
    timeout.tv_usec = 0;

    m_sock = socket ( AF_INET, SOCK_STREAM, 0 );
    if ( ! is_valid() )
        return false;
    int on = 1;
    if (setsockopt (m_sock, SOL_SOCKET, SO_REUSEADDR, (const char*)&on,sizeof(on)) == FAIL )
        return false;

    if (setsockopt (m_sock, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout,sizeof(timeout)) == FAIL)
        return false;

    return true;

}

bool Socket::connect ( const std::string host, const int port )
{

    struct hostent *he;
    if ((he = gethostbyname(host.c_str())) == NULL)
        return false;

    if ( ! is_valid() ) return false;

    m_addr.sin_family = AF_INET;
    m_addr.sin_port = htons ( port );
    m_addr.sin_addr.s_addr = *(long*)(he->h_addr);

    int status = inet_pton ( AF_INET, host.c_str(), &m_addr.sin_addr );

    if ( errno == EAFNOSUPPORT ) return false;

    status = ::connect ( m_sock, ( sockaddr * ) &m_addr, sizeof ( m_addr ) );

    if ( status != FAIL )
        return true;
    else
        return false;
}
void Socket::close()
{
    shutdown(m_sock,SHUT_RDWR);
    if (is_valid())
        std::cout << "couldnt close the socket" << m_sock << std::endl;
    else
        std::cout << "socket is close" << std::endl;
}

bool Socket::send ( const std::string s ) const
{
    int status = ::send ( m_sock, s.c_str(), s.size(), MSG_NOSIGNAL );
    if ( status == FAIL )
    {
        return false;
    }
    else
    {
        return true;
    }
}

bool Socket::recv() const
{
    const int buffsize = 1024;
    char buf[buffsize];
    std::string p;
    p.clear();
    bzero(buf, sizeof(buf));
    int status;
    std::cout << "recieving..." << std::endl;
    while ((status = ::recv(m_sock, buf, buffsize, 0)) > 0)
    {

        p = buf;
        std::cout << p << std::endl;
        bzero(buf, sizeof(buf));
    }
    if (status != FAIL)
    {
        std::cout << "recieved" << std::endl;
        return true;
    }
    return false;
}
bool Socket::bind ( const int port )
{

    if ( ! is_valid() ) { return false; }

    m_addr.sin_family = AF_INET;
    m_addr.sin_addr.s_addr = INADDR_ANY;
    m_addr.sin_port = htons ( port );

    int bind_return = ::bind ( m_sock, ( struct sockaddr * ) &m_addr,  sizeof ( m_addr ) );


    if ( bind_return == FAIL ){ return false; }
    return true;
}


bool Socket::listen() const
{
    if ( ! is_valid() )
    {
        return false;
    }

    int listen_return = ::listen ( m_sock, MAXCONNECTIONS );


    if ( listen_return == FAIL )
    {
        return false;
    }

    return true;
}


bool Socket::accept ( Socket& new_socket ) const
{
    int addr_length = sizeof ( m_addr );
    new_socket.m_sock = ::accept ( m_sock, ( sockaddr * ) &m_addr, ( socklen_t * ) &addr_length );

    if ( new_socket.m_sock <= 0 )
        return false;
    else
        return true;
}

void Socket::set_non_blocking ( const bool b )
{

    int opts;

    opts = fcntl ( m_sock,
       F_GETFL );

    if ( opts < 0 )
    {
        return;
    }

    if ( b )
        opts = ( opts | O_NONBLOCK );
    else
        opts = ( opts & ~O_NONBLOCK );

    fcntl ( m_sock,
        F_SETFL,opts );

}