C / C++ / MFC

• Takes BigStep (the address of the array of const MyStep structs).
• Casts it to struct Mystep * (hence discarding the const constraint).
• Assigns the result to step (that is probably defined as struct MyStep *).

Ebe72 wrote:

step = (struct MyStep*)BigStep
given,
typedef struct MyStep {...structure
definition...};
const struct MyStep BigStep[]{...an array of MyStep...};

<br />
if(x=0){...Do Something...} (Never Happens)<br />
<br />
int x==1;<br />
<br />
for(x=0;x=10;x++){...Do Something...}<br />
switch(){// In VC5 Trashes the Compiler<br />
break;<br />
}<br />

void open ( const char * filename, ios_base :openmode mode = ios_base::in );

open(filename, ios_base::out);
//Or maybe
open(filename, ios_base::in | ios_base::out);

m_hevWSA = ::WSACreateEvent();
m_sockRecv = ::WSASocket(AF_INET, SOCK_DGRAM, IPPROTO_UDP, NULL, 0, WSA_FLAG_OVERLAPPED);
::bind(m_sockRecv, reinterpret_cast<sockaddr*>(&sinRecv), sizeof(struct sockaddr));

// Worker thread
UINT CMyClass::WorkerThread(void)
{
    int nRet = -1;
    bool bPending = false;
    DWORD dwWSARead = 0;
    DWORD dwWSAFlags = 0;receive flags
    char NetBuf[DGRAM_BUF_SIZE];
    WSABUF WSABuf = { DGRAM_BUF_SIZE, NetBuf };
    HANDLE ahWait[2] = { m_evKill.m_hObject, m_hevWSA };
    WSAOVERLAPPED ovWSA;
    struct sockaddr_in SenderAddr;
    ::ZeroMemory(&SenderAddr, sizeof(SenderAddr));
    ::ZeroMemory(&ovWSA, sizeof(WSAOVERLAPPED));
    ovWSA.hEvent = m_hevWSA;
    do
    {
        int nWSAErr = 0;
        unsigned nNetRead = 0;
        if (!bPending)
        {
            dwWSARead = 0;
            dwWSAFlags = 0;
            WSABuf.len = DGRAM_BUF_SIZE;
            WSABuf.buf = NetBuf;
            int nSenderAddrSize = sizeof(SenderAddr);
            if (::WSARecvFrom(m_sockRecv, &WSABuf, 1, &dwWSARead, &dwWSAFlags,
                (SOCKADDR *)&SenderAddr, &nSenderAddrSize, &ovWSA, NULL) == 0)
            {
                nNetRead = static_cast<unsigned>(dwWSARead);
            }
            else
            {
                nWSAErr = ::WSAGetLastError();
                if (nWSAErr == WSA_IO_PENDING)
                    bPending = true;
                else
                    nRet = 1;
            }
        } // if (!m_bPending)
        switch (::WaitForMultipleObjects(bPending ? 2 : 1,
            ahWait, FALSE, bPending ? INFINITE : 0))			
        {
        case WAIT_OBJECT_0 : nRet = 0; break;
        case WAIT_OBJECT_0 + 1 :
            if (::WSAGetOverlappedResult(m_sockRecv, &ovWSA, &dwWSARead, FALSE, &dwWSAFlags))
            {
                nNetRead += static_cast<unsigned>(dwWSARead);
                bPending = false;
            }
            else
            {
                nWSAErr = ::WSAGetLastError();
                if (nWSAErr != WSA_IO_INCOMPLETE)
                    bPending = false;
            }
            ::ResetEvent(m_hevWSA);
            break;
        }
        if (nNetRead)
        {
            // process data
        }
    }
    while (nRet == -1);
    return (nRet == STILL_ACTIVE) ? 1 : static_cast<UINT>(nRet);
}

Jochen Arndt wrote:

Using one receiving thread is enough even with many clients when the UDP packets
are small.

SledgeHammer01 wrote:

What specifics are we talking here? Seems like common convention on the internet is telling me to restrict UDP packet sizes to 256 bytes, correct?

SledgeHammer01 wrote:

Assuming my UDP server is receiving AND sending to clients, how many clients can I handle in a single thread? 100? 1,000? 10,000? 100,000?

SledgeHammer01 wrote:

Basically trying to do something that could scale to millions of clients. Not even sure if thats possible without multiple servers behind a load balancer though