spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

class NETWORKLIB_EXPORT CServer
{
    private:

        WSADATA wsa;
        SOCKADDR_IN addr;

        SOCKET ContactSocket;
        HANDLE ContactThreadHandle;
        DWORD ContactThreadId;

        HANDLE SendThreadHandle;
        DWORD SendThreadId;

        SOCKET* ClientSockets;
        HANDLE* ClientThreadHandles;
        DWORD* ClientThreadIds;

        std::queue<char*>* InputBuffer;
        std::queue<char*>* OutputBuffer;

        int MaxClients;

        static DWORD WINAPI ContactThread(LPVOID pParameters);
        static DWORD WINAPI ClientThread(LPVOID pParameters);
        static DWORD WINAPI SendThread(LPVOID pParameters);

        CRITICAL_SECTION csInputBuffer;
        CRITICAL_SECTION csOutputBuffer;

    public:

        void Create(int pPort, int pMaxClients);
        bool GetBuffer(int pClientId, char* pBuffer, int pBufferSize);
        void AddToBuffer(int pClientId, char* pBuffer);
        void Shutdown();
};

C-/C++-Quelltext

void CServer::Create(int pPort, int pMaxClients)
{
    //maximale Anzahl Klienten speichern
    MaxClients = pMaxClients;

    //WSAStartup
    WSAStartup(MAKEWORD(2,0),&wsa);

    //Kontakt Socket erstellen
    ContactSocket=socket(AF_INET,SOCK_STREAM,0);

    //SOCKADDR_IN Struktur füllen
    ZeroMemory(&addr, sizeof(SOCKADDR_IN));
    addr.sin_family=AF_INET;
    addr.sin_port=htons(pPort);
    addr.sin_addr.s_addr=INADDR_ANY;

    //Kontakt Socket binden und in listen Modus setzen
    bind(ContactSocket, (SOCKADDR*)&addr, sizeof(SOCKADDR_IN));
    listen(ContactSocket, MaxClients);

    //ClientArrays erzeugen
    ClientSockets = new SOCKET[MaxClients];
    ClientThreadHandles = new HANDLE[MaxClients];
    ClientThreadIds = new DWORD[MaxClients];

    //Buffer erzeugen
    InputBuffer = new std::queue<char*>[MaxClients];
    OutputBuffer = new std::queue<char*>[MaxClients];

    //Clientarrays leer initialisieren
    for(int i=0;i<MaxClients;i++)
    {
        ClientSockets[i]        = 0;
        ClientThreadHandles[i]  = 0;
        ClientThreadIds[i]      = 0;
    }  

    //CriticalSections erzeugen
    InitializeCriticalSection(&csInputBuffer);
    InitializeCriticalSection(&csOutputBuffer);

    //Kontakt Thread starten
    ContactThreadHandle = CreateThread(NULL, 0, ContactThread, this, 0, &ContactThreadId);

    //Send Thread starten
    SendThreadHandle = CreateThread(NULL, 0, SendThread, this, 0, &SendThreadId);

}

void CServer::Shutdown()
{
    //Kontakt Thread und Socket schließen
    TerminateThread(ContactThreadHandle, 0);
    closesocket(ContactSocket);

    //Send Thread beenden
    TerminateThread(SendThreadHandle, 0);

    //Client Threads, Sockets schließen und Speicher freigeben
    for(int i=0;i<MaxClients;i++)
    {
        TerminateThread(ClientThreadHandles[i], 0);
        closesocket(ClientSockets[i]);

        while(!InputBuffer[i].empty())
        {
            delete InputBuffer[i].front();
            InputBuffer[i].pop();
        }
        while(!OutputBuffer[i].empty())
        {
            delete OutputBuffer[i].front();
            OutputBuffer[i].pop();
        }
    }

    //CriticalSections löschen
    //DeleteCriticalSection(&csInputBuffer);
    //DeleteCriticalSection(&csOutputBuffer);

    //Speicher freigeben
    delete [] ClientThreadIds;
    delete [] ClientThreadHandles;
    delete [] ClientSockets;
    delete [] InputBuffer;
    delete [] OutputBuffer;

    WSACleanup();
}

}

C-/C++-Quelltext

#include <iostream>
#include "NetworkLib/global.h"

int main()
{
    CServer Server;
    CClient Client;
    Server.Create(1612, 10);
    Client.Init("127.0.0.1", 1612);
    Client.SetBuffer("test", 5);
    Client.SetBuffer("test1", 6);
    Client.SetBuffer("test11", 7);
    Client.SetBuffer("test111", 8);
    Client.SetBuffer("test1111", 9);*/
    Sleep(100);
    
    char tmp[512];
    

    while(true)
    {
        while(Server.GetBuffer(0, tmp, 512))
        {
            Server.AddToBuffer(0, tmp);
            std::cout<<"Server received: "<<tmp<<"Sent back!\r\n";
        }
    }

    Server.Shutdown();

    return 0;
}

C-/C++-Quelltext

class NETWORKLIB_EXPORT CClient
{
    private:

        WSADATA wsa;
        SOCKET s;
        SOCKADDR_IN addr;

        std::queue<char*> InputBuffer;
        std::queue<char*> OutputBuffer;

        HANDLE RecieveThreadHandle;
        DWORD RecieveThreadId;
        HANDLE SendThreadHandle;
        DWORD SendThreadId;

        static DWORD WINAPI RecieveThread(LPVOID pParameter);
        static DWORD WINAPI SendThread(LPVOID pParameters);

    public:

        bool Init(char* pIp, int pPort);
        bool GetBuffer(char* pBuffer, int pBufferSize);
        void SetBuffer(char* pBuffer, int pBufferSize);
        void Shutdown();
};

C-/C++-Quelltext

void CServer::AddToBuffer(int pClientId, char* pBuffer)
{
    char* tmp = new char[512];
    strcpy_s(tmp, 512, pBuffer);

    EnterCriticalSection(&csOutputBuffer);
    OutputBuffer[pClientId].push(tmp);
    LeaveCriticalSection(&csOutputBuffer);
}

C-/C++-Quelltext

bool CServer::GetBuffer(int pClientId, char* pBuffer, int pBufferSize)
{
    EnterCriticalSection(&csInputBuffer);
    if(InputBuffer[pClientId].empty())
    {
        LeaveCriticalSection(&csInputBuffer);
        return false;
    }

    strcpy_s(pBuffer, pBufferSize, InputBuffer[pClientId].front());
    delete InputBuffer[pClientId].front();
    InputBuffer[pClientId].pop();

    LeaveCriticalSection(&csInputBuffer);
    return true;
}

bool CClient::GetBuffer(char* pBuffer, int pBufferSize)
{
    if(InputBuffer.empty()) return false;

    strcpy_s(pBuffer, pBufferSize, InputBuffer.front());
    delete InputBuffer.front();
    InputBuffer.pop();

    return true;
}