stringsocket.cpp

Last change: 2008-02-03 This is the source code of KCeasy。

/*
This file is part of KCeasy (http://www.kceasy.com)
Copyright (C) 2002-2004 Markus Kern <[e-mail]>

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.
*/
//---------------------------------------------------------------------------
#pragma hdrstop
#include "StringSocket.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)

namespace KCeasyEngine {

TStringSocket::TStringSocket()
:   Sock(INVALID_SOCKET),
    LastError(0),
    RecvBuf(NULL)
{
    WSADATA WSAData;
    // Use version 2.1 since giFT does as well. So if something goes wrong
    // we get the same error info here.
    if(WSAStartup(MAKEWORD(2,1),&WSAData) != 0)
        SetError("WSAStartup()");

    WinsockDesc = WSAData.szDescription;
    WinsockStatus = WSAData.szSystemStatus;

    RecvBuf = new char[RecvBufSize];
}

TStringSocket::~TStringSocket()
{
    Disconnect();
    delete[] RecvBuf;
    WSACleanup();
}

bool TStringSocket::Connect(const char* Host, unsigned short Port)
{
    SOCKADDR_IN Addr;
    HOSTENT* HostEnt;

    if(Sock != INVALID_SOCKET)
        Disconnect();

    if((Sock = socket(AF_INET,SOCK_STREAM,IPPROTO_IP)) == INVALID_SOCKET)
        return SetError("socket()");

	memset(&Addr,0,sizeof(SOCKADDR_IN));
	Addr.sin_family = AF_INET;
	Addr.sin_port = htons(Port);
	Addr.sin_addr.s_addr = inet_addr(Host);

    if(Addr.sin_addr.s_addr == INADDR_NONE) {
        HostEnt = gethostbyname(Host);
        if(HostEnt)
        	Addr.sin_addr.s_addr = *((unsigned int*)HostEnt->h_addr);
    }

    if(connect(Sock,(const SOCKADDR*)&Addr,sizeof(SOCKADDR_IN)) == SOCKET_ERROR)
        return SetError("connect()");

    return true;
}

void TStringSocket::Disconnect()
{
    if(Sock == INVALID_SOCKET)
        return;

    Shutdown();
    closesocket(Sock);
    Sock = INVALID_SOCKET;
}

void TStringSocket::Shutdown()
{
    if(Sock == INVALID_SOCKET)
        return;

    shutdown(Sock,2);
}

bool TStringSocket::WaitForData(int Timeout)
{
    fd_set rfds;
    struct timeval tm;
    int ret;

    FD_ZERO(&rfds);
    FD_SET(Sock,&rfds);

    tm.tv_sec = Timeout/1000;
    tm.tv_usec = (Timeout%1000)*1000;
    ret = select(0,&rfds,0,0,&tm);

    if(ret == SOCKET_ERROR)
        return SetError("select()");

    return (ret == 0) ? false : true;
}

bool TStringSocket::Send(const char* String)
{
    if(send(Sock,String,strlen(String),0) == SOCKET_ERROR)
        return SetError("send()");
    return true;
}

char* TStringSocket::Receive()
{
    int ret;

    ret = recv(Sock,RecvBuf,RecvBufSize-1,0);
    if(ret == 0 || ret == SOCKET_ERROR) {
        SetError("recv()");
        return NULL;
    }
    RecvBuf[ret] = 0;
    return RecvBuf;
}

string TStringSocket::GetErrorString()
{
    char ErrorString[2048];
    DWORD ret;

	ret = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
                        NULL, LastError, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                        (LPTSTR) &ErrorString, sizeof(ErrorString), NULL);

	if(ret == 0)
        wsprintf(ErrorString,"Unknown Socket error %d",LastError);

    string Err = LastErrorPlace + ": " + ErrorString;
    Err += string("\n\nWinsock Description: ") + WinsockDesc;
    Err += string("\nWinsock Status: ") + WinsockStatus;

    return Err;
}

bool TStringSocket::SetError(const char* Place)
{
    LastError = WSAGetLastError();
    LastErrorPlace = Place;
    return false; // always returns false
}

} // namespace KCeasyEngine