Re: socket programming
sirisha,
You need to learn a few of the rules regarding resource management.
The first and foremost is that for every "open" there is a "close".
That goes for all the various create/delete, new/delete, alloc/dealloc,
and similar pairings. Many operations pairs like fopen/fclose,
FindFile/FindClose are a bit harder to find when you don't notice
how they are supposed to be used.
Your code is full of potential resource leaks, though you don't
mention which ones you are interested in finding. Since the leaks
are noticeable I'll presume they are big ones.
See my notes inline for a few of them.
On Tue, 6 Jun 2006 12:26:15 UTC, "sirisha" <sirishamohan2000@gmail.com> wrote:
the code for sending files is like this : in which i am sending the
contents
in the order :
file size, filename size, file name, file contents
void Sender::SendData(void)
{
CString findFilePath=filePathInformation+"\\*.*";
bWorking=finder.FindFile(_T((LPCTSTR)findFilePath));
finder is not closed during many of the exit points of your loops.
while (bWorking)
{
bWorking = finder.FindNextFile();
CString findFileName(finder.GetFileName());
if(findFileName.Compare(".") == 0 || findFileName.Compare("..")
== 0)
{
//CloseSocket();
continue;
}
int returnValue=SetAddress();
if(returnValue==0)
{
CString sendFilePath=finder.GetFilePath();
FILE *filePointer;
//int returnedValue;
if( (filePointer = fopen(sendFilePath, "rb" )) == NULL )
{
cout<<endl<<"File open error";
CloseSocket();
A good example of exiting without closing all resources. Here
your return doesn't close finder.
return;
}
else
{
char *fileContentBuffer;
unsigned int bytesRead,fileNameLength;
long fileSize;
//long allocReqNum;
//first send the file size details
fseek(filePointer, 0, SEEK_END); // Move File Pointer to EOF
fileSize=ftell(filePointer); // Get position of File Pointer
rewind(filePointer); // Move File Pointer back to beginning
of file
fileContentBuffer = (char *)calloc(32,sizeof(long));
//returnedValue=_CrtIsMemoryBlock(fileContentBuffer, 32,
&allocReqNum, NULL, NULL);
ltoa( fileSize, fileContentBuffer,10 );
int returnValue = send(mySocket,fileContentBuffer,32,0);
if(returnValue == SOCKET_ERROR)
{
cout<<endl<<"Error in Sending File Length";
CloseSocket();
You're leaking the fileContentBuffer here.
return;
}
else
cout<<endl<<"File Size Sent Successfully : "<<fileSize;
//long valueReturned=_CrtSetBreakAlloc(allocReqNum);
//delete fileContentBuffer;
free(fileContentBuffer);
//send file name length
fileNameLength=findFileName.GetLength();
fileContentBuffer = (char *)calloc(32,sizeof(int));
char *returnChar=itoa( fileNameLength, fileContentBuffer, 10 );
returnValue = send(mySocket,fileContentBuffer,32,0);
if(returnValue == SOCKET_ERROR)
{
cout<<endl<<"Error in Sending File Details";
CloseSocket();
return;
}
else
cout<<endl<<"File Length Sent Successfully : "<<fileNameLength;
free(fileContentBuffer);
//delete fileContentBuffer;
//Send the file name
char *temporaryBuffer;
fileContentBuffer = (char *)calloc(255,sizeof(char));
temporaryBuffer=findFileName.GetBuffer(fileNameLength);
strcpy(fileContentBuffer,temporaryBuffer);
returnValue = send(mySocket,fileContentBuffer,fileNameLength,0);
if(returnValue == SOCKET_ERROR)
{
cout<<endl<<"Error in Sending in File Name";
CloseSocket();
return;
}
else
cout<<endl<<"File Name Sent Successfully : "<<temporaryBuffer;
free(fileContentBuffer);
//delete fileContentBuffer;
//sending the file
fileContentBuffer = (char *)calloc(fileSize,sizeof(char));
bytesRead=fread(fileContentBuffer,sizeof(char),fileSize,filePointer);
returnValue = send(mySocket,fileContentBuffer,fileSize,0);
if(returnValue == SOCKET_ERROR)
{
cout<<endl<<"Error in Sending File Contents";
CloseSocket();
return;
}
else
cout<<endl<<"File Sent Successfully "<< returnValue<<" bytes";
//delete fileContentBuffer;
free(fileContentBuffer);
}
//returnedValue=_CrtDumpMemoryLeaks();
fclose(filePointer);
CloseSocket();
}
else
{
cout<<endl<<"Error in connecting";
CloseSocket();
return;
}
}
}
and the receiver is getting the data in the same order.
in both of them i am getting the same memory leak errors,
could u help regarding this,
that would be greatful to me,
sirisha.
I'm not sure if my newsreader mangled your code or not. Proper
indention helps spot many leaks. I've also found that writing
code in blocks helps. That is whenever you use one of the
paired calls, immediately write the closing call. For example
before writing the code inside an if statement, close out a FILE.
{ // Snippet
FILE *File = fopen ("MyFile.txt", "rb");
if (File)
{ // File opened
fclose (File);
}
else
{ // File not opened
}
}
Even this example still has trouble. I didn't check
for fclose failing. I also didn't set File to NULL or 0
after invalidating it.
Creating a good style and following it (in any language)
helps prevent many coding errors.
You may also want to invest in a log or debug capability.
Even printf is very useful for finding errors. Watch the
open/close pairs and see what is obviously missing. This
will bite you very hard in production. I've seen many
developers that can code at their desk and think the code
works. Upon release the customer sees many problems and
all the developer hears is "is doesn't work". You must
have a long term strategy for understanding why your code
sometimes doesn't work. Yes, it takes a bit more code,
but when there is a problem, you can generally find it
very quickly.
Good luck,
David