/*
 *  Baltisot
 *  Copyright (C) 1999-2007 Nicolas "Pixel" Noble
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifdef _WIN32
#include <winsock2.h>
#endif

#define _BSD_SOCKLEN_T_ int
#ifndef _WIN32
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <strings.h>
#endif
#include <string.h>
#include <errno.h>
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "BString.h"
#include "Socket.h"
#include "Exceptions.h"
#include "Input.h"
#include "Output.h"
#include "gettext.h"

#ifdef _WIN32
class dummy_win32_socket_class_t : public Base {
  public:
      dummy_win32_socket_class_t() throw (GeneralException) {
          WSADATA wsaData;

          if (WSAStartup(MAKEWORD(2, 0), &wsaData) != 0)
              throw GeneralException("WSAStartup() failed.");
      }
} dummy_win32_socket_class;
typedef int socklen_t;
#endif

Socket::Socket() throw (GeneralException) : Handle(socket(AF_INET, SOCK_STREAM, 0)), connected(false), listening(false), writeclosed(false), readclosed(false), connecting(false) {
//    cerr << "Socket(): connected = " << connected << "; readclosed = " << readclosed << "; writeclosed = " << writeclosed << endl;
    if (GetHandle() < 0) {
	throw GeneralException(_("Error creating socket."));
    }
}

Socket::Socket(const Socket & s) : Handle(s), connected(s.connected), listening(s.listening), writeclosed(s.writeclosed), readclosed(s.readclosed), connecting(s.connecting) {
//    cerr << "Constructing a socket by copy...\n";
//    cerr << "Socket(const Socket &): connected = " << connected << "; readclosed = " << readclosed << "; writeclosed = " << writeclosed << endl;
}

Socket::Socket(int h) : Handle(h), connected(true), listening(false), writeclosed(false), readclosed(false), connecting(false) { }

String Socket::GetName(void) {
    return String("socket");
}

bool Socket::IsConnected(void) {
    return connected;
}

bool Socket::IsConnecting(void) {
    return connecting;
}

bool Socket::IsListening(void) {
    return listening;
}

bool Socket::CanRead(void) {
//    cerr << "CanRead: connected = " << connected << "; readclosed = " << readclosed << endl;
    return connected && !readclosed;
}

bool Socket::CanWrite(void) {
//    cerr << "CanWrite: connected = " << connected << "; writeclosed = " << writeclosed << endl;
    return connected && !writeclosed;
}

void Socket::CloseWrite(void) {
    if (!writeclosed) {
	writeclosed = true;
	shutdown(GetHandle(), 1);
    }
}

void Socket::CloseRead(void) {
    if (!readclosed) {
	readclosed = true;
	shutdown(GetHandle(), 0);
    }
}

    /***********************************************\
    * Toute la suite n'est pas à décrire. Consulter *
    * plutôt un document décrivant les sockets.     *
    \***********************************************/


bool Socket::SetLocal(const String & vhost, int port) {
    struct hostent * localhostent;
    struct in_addr localhostaddr;
    struct sockaddr_in localsocketaddr;

    memset((void *)&localhostaddr, 0, sizeof(localhostaddr));

    if (vhost.strlen() != 0) {
	if ((localhostent = gethostbyname(vhost.to_charp()))) {
	    memcpy((void *)&localhostaddr, localhostent->h_addr, sizeof(localhostaddr));
	} else {
	    return false;
	}
    } else {
	localhostaddr.s_addr = htonl(INADDR_ANY);
    }

    memset(&localsocketaddr, 0, sizeof(struct sockaddr_in));
    localsocketaddr.sin_family = AF_INET;
    localsocketaddr.sin_addr = localhostaddr;
    localsocketaddr.sin_port = htons(port);

#ifndef _WIN32
    int enable = 1;
    setsockopt(GetHandle(), SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable));
#endif

    if (bind(GetHandle(), (struct sockaddr *) &localsocketaddr, sizeof(localsocketaddr)) < 0) {
	return false;
    } else {
	return true;
    }
}

