[RESOLVED] Help with memory leak

[fire_]

Hi. I'm having problems with my code. First of all i think i should mention i'm doing some sockets prgraming (non-MFC). Everything is working fine, however,

_CrtDumpMemoryLeaks()

is telling me that there's a memory leak. I did some research and i found out that it appears after these lines of code:

//char buff[257]
//wchar_t dataBuff[257]
//std::wstring *data - this is a valid pointer passed to function

received += singleRecv;
buff[singleRecv] = '\0';
mbstowcs_s(&converted, dataBuff, 257, buff, singleRecv);
*data += dataBuff;

Text with wich memory leak appears to be is 9 symbols. These are pretty much all variables wich gets in touch with it but it seems that none of these variables' address matches memory leak address. I think this might be silly mistake or something i'm overlooking but i can't find it. Hopefully you can Didn't felt a need to burden this post with whole function code, but feel free tell me if you need it.

Thanks in advance,
Fire_

[Paul McKenzie]

Hi. I'm having problems with my code.

What is "converted"?

mbstowcs_s(&converted, dataBuff, 257, buff, singleRecv);
*data += dataBuff;

In general, it helps if you posted the entire code, so we know what the declaration of everything is supposed to be.

In addition:

received += singleRecv;
buff[singleRecv] = '\0';

How do we know what the value of "singleRecv" is? Also, your databuff and buf are commented out, so who knows what they really are.

Last, why not write a simple program and call just that one function. Is there a memory leak in that simple program? There is no need to attach a giant function -- all you need to do is write a simple program, 3 or 4 lines, that sets up those arrays, calls the mbstowcs_s() function, and then exits. Then you check if there are memory leaks. If there aren't any, then there is nothing wrong with mbstowcs_s(), given that it is processing "good" data.

Regards,

Paul McKenzie

[fire_]

Last, why not write a simple program and call just that one function. Is there a memory leak in that simple program? There is no need to attach a giant function -- all you need to do is write a simple program, 3 or 4 lines, that sets up those arrays, calls the mbstowcs_s() function, and then exits. Then you check if there are memory leaks. If there aren't any, then there is nothing wrong with mbstowcs_s(), given that it is processing "good" data.

Regards,

Paul McKenzie

Thanks for answer. I already tried that and there's no memory leaks in there. So here's the full code of functions:

Main class declaration

class CWINSOCK_API CWinSock
{
public:
	CWinSock();
	CWinSock(const CWinSock&);
	~CWinSock();

	// Initialize WinSock
	int Initialize(WORD version = 0x101);
	// Shutdown WinSock
	void Deinitialize();
	// Sends packet directly and returns amount of data sent (blocking)
	int SendPacket(SOCKET s, wchar_t *data, DWORD Flag);
	// Reads packet from stream and returns if CRC is correct (blocking)
	bool ReceivePacket(SOCKET s, PACKET *packet);
	// Receives data chunk
	int ReceiveData(SOCKET s, std::wstring *data, int len);
private:
	// Lookup table array
	ULONG crc32_table[256];
	// Builds Lookup table array
	void Init_CRC32_Table();
	// Reflects CRC bits in the lookup table
	ULONG Reflect(ULONG ref, char ch);
	// Creates a CRC from a string buffer
	int Get_CRC(wchar_t* text);
};

Function to received specific amount of data. Memory leak appears here

int CWinSock::ReceiveData(SOCKET s, std::wstring *data, int num)
{
	if(num  <= 0)
		return -1;
	int received = 0, singleRecv = 0;
	size_t converted;
	char buff[257];
	wchar_t dataBuff[257];
	
	_CrtDumpMemoryLeaks();
	singleRecv = recv(s, buff, num, NULL);
	
	_CrtDumpMemoryLeaks();
	if(singleRecv > 0)
	{
		received += singleRecv;
		buff[singleRecv] = '\0';
		mbstowcs_s(&converted, dataBuff, 257, buff, singleRecv);
		*data += dataBuff;
	}
	_CrtDumpMemoryLeaks(); // That's where memory leak first appears
	DWORD start = GetTickCount();
	while(received < num && (GetTickCount()-start)<250)
	{
		singleRecv = recv(s, buff, num-received, NULL);
		if(singleRecv > 0)
		{
			received += singleRecv;
			buff[singleRecv] = '0';
			mbstowcs_s(&converted, dataBuff, 257, buff, singleRecv);
			*data += dataBuff;
		}
	}
	return received;
}

