C / C++ / MFC

void SurServer::OnAccept(int nErrorCode) 
{
	// TODO: Add your specialized code here and/or call the base class
	SurServer* ps=new SurServer(pWnd);
	Accept(*ps);
	
	
	CAsyncSocket::OnAccept(nErrorCode);
}

void SurServer::OnReceive(int nErrorCode) 
{	
	char *pBuf = new char[4096];
	int iBufSize = 4095;
	int iRcvd;
	CString strRecvd;
	iRcvd =  Receive(pBuf, iBufSize);
	pBuf[iRcvd] = NULL;
        strRecvd = pBuf;

	((CSpoolerSurDlg*)pWnd)->NuevaTarea(strRecvd);

}

Stream.begin();
void * Stream.end();
Stream.clear();
Stream.add(void * data, int size);

Stream myStream;
// Data for testing:
void * t1 = allocateMem(11); // 11 Bytes
void * t2 = allocateMem(21); // 21 Bytes
void * t3 = allocateMem(31); // 31 Bytes
// void * allocateMem(int size) is my function for allocating Memory... you can use memalloc as well
// strings as Data -> don't for get the ending Zero pointer ('\0')
memmove(t1,"1________x\0",11);
memmove(t2,"2________xa________x\0",21);
memmove(t3,"3________x_________xb________x\0",31);
//          1234567890123456789012345678901
/////////////////////1/////////2/////////3////////////////////////////

myStream.begin(); // tell the class to clear old stream and prepare for new
printf(" fill stream:\n"); myStream.add(t1,11); // adding data to stream
printf(" fill stream:\n"); myStream.add(t2,21);
printf(" fill stream:\n"); myStream.add(t3,31);
printf(" --- stream completed ---\n");

// end stream and return the resolving data with header and block information:
char * myData = (char *) myStream.end(); 

/////////////////////////////////////////////////////////////////////
// rebuild data from stream:
//

// get header information:
tStreamheader * pStreamheader = (tStreamheader *)myData;

// how many blocks ?
printf(" num of blocks: %i\n",pStreamheader->numblocks);

// first block size?
unsigned long * pBlocksize;
char * pBlockdata = NULL;

// offset to step throu stream
unsigned long myoffset = sizeof(tStreamheader); // we want the data, so skip the header

// loop to print out the data of the block
for (int i = 0; i< (int) pStreamheader->numblocks; i++) // all blocks
{
  pBlocksize = (unsigned long *) (myData + myoffset); // blocksize
  myoffset+=sizeof(unsigned long); // skip blocksize to get blockinfo
  pBlockdata = (char *)allocateMem(*pBlocksize); // make room for block data
  memmove(pBlockdata, myData + myoffset,*pBlocksize); // copy block data
  myoffset+=*pBlocksize; // skip block data to get next block lenght

  // print out what we got:
  printf(" Stream Block %i size = %u\n", i, *pBlocksize);
  printf(" Stream Block data = %s\n",pBlockdata);
		
  pBlockdata = freeMem(pBlockdata); // delete blockdata 
}

t1 = freeMem(t1);
t2 = freeMem(t2);
t3 = freeMem(t3);