Почему WSASend возвращает 0, но все еще вызывает процедуру завершения?

В документах четко сказано, что если WSASend завершится немедленно, вы получите WSA_IO_PENDING, но этого просто не произойдет. Я всегда получаю 0, а dwBytesTransferred всегда совпадает с байтами, которые я отправил. Однако иногда кажется, что моя процедура завершения называется, а иногда нет. Я выделяю буфер для отправки, поэтому мне нужно освободить буфер, если процедура завершения не будет вызвана.

У меня есть три импровизированных счетчика, m_dwAsyncSend, m_dwSyncSend и m_dwCompletions. m_dwAsycSend всегда равен нулю, а m_dwSyncSend и m_dwCompletions всегда очень далеко друг от друга, так как один m_dwSyncSend может иметь значение 750, а m_dwCompletions равно 2. Есть множество случаев, когда поток может быть предупрежден, поэтому я не думаю, что я истощаю его таким образом.

Это сводит меня с ума! Уже после полуночи, и я был в этом весь день. Я обвиняю, что если что-либо из этого является несогласованным!

Вот код, я не думаю, что вам нужен файл класса, чтобы увидеть, что я делаю.

void
CALLBACK
SendCompletion(
DWORD dwError,
DWORD cbTransferred,
LPOVERLAPPED pOvl,
DWORD dwFlags
)
{
LPWSABUF pBuffer = (LPWSABUF)((DWORD_PTR)pOvl + sizeof(OVERLAPPED));
CNetAsyncSocket *pSock = (CNetAsyncSocket *)pOvl->hEvent;
pSock->m_dwCompletions++;
if(dwError != NO_ERROR)
{
// If things didn't go as planned, ring the bell and disconnect.
pSock->Disconnect();
tracef(TT_REGULAR, 1,
"SOCKET_ERROR in CNetAsyncSocket::Send(), disconnecting, error code: %ld, on socket: %s:%ld",
dwError, pSock->GetIP(), pSock->GetPort());
free(pOvl);
}
else
{
// If we sent less than we meant to, queue up the rest.
if(cbTransferred < pBuffer->len)
{
DWORD dwRemaining = pBuffer->len - cbTransferred;
memmove(pBuffer->buf, (PVOID)((DWORD_PTR)pBuffer->buf + dwRemaining), dwRemaining);
pBuffer->len = dwRemaining;
}
else
{
free(pOvl);
}
}
}
void CNetAsyncSocket::SendAsync(PBYTE pData, DWORD dwLength)
{
// We want to minimize heap churn, so let's do this in one allocation.
// Also, having this in one chunk of memory makes it easier to interpret
// it on the other side.
DWORD dwAllocSize =
sizeof(OVERLAPPED) +        // The OVERLAPPED struct.
sizeof(WSABUF) +            // The buffer info.
dwLength;                   // The actual buffer we're copying.
LPOVERLAPPED pOvl = (LPOVERLAPPED)malloc(dwAllocSize);

if(pOvl == NULL)
{
// Out of memory.
}

// Initialize the allocation.
ZeroMemory(pOvl, dwAllocSize);// Build the pointers.
LPWSABUF pBuffer = (LPWSABUF)((DWORD_PTR)pOvl + sizeof(OVERLAPPED));
pBuffer->len = dwLength;
assert(pBuffer->len < 1000000);
pBuffer->buf = (PCHAR)((DWORD_PTR)pBuffer + sizeof(WSABUF));
// When you have a completion routine, the hEvent member is ignored, so we
// can use it to pass our this pointer to the completion routine.
pOvl->hEvent = (PVOID)this;

// Copy the data to the buffer.
CopyMemory(pBuffer->buf, pData, dwLength);

// Send the data.
DWORD dwSent = 0;
int iResult = WSASend(
m_hSocket,          // The socket.
pBuffer,            // The WSABUF struct.
1,                  // Number of structs (1).
&dwSent,            // Bytes sent. Updated if it happens synchronously.
0,                  // No flags.
pOvl,               // The overlapped struct.
SendCompletion);    // Completion routine.

if(iResult == NO_ERROR)
{
// If the send happened synchronously, we can go ahead and delete the
// memory that we allocated.

// TODO: look at bytes transferred, and if they're less than the total
// then issue another send with the remainder.

if(HasOverlappedIoCompleted(pOvl))
{
// If I actually free this here, the completion routine gets garbage.
//free(pOvl);
m_dwSyncSend++;
}
else
{
m_dwAsyncSend++;
}
}
else
{
// If we got WSA_IO_PENDING, then that just means the completion routine
// will take care of it.
if(iResult != WSA_IO_PENDING)
{
Disconnect();
tracef(TT_REGULAR, 1,
"SOCKET_ERROR in CNetAsyncSocket::Send(), disconnecting, error code: %ld, on socket: %s:%ld",
iResult, GetIP(), GetPort());
// Don't need the payload anymore.
free(pOvl);
}
else
{
m_dwAsyncSend++;
}
}
}