CNetConn

So hier hab ich noch was extrem feines für die jenigen die sich mit Net conn auseinander setzen^^
Provides WinSock2 IP connection management wenn euch das was sagt

/*

Provides WinSock2 IP connection management



Dependencies: CCrypto (discardable), CString, wsock32.lib





*/



#ifndef _NETCONN_H_INC_

#define _NETCONN_H_INC_



#include <windows.h>

#include <winsock.h>

#include "string.h"

#include "crypto.h"



#define MAX_CLIENT_CONN  10   // maximum possible connections from clients

                              // used in NetListenThread()

extern int giCurrConnCount;



/*

 *  class CNetConn

 *

 *  Provides generic network communication layer with GK/HTTP/FTP protocol support

 *

 */

class CNetConn

{

    public:

        // Main constructor

        // Initializes class and some variables

        CNetConn();



        // Main destructor

        ~CNetConn();



        // create socket and bind it if port != 0

        BOOL CreateSocket(int iType, int iPort);

        // opens a connection

        BOOL Connect(CString strHost);

        // closes connection

        void Close();

        // gets pending connection ob bound listen port

        // --> result must be checked with IsValid() method!!

        CNetConn GetConn();



        // send String  data to remote computer

        int Send(CString str);

        // send binary data to remote computer

        int SendData(LPVOID data, DWORD dwLength);

        // receive data from remote computer

        int Recv(CString& str, int iMaxLen);



        // is a valid/connected socket?

        BOOL IsValid();

        BOOL IsConnected();



        // encryption

        int SetEncryption(int iMethod);



        CString m_strHost;

        sockaddr_in m_addr;



    private:

        SOCKET m_socket;

        WSADATA m_wsaData;

        bool m_bIsConnected;

        //CCrypto m_crypto;

};



#define NETNOTIFY_OPEN  0

#define NETNOTIFY_DATA  1

#define NETNOTIFY_CLOSE 2

typedef int (*NETNOTIFYPROC)(CNetConn *, CString, int);



struct RECV_PARAM

{

    CNetConn *conn;

    NETNOTIFYPROC *pNetNotify;

};



HANDLE InitNetConnThread(CNetConn *conn, NETNOTIFYPROC *pNetNotify, DWORD *tid);

HANDLE InitNetListenThread(CNetConn *listenconn, NETNOTIFYPROC *pNetNotify, DWORD *tid);



#endif  // ifdef _NETCONN_H_INC_

/*

Provides WinSock2 IP connection management



Dependencies: CCrypto (discardable), CString, wsock32.lib





*/



#include "netconn.h"

//#include "crypto.h"



/*

 *  default constructor

 *

 */

CNetConn::CNetConn()

{

    if (WSAStartup(0x202, &m_wsaData) == SOCKET_ERROR)

    {

        WSACleanup();

        DEBUGMSG("CNetConn couldn't init windows sockets. Quitting process");

        ExitProcess(0);

    }



    m_socket = INVALID_SOCKET;

    m_bIsConnected = false;



    // initialize m_crypto here

}



CNetConn::~CNetConn()

{

}



BOOL CNetConn::CreateSocket(int iType, int iPort)

{

    // iType == SOCK_DGRAM (UDP) | SOCK_STREAM (TCP)



    struct sockaddr_in local;



    m_socket = socket(AF_INET, iType, 0);

    if (m_socket == INVALID_SOCKET)

    {

        WSACleanup();

        DEBUGMSG("CNetConn::CreateSocket() couldn't create a socket");

        return false;

    }



    if (iPort != 0)

    {

        local.sin_family = AF_INET;

        local.sin_addr.s_addr = INADDR_ANY;

        local.sin_port = htons(iPort);



        if (bind(m_socket, (struct sockaddr*) &local, sizeof(local)) == SOCKET_ERROR)

        {

            WSACleanup();

            DEBUGMSG("CNetConn::CreateSocket() couldn't bind socket");

            return false;

        }

    }



    return true;

}



BOOL CNetConn::Connect(CString strHost)

{

    struct hostent *hp;

    unsigned int addr;

    unsigned short port = 0;

    sockaddr_in to;

    int retval;



    if (strHost.IsEmpty()) return false;



    port = atoi(strHost.Part(':', 1));

    if (!port)

    {

        CString str;

        str.Format("CNetConn::Connect() couldn't interpret port number \"%s\"", strHost.Part(':', 1));

        DEBUGMSG(str);

        return false;

    }



    if (isalpha(strHost[0]))  /* server address is a name */

    {

        hp = gethostbyname(strHost.Part(':', 0));

    }

    else  /* Convert nnn.nnn address to a usable one */

    {

        addr = inet_addr(strHost.Part(':', 0));

        hp = gethostbyaddr((char *) &addr, 4, AF_INET);

    }

    if (hp == NULL)

    {

        CString str;

        str.Format("CNetConn::Connect() can't resolve \"%s\"", strHost);

        DEBUGMSG(str);

        return false;

    }



    memset(&to, 0, sizeof(to));

    memcpy(&(to.sin_addr), hp->h_addr, hp->h_length);

    to.sin_family = hp->h_addrtype;

    to.sin_port = htons(port);



    retval = connect(m_socket, (sockaddr *) &to, sizeof(to));

    if (retval == SOCKET_ERROR)

    {

        m_bIsConnected = false;

        retval = WSAGetLastError();

        CString str;

        str.Format("CNetConn::Connect() can't connect(): error %d", retval);

        DEBUGMSG(str);

        return false;

    }



    m_bIsConnected = true;

    return true;

}



void CNetConn::Close()

{

    closesocket(m_socket);

    m_socket = INVALID_SOCKET;

    m_bIsConnected = false;

}



CNetConn CNetConn::GetConn()

