sock receive fdset problem

Code:

---

exStr sock_receive()
{
        engine::fdset = engine::fds;
        engine::sr = select(1, &engine::fdset, NULL, NULL, &engine::selectTime);
       
        if (engine::sr == 1)
        {
                if (FD_ISSET(engine::esock.sock, &engine::fdset))
                {

                        ofstream fout;
                        fout.open("errors.txt", ios::binary | ios::app);
                        fout << "+";
                        fout.close();

                        char
                        buffer[1027] = "",
                        flag[6]      = "";

                        int nRcvd  = 0;

                        unsigned int iLen = 2;

                        bool gotLen = 0;

                        engine::exbuff[0] = '\0';

                        do
                        {
                                int rc = recv(engine::esock.sock, &buffer[nRcvd], iLen, 0);

                                if (rc > 0)
                                {
                                        nRcvd += rc;

                                        if ((!gotLen) && (nRcvd > 1))
                                        {
                                                iLen  = unpack(buffer[0], buffer[1]);
                                                gotLen = true;
                                        }
                                }
                                else
                                {
                                        if (rc == -1)
                                        {
                                                engine::sockRcvErr = -1;
                                        }
                                        if (rc == 0)
                                        {
                                                engine::sockRcvErr = 0;
                                        }
                                }
                        }
                        while ((!gotLen) || (nRcvd < iLen));

                        engine::sockRcvErr = 0;

                        process_instruction(buffer, iLen);

                        return (engine::exbuff);
                }
                else
                {
                        engine::sockRcvErr = 2;
                }
        }
        else
        {
                engine::sockRcvErr = 3;
        }
        return ("");
}

---

This function will receive the first message it gets perfectly fine. After that it won't receive any other messages. Can anyone tell me whats wrong?

Why doesn't it receive any other messages? Is recv() failing? Are you sure that there is more data in the socket buffer to be received?

The fd is never set after it is set once. I am positive I am sending data to the socket. I send two messages to the same socket and only the first one gets received. No matter how many messages I send only the first one gets received. And no its not receiving two messages at once. I can send them 10 minutes apart and it will only receive the first message.

How is your code supposed to work? Are the two messages supposed to be received in the do...while loop, or is the sock_receive() function called for each message?

Well if something is there to be received in engine::esock.sock shouldn't it be set? I just call the function once every pass through the game loop, and if the sock is set then it should receive a message. But if (FD_ISSET(engine::esock.sock, &engine::fdset)) is only returning true the first time I send a message. Every other time its returning false.

The first parameter you are passing to select is wrong. On unix systems this will fail, on Windows the first parameter is ignored, so you are OK.

Also, where is your code where you set up the fd_set structure that is passed to select?

Incase any other questions arise I'll just post the whole code since there isn't very much. I think it will just save time. Once again thank you for your help so far.

PHP Code:

---

#include "dll.h"
#include <windows.h>
#include <cstdio>
#include <to/crypt.h>
#include <fstream>

using namespace std;

unsigned int unpack(char byteA, char byteB)
{
    return ((static_cast<unsigned int>(byteA) << 8) | byteB);
}

char *pack(unsigned int value, char buffer[2])
{
    buffer[0] = (value >> 8);
    buffer[1] = (value & 255);

    return (buffer);
}

struct sockData
{
      SOCKET sock;
      sockaddr_in addr;
};

namespace engine
{
    sockData esock;

    fd_set  fdset, fds;
    timeval selectTime;
    
    char exbuff[1027];

    int sr, sockRcvErr, sockSndErr;
}
    
exVal sock_init()
{
    WSADATA w;
    int error = WSAStartup(0x0202, &w);

    if (error)
    {
        WSACleanup();
        return (0);
    }

    if (w.wVersion != 0x0202)
    {
        WSACleanup();
        return (0);
    }

    return (1);
}