bool Socket::Connect(const String & host, int port) {
    struct hostent * remotehostent;
    struct sockaddr_in remotesocketaddr;

    if (!listening && !connected) {
//	std::cerr << " - Resolving '" << host << "'..." << std::endl;
        if (!(remotehostent = gethostbyname(host.to_charp()))) {
    	    return false;
	}

	remotesocketaddr.sin_family = AF_INET;
	remotesocketaddr.sin_port = htons(port);
	bcopy(remotehostent->h_addr, &remotesocketaddr.sin_addr, remotehostent->h_length);
//	std::cerr << " - Connecting to port " << port << " ..." << std::endl;
	if (!connect(GetHandle(), (struct sockaddr *)&remotesocketaddr, sizeof(remotesocketaddr))) {
//	    std::cerr << " - Connected." << std::endl;
	    connected = true;
	} else {
//            std::cerr << " - Error connecting: " << strerror(errno) << std::endl;
#ifdef _WIN32
            if (WSAGetLastError() == WSAEWOULDBLOCK) {
#else
            if (errno == EINPROGRESS) {
#endif
                connecting = true;
            }
	}
    }
    return connected;
}

bool Socket::Listen(void) {
    if (!listening && !connected) {
	if (!listen(GetHandle(), 10)) {
	    listening = true;
	}
    }
    return listening;
}

Socket Socket::Accept(void) throw (GeneralException) {
    struct sockaddr inaddr;
    socklen_t inlen = sizeof(inaddr);
    int h;

    if ((h = accept(GetHandle(), &inaddr, &inlen)) < 0) {
	throw GeneralException(_("Failed accepting."));
    } else {
	return Socket(h);
    }
}

int Socket::GetPort() {
    int r;
    struct sockaddr_in localsocketaddr;
    socklen_t locallen = sizeof(localsocketaddr);
    
    if (getsockname(GetHandle(), (struct sockaddr *) &localsocketaddr, &locallen)) {
        return -1;
    }
    
    r = ntohs(localsocketaddr.sin_port);
    
    return r;
}

Uint32 Socket::GetAddr() {
    Uint32 r;
    struct sockaddr_in localsocketaddr;
    socklen_t locallen = sizeof(localsocketaddr);
    
    if (getsockname(GetHandle(), (struct sockaddr *) &localsocketaddr, &locallen)) {
        return -1;
    }
    
    r = ntohl(localsocketaddr.sin_addr.s_addr);
    
    return r;
}

int Socket::GetDistantPort() {
    int r;
    struct sockaddr_in distantsockaddr;
    socklen_t distantlen = sizeof(distantsockaddr);
    
    if (getpeername(GetHandle(), (struct sockaddr *) &distantsockaddr, &distantlen)) {
	return -1;
    }
    
    r = ntohs(distantsockaddr.sin_port);
    
    return r;
}

Uint32 Socket::GetDistantAddr() {
    Uint32 r;
    struct sockaddr_in distantsockaddr;
    socklen_t distantlen = sizeof(distantsockaddr);
    
    if (getpeername(GetHandle(), (struct sockaddr *) &distantsockaddr, &distantlen)) {
	return -1;
    }
    
    r = ntohl(distantsockaddr.sin_addr.s_addr);
    
    return r;
}

bool Socket::FinalizeConnect() {
    int r;
    socklen_t l = sizeof(r);

    if (getsockopt(GetHandle(), SOL_SOCKET, SO_ERROR, (char *)&r, &l) == 0) {
        if (r == 0) {
            connected = true;
        }
    }
    connecting = false;

    return connected;
}

ssize_t Socket::nwrite(const void * buf, size_t count) throw (GeneralException) {
    return ::send(GetHandle(), (const char *) buf, count, 0);
}

ssize_t Socket::nread(void * buf, size_t count) throw (GeneralException) {
    return ::recv(GetHandle(), (char *) buf, count, 0);
}

int Socket::ndup() const throw (GeneralException) {
#ifdef _WIN32
    WSAPROTOCOL_INFO ProtocolInfo;
    int r, s;

    if (r = WSADuplicateSocket(GetHandle(), GetCurrentProcessId(), &ProtocolInfo)) {
        throw GeneralException("Error within WSADuplicateSocket().");
    }

    if ((s = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, &ProtocolInfo, 0, 0)) == INVALID_SOCKET) {
        throw GeneralException("Error within WSASocket() while dup()ing it.");
    }

    return s;
#else
    return dup(GetHandle());
#endif
}

int Socket::nclose() throw (GeneralException) {
#ifdef _WIN32
    return closesocket(GetHandle());
#else
    return Handle::nclose();
#endif
}