{

    sockaddr_in from;

    int fromlen;

    CNetConn conn;



    fromlen = sizeof(from);



    if (listen(m_socket, 5) == SOCKET_ERROR)

    {

        DEBUGMSG("CNetConn::GetConn() can't listen()");

    }

    else

    {

        conn.m_socket = accept(m_socket, (struct sockaddr*) &from, &fromlen);

        conn.m_addr = from;

        conn.m_strHost.Format("%s:%d", inet_ntoa(from.sin_addr), ntohs(from.sin_port));

    }



    //conn.SetEncryption(CRYPT_XOR);

    m_bIsConnected = true;

    return conn;

}



int CNetConn::Send(CString str)

{

    return SendData(str.GetBuffer(), str.GetLength());

}



int CNetConn::SendData(LPVOID data, DWORD dwLength)

{

    int retval;



    CString strEnc;

    memcpy(strEnc.GetBuffer(dwLength), data, dwLength);

    strEnc.ReleaseBuffer(dwLength);

    //strEnc = m_crypto.Encrypt(strEnc);



    retval = send(m_socket, strEnc, dwLength, 0);

    if (retval == SOCKET_ERROR)

    {

        retval = WSAGetLastError();

        CString str;

        str.Format("CNetConn::Connect() can't send(): error %d", retval);

        DEBUGMSG(str);

        return -1;

    }



    return retval;

}



int CNetConn::Recv(CString& str, int iMaxLen)

{

    int retval;

    int fromlen = 16;



    retval = recv(m_socket, str.GetBuffer(iMaxLen), iMaxLen, 0);

    if (retval < 0)

    {

        retval = WSAGetLastError();

        if (retval = WSAECONNRESET)

        {

            str.ReleaseBuffer(0);

            return 0;

        }

        CString str;

        str.Format("CNetConn::Connect() can't recv(): error %d", retval);

        DEBUGMSG(str);

        return -1;

    }

    str.ReleaseBuffer(retval);



    //str = m_crypto.Decrypt(str);



    return retval;

}



BOOL CNetConn::IsValid()

{

    return (m_socket != INVALID_SOCKET);

}



BOOL CNetConn::IsConnected()

{

    return m_bIsConnected;

}



void WINAPI NetConnThread(LPVOID lParam)

{

    NETNOTIFYPROC pNetNotify = (NETNOTIFYPROC) ((RECV_PARAM *) lParam)->pNetNotify;

    CNetConn *conn = (CNetConn *) ((RECV_PARAM *) lParam)->conn;



    free(lParam);



    CString str;

    int iRet;

    bool bExitThread = false;



    //DEBUGMSG("NetConnThread started");



    pNetNotify(conn, str, NETNOTIFY_OPEN);

    while (!bExitThread)

    {

        iRet = conn->Recv(str, 1000);

        if (iRet > 0)

        {

            pNetNotify(conn, str, NETNOTIFY_DATA);

        }

        else if (iRet == 0)

        {

            str = "";

            pNetNotify(conn, str, NETNOTIFY_CLOSE);

            conn->Close();

            bExitThread = true;

        }

        else

        {

            str = "";

            pNetNotify(conn, str, NETNOTIFY_CLOSE);

            conn->Close();

            str.Format("NetConnThread can't recv(): error %d", iRet);

            DEBUGMSG(str);

            bExitThread = true;

        }

    }

    app.m_iCurrConnCount--;



    //DEBUGMSG("NetConnThread terminated");

}



HANDLE InitNetConnThread(CNetConn *conn, NETNOTIFYPROC *pNetNotify, DWORD *tid)

{

    HANDLE hThread;

    RECV_PARAM *prp = (RECV_PARAM *) malloc(sizeof(RECV_PARAM));

    prp->pNetNotify = pNetNotify;

    prp->conn = conn;



    hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) NetConnThread, prp, 0, tid);



    if (!hThread)

        return (HANDLE) 0;

    else

    {

        app.m_iCurrConnCount++;

        return hThread;

    }

}



void WINAPI NetListenThread(LPVOID lParam)

{

    NETNOTIFYPROC pNetNotify = (NETNOTIFYPROC) ((RECV_PARAM *) lParam)->pNetNotify;

    CNetConn *listenconn = (CNetConn *) ((RECV_PARAM *) lParam)->conn;



    free(lParam);



    HANDLE hConnThread;

    bool bExitThread = false;

    DWORD dwTid;



    //DEBUGMSG("NetListenThread started");



    while (!bExitThread)

    {

        app.m_conn[app.m_iCurrConnCount] = listenconn->GetConn();

        // TO-DO: also use free connections with lower index

        if (app.m_iCurrConnCount >= MAX_CLIENT_CONN)

        {

            app.m_conn[app.m_iCurrConnCount].Close();

        }

        else

        {

            hConnThread = InitNetConnThread(&app.m_conn[app.m_iCurrConnCount], (NETNOTIFYPROC *) pNetNotify, &dwTid);

            if (!hConnThread)

            {

                DEBUGMSG("NetListenThread can't InitNetConnThread(). quitting process");

                ExitProcess(0);

            }

        }

    }



    //DEBUGMSG("NetListenThread terminated");

}



HANDLE InitNetListenThread(CNetConn *listenconn, NETNOTIFYPROC *pNetNotify, DWORD *tid)

{

    HANDLE hThread;

    RECV_PARAM *prp = (RECV_PARAM *) malloc(sizeof(RECV_PARAM));

    prp->pNetNotify = pNetNotify;

    prp->conn = listenconn;



    hThread = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE) NetListenThread, prp, 0, tid);



    if (!hThread)

        return (HANDLE) 0;

    else

        return hThread;

}



int CNetConn::SetEncryption(int iMethod)

{

    //return m_crypto.SetMethod(iMethod);

}