exVal sock_connect(double port, char *ipaddr)
{
    SOCKET sock = socket(PF_INET, SOCK_STREAM, 0);

    sockaddr_in addr;
    addr.sin_family      = AF_INET;
    addr.sin_port        = htons(static_cast<int>(port));
    addr.sin_addr.s_addr = inet_addr(ipaddr);

    engine::esock.sock = sock;
    engine::esock.addr = addr;

    engine::selectTime.tv_sec  = 0;
    engine::selectTime.tv_usec = 0;

    FD_ZERO(&engine::fdset);
    FD_SET(engine::esock.sock, &engine::fds);
    
    if (connect(sock, (sockaddr *)&addr, sizeof(addr)) == SOCKET_ERROR)
    {
        return (0);
    }
    else
    {
        return (1);
    }
}

void send_gnt(int sockfd, char *buff, int len) 
{
    while (len > 0)
    {
        int nSent = send(sockfd, buff, len, 0);

        if (nSent > 0)
        {
            len  -= nSent;
            buff += nSent;
        }
        else
        {
            engine::sockSndErr = -1;
        }
    }
}

exVal sock_send(double size, char *buff)
{
    if (size > 1023)
    {
        return (0);
    }
    else
    {
        char buffer[2];
        pack(static_cast<int>(size), buffer);

        unsigned int keyval = unpack(buff[0], buff[1]);

        char key[6] = "";
        sprintf(key, "%05d", keyval);

        crypt_comp(buff, static_cast<int>(size), 2);
        crypt_xor(buff, key, static_cast<int>(size), 6, 2);

        send_gnt(engine::esock.sock, buffer, 2);
        send_gnt(engine::esock.sock, buff, static_cast<int>(size));
        
        return (1);
    }
}

void process_instruction(char *buffer, int iLen)
{
    unsigned int value = unpack(buffer[2], buffer[3]);
    char flag[6] = "";
    sprintf(flag, "%05d", value);

    crypt_xor(buffer, flag, iLen + 2, 6, 4);
    crypt_comp(buffer, iLen + 2, 4);

    switch (value)
    {
        case(0): // creation accept
        case(1): // login request
        {
            char instruction[2];

            instruction[0] = buffer[4];
            instruction[1] = '\0';

            strcat(engine::exbuff, flag);
            strcat(engine::exbuff, instruction);
            break;
        }
        case(2): // chat
        {
            char instruction[iLen - 4];

            int i = 0;

            while (i < iLen - 3)
            {
                instruction[0] = buffer[i + 4];
                i++;
            }

            strcat(engine::exbuff, flag);
            strcat(engine::exbuff, instruction);
            break;
        }
        default: int i = 0; while (i == 0) {;}
    }
}

exStr sock_receive()
{
    engine::fdset = engine::fds;
    engine::sr = select(1, &engine::fdset, NULL, NULL, &engine::selectTime);
    
    if (engine::sr == 1)
    {
        if (FD_ISSET(engine::esock.sock, &engine::fdset))
        {

            ofstream fout;
            fout.open("errors.txt", ios::binary | ios::app);
            fout << "+";
            fout.close();

            char 
            buffer[1027] = "", 
            flag[6]      = "";

            int nRcvd  = 0;

            unsigned int iLen = 2;

            bool gotLen = 0;

            engine::exbuff[0] = '\0';

            do
            {
                int rc = recv(engine::esock.sock, &buffer[nRcvd], iLen, 0);

                if (rc > 0)
                {
                    nRcvd += rc;

                    if ((!gotLen) && (nRcvd > 1))
                    {
                        iLen   = unpack(buffer[0], buffer[1]);
                        gotLen = true;
                    }
                }
                else
                {
                    if (rc == -1)
                    {
                        engine::sockRcvErr = -1;
                    }
                    if (rc == 0)
                    {
                        engine::sockRcvErr = 0;
                    }
                }
            }
            while ((!gotLen) || (nRcvd < iLen));

            engine::sockRcvErr = 0;

            process_instruction(buffer, iLen);

            return (engine::exbuff);
        }
        else
        {
            engine::sockRcvErr = 2;
        }
    }
    else
    {
        engine::sockRcvErr = 3;
    }
    return ("");
} 


---