C / C++ / MFC

memset(EsimData, 0, nSize);
memcpy(EsimData, Esim, nSize);

manoharbalu wrote:

But the client is still hanging

enum ReadParseStatus {
	readSigState = 0,
	readDataSizeState,
	readDataBodyState,
	readDataAvailState
};

// This is some unique signature make it what you like
// It should be something unlikely to occur in the data itself
// Make sure the server sends an identical signature and the data size before each packet body
const char signature[] = "PACKETSIG%$#";

// Parse status always starts as read signature
enum ReadParseStatus parseState = readSigState;

// Parse buffer
char parseBuffer[4096];			// The parse buffer itself ... you may adjust this up or down depending on poll rate
int parsePos = 0;				// Position of parse buffer
long bodyDataSize = 0;			// Body data size for current packet
unsigned char* bodyData = NULL; // Body data storage
long bodyDataPos = 0;			// Body data position


// Parses socket receive data
BOOL Poll_Receive_Data (CAsyncSocket sock){

	// Read whatever data is available into the parse buffer up to parse buffer full
	// sock would be m_pSocket in your code
	int iResult = sock.Receive(&parseBuffer[parsePos], sizeof(parseBuffer) - parsePos);
	
	// If return is zero or less there is either no data of something is wrong
	// So return a false so caller knows and can do something
	if (iResult <= 0) return (FALSE);
	
	// Adjust the parse position so space in buffer left can be checked
	parsePos += iResult;

	switch (parseState){
		case readSigState: {	
				// Temp buffer .. its 32 bytes here which must be bigger than signature length
				char tempbuf[32];
				// Hold signature length we will use it a bit in this phase
				int siglen = strlen(signature);
				// Preset sigFound to false
				BOOL sigFound = FALSE;
				// Loop while signature not found and enough data to run signature test
				while ((sigFound == FALSE) && (parsePos > siglen)) {
					// Transfer signature length of data from parseBuffer
					memcpy(tempbuf, &parseBuffer[0], siglen);
					// make sure its asciiz
					tempbuf[siglen] = 0;
					// Look for exact signature match
					if (strcmp(signature, &tempbuf[0])){
						// You found the signature so dump it .. memory overlap needs memmove
						memmove(&parseBuffer[0], &parseBuffer[siglen], parsePos - siglen);
						// adjust parsePos to reflect we removed the signature and dumped it
						parsePos -= siglen;
                        // signature found obviously
                        sigFound = TRUE; 
						// parser moves to next state
						parseState = readDataSizeState;
					} else {
						// So dump first character in parse buffer ... memory overlap so needs memmove
						memmove(&parseBuffer[0], &parseBuffer[1], parsePos - 1);
						// decrement parsePos
						parsePos--;
						// We will loop around now with next data
					}
				}
			}
			break;
		case readDataSizeState: {
				// Temp buffer .. which is size of a long + a character #0
				char tempbuf[sizeof(long)+1];
				// Do we have enough data to recover our data size long
				if (parsePos > sizeof(long)) {
					// Transfer data size long from parseBuffer
					memcpy(tempbuf, &parseBuffer[0], sizeof(long));
					// Make asciiz
					tempbuf[sizeof(long)] = 0;
					// Recover our body data size for this packet
					bodyDataSize = atol(&tempbuf[0]);
					// If we have old body data free the memory because we are on next packet
					// This is a self cleanup to make sure we dont bleed memory
					if (bodyData) free(bodyData);
					// Ok allocate memory to hold the body data, now we know its size
					bodyData = (unsigned char*) malloc(bodyDataSize);
					// Zero the body data position
					bodyDataPos = 0;
					// Done with the body size so dump it from parser .. memory overlap so use memmove
					memmove(&parseBuffer[0], &parseBuffer[sizeof(long)], parsePos - sizeof(long));
					// adjust parsePos to reflect we removed the body size long
					parsePos -= sizeof(long);
					// Now move to read data body parse state
					parseState = readDataBodyState;
				}
			}
			break;
		case readDataBodyState: {
				// We have body data to transfer
				if (parsePos > 0) {
					// This is amount left we need from body data
					long amountLeft = bodyDataSize - bodyDataPos;
					// Calc transfer size, allowing for fact we may have too much
					int transferSize = parsePos;
					if (transferSize > amountLeft) transferSize = amountLeft;
					// Transfer the data from parse buffer
					memcpy(&bodyData[bodyDataPos], &parseBuffer[0], transferSize);
					// Adjust bodyDataPos by transferSize
					bodyDataPos += transferSize;
					// Remove the parse data we just transferred .. memory overlap so use memmove
					memmove(&parseBuffer[0], &parseBuffer[transferSize], parsePos - transferSize);
					// adjust parsePos to reflect we removed the data transferred
					parsePos -= transferSize;
				}
				// Check if we have transferred all the body data so bodyDataPos == bodyDataSize
				if (bodyDataPos == bodyDataSize) {
					// Now move to data available parse state ... your data is ready
					parseState = readDataAvailState;
				}
			}
			break;
		case readDataAvailState: {
			        // Your data is available in bodydata
					// Do what you want with it

			        //.... Use and abuse your bodyData 
					// You havent said what happens to data but its available HERE

					// Set the parser back to the search for signature state for nexy packet
					parseState = readSigState;
			}
			break;
	}

	return (TRUE);	// Parser still working normally return true
}

manoharbalu wrote:

Is there any specific ways or methods of send/receive huge data continuosly via Csocket.

How to send the big data every interval in a better way.

mname = SHAWSHANK
mgenre = REDEMPTION
mlanguage = 120
mrelease_year = 5
mamount = MYSTERY - which is not an integer
mrating = 2009
mruntime = ENGLISH - also not an integer

the final 3 will now go into the title next time round the loop.

Farhan_Karim wrote:

works if...all the strings...seperated by special characters.