Code to get crc of packet

int CWinSock::Get_CRC(wchar_t* text)
{
	ULONG  ulCRC(0xffffffff);
	int len;
	wchar_t* buffer;

	len = wcslen(text);
	buffer = (wchar_t*)text;
	while(len--)
		ulCRC = (ulCRC >> 8) ^ crc32_table[(ulCRC & 0xFF) ^ *buffer++];
	return ulCRC ^ 0xffffffff;
}

Simple function to convert wchar to bytes array. Used in main function so included for clarity

void wcharToBytes(wchar_t *src, unsigned char *dest, int num)
{
	char temp[2];
	size_t converted;
	for(int i=0; i<num; i++)
	{
		if(src[i] != 0)
		{
			wcstombs_s(&converted, temp, 2, &src[i], 1);
			dest[i] = (BYTE)temp[0];
		}
		else
			dest[i] = 0;
	}
}

Main function wich calls ReceiveData()

bool CWinSock::ReceivePacket(SOCKET s, PACKET *packet)
{
	_CrtDumpMemoryLeaks();
	int DataLen, CRC;
	std::wstring buff;
	BYTE bytes[4];
	size_t converted;
	ZeroMemory(bytes, 4);
	int received = 0;
	int packetCRC = 0;

	// HEADER
	// Get data length
	received = ReceiveData(s, &buff, 4);
	wcharToBytes((wchar_t*)buff.c_str(), bytes, 4);
	memcpy_s(&DataLen, 4, bytes, 4);
	if(received != 4)
		return false;
	// Get data CRC
	received = ReceiveData(s, &buff, 4);
	wcharToBytes((wchar_t*)buff.c_str(), bytes, 4);
	memcpy_s(&CRC, 4, bytes, 4);
	if(received != 4)
		return false;
	// TODO: Add resend if couldn't read all data from stream
	// TODO: Add get flag

	// BODY
	// Get data
	std::wstring dataBuff;
	received = 0;
	if(DataLen)
	{
		received  = ReceiveData(s, &dataBuff, DataLen); // Leak appears in this call
		_CrtDumpMemoryLeaks();
		if(received < DataLen)
			Sleep(30);
		// TODO: Add resend packet if too small
		packet->body.data = dataBuff;
		packetCRC = Get_CRC((wchar_t*)dataBuff.c_str());
	}
	// Fill packet structure
	_CrtDumpMemoryLeaks();
	packet->header.CRC = CRC;
	packet->header.size = DataLen;

	// Check CRC of received packet
	if(packetCRC != CRC)
		return false;
	else
		return true;
}

Thanks in advance,
Fire_

[superbonzo]

you're not using CrtDumpMemoryLeaks correctly. _CrtDumpMemoryLeaks checks if all memory allocations in the process heap have been freed at the point of its call. Hence, invoking it in the middle of your program will give false positives. For example

int main()
{
    char* p = new char;
    _CrtDumpMemoryLeaks();
    delete p;
}

clearly, this program has no memory leaks as it is, but _CrtDumpMemoryLeaks comlpains anyway. Call it at the end of the program ( or wherever all heap resources are expected to be released ) instead.

[Paul McKenzie]

Thanks for answer. I already tried that and there's no memory leaks in there.

Well, as superbonzo stated, you're using the CrtDumpMemoryLeaks incorrectly. Of course if you stick that call in the middle of running code, especially code where you're concatenating onto a wstring, you will get a memory leak report.

CrtDumpMemoryLeaks is obviously going to say you have a memory leak, since the wstring variables have not gone out of scope yet, which is where the deallocation of the string data occurs.

Regards,

Paul McKenzie

[fire_]

Ok... As I guessed earlier it was a silly mistake :P Thank you very much, you saved me hours of further research