C / C++ / MFC

<br />
ofstream out;<br />
out.open("error.txt",ios::app);<br />
out << WSAGetLastError << endl;<br />
out.close();<br />

dellthinker wrote:

I setup a function thread to loop over and over to send request...

dellthinker wrote:

out << WSAGetLastError << endl;

<br />
if(WSAGetLastError==183){<br />
}<br />

dellthinker wrote:

if(WSAGetLastError==183){

dellthinker wrote:

That doesnt work. If 183 is some code indicating that the data sent was lots and or not sent then there should be a way to use this in a if statement. Correct?

while (more_data_exists)
{
    int nRet = send(...);
    if (SOCKET_ERROR == nRet)
        DWORD dwError = WSAGetLastError();
}

DavidCrow wrote:

our question is really confusing. Do you have something akin to:

while (more_data_exists)
{
int nRet = send(...);
if (SOCKET_ERROR == nRet)
DWORD dwError = WSAGetLastError();
}

iResult = send (m_hSocket, pBuffer, iLength, 0);
if (iResult == SOCKET_ERROR)
{
    iResult = WSAGetLastError ()
    if ((iResult == WSAENETDOWN) ||
        (iResult == WSAENETRESET) ||
        (iResult == WSAECONNABORTED) ||
        (iResult == WSAETIMEDOUT) ||
        (iResult == WSAECONNRESET))
    {
        // socket closed
    }
    else
    {
        // some funky send error
    }

dellthinker wrote:

In order for me to do that im looking for whatever error WSAGetLastError might spit out. Compare that error with an if statement and do whatever is necessary to reconnect to the server. Understand me now?

DWORD dwError = WSAGetLastError();
if (183 == dwError)
    ...

DQNOK wrote:

I'm looking to fill memory with a pattern...

//author: David Qualls
//date:   Sept 2007
#include <string.h>

void memoryfill( void* target, char* pattern, size_t ptrnlen, size_t numRepeats )
{  
   char* trgt = (char*)target;  //for ease in pointer manipulation.
   if( 0 == numRepeats ) 
   {
      ; // do nothing!
   }
   else if( 1 == ptrnlen ) 
   {
      memset(target, *pattern, numRepeats);   
   }
   else    
   {
   // The naive approach here would be:
   // while( numRepeats--  > 0 )
   // {  memcpy(target, pattern, ptrnlen);
   //    (char*)target += ptrnlen;
   // }
   // But this is O(numRepeats).  Very ineffecient for large numRepeats.
   // Use a binary algorithm instead.  This one uses between log(numRepeats)
   // and 2*log(numRepeats) calls to memcpy(); a maximum of 64 calls to 
   // memcpy()for 32-bit size_t's : versus up to 4-billion calls to memcpy().

   // First, fill target up to the highest "bit" of repeatCount. log(n) loops.
      memcpy(trgt, pattern, ptrnlen); //begin by putting one copy into target.
      int snglbit=1;                  //number of copies in target. Always a power of 2.
      int thisCnt = numRepeats >> 1;  //one bit of repeatCount has already been taken care of.
      while( thisCnt > 0 )            //until all bits have been shifted off.
      {
         memcpy(trgt+ptrnlen*snglbit, trgt, ptrnlen*snglbit); //now double the amount in target.
         snglbit <<= 1;  //doubles the value of snglbit.
         thisCnt >>= 1;  //halves the value of thisCnt.
      }
   // snglbit now matches the most significant bit of repeatCount.
      char* endptr = trgt + ptrnlen*snglbit;   //where the next memcpy target is.
      while( (snglbit >>= 1) > 0 )             //for each lower bit within numRepeats,
      {
         if( snglbit & numRepeats )            //if this bit is ON within numRepeats,
         {
            memcpy(endptr, trgt, ptrnlen*snglbit);
            endptr += ptrnlen*snglbit;
         }
      }
   }
   return;
}
<br>
#include <stdio.h>
<br>
int main()
{
   char buf[1024];
   memset(buf, 0, 1024);  //insure null terminator(s)
   memoryfill( buf, "Hello World_", 12, 19 );
   printf("\n%s", buf);
}