¿procesos que charlan entre ellos usando tuberias con nombre?

[[escafandra]]

Veo que te has puesto manos a la obra.

He estado ocupado pero en un ratito libre he preparado un ejemplo a bajo nivel con WinSock en programas de consola. Se trata de un pequeño prototipo de chat con modelo cliente servidor y protocolo TCP aceptando una sola conexión, para no liar la cosa.

Dejo el código muy comentado por si más adelante te interesa el manejo a bajo nivel sin componentes:

Servidor:

Código PHP:

int main(int argc, char* argv[])
{
  WSADATA Wsa;
  SOCKET Sock_e;   // Sock de escucha
  SOCKET Sock_c;   // Sock de comunicación
  struct sockaddr_in Server, Client, AddrEnRoute;
  int Len=0;
  char Buffer[1024];
  DWORD Port = 9999;

  // Inicializamos
  printf("Inicializando el servidor...\n");
  if(WSAStartup(MAKEWORD(2, 0), &Wsa) != 0) return 0;

  //Creamos el socket
  if((Sock_e = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP)) != INVALID_SOCKET){
    // Dirección IP y puerto
    Server.sin_family = AF_INET;
    Server.sin_addr.s_addr = INADDR_ANY;
    Server.sin_port = htons(Port);
    AddrEnRoute = Server;
    AddrEnRoute.sin_addr = *((struct in_addr *)gethostbyname("localhost")->h_addr);

    // Asociamos el socket al puerto
    if(bind(Sock_e, (SOCKADDR*)&Server, sizeof(Server)) != -1){
      // Bucle principal del servidor
      // Este servidor nunca termina, siempre escuchará
      while(true){
        // Escuchando puerto
        printf("\nEscuchando por el puerto %d\n", Port);
        if (listen(Sock_e, 1) != -1){
          //hay una conexión entrante y la aceptamos
          Len = sizeof(sockaddr);
          Sock_c = accept(Sock_e,(sockaddr*)&Client, &Len);
          if(Sock_c == INVALID_SOCKET) continue;
          strcpy(Buffer, "Aceptada conexión\n\n");
          printf(Buffer);

          // Bucle de comunicación
          do{
            // Leemos los datos entrantes
            Len = recv(Sock_c, Buffer, sizeof(Buffer), 0); //recibimos los datos que envie
            if(Len<0) continue;
            // Si tenemos datos seguimos
            printf("- "); printf(Buffer);
            if(!strnicmp(Buffer, "Adios", 5)) break;
            printf("\n>> ");
            gets(Buffer);
            strcat(Buffer, "\n");
            send(Sock_c, Buffer, lstrlen(Buffer)+1, 0);
          } while(Len && Len!=-1);

          closesocket(Sock_c);
        }
      } // While(true)
      closesocket(Sock_e);
    } // if(bind)
  } // if(Sock_e)

  WSACleanup();
  return 0;
} 


Cliente:

Código PHP:

int main(int argc, char* argv[])
{
  WSADATA Wsa;
  SOCKET  Sock;
  struct hostent *host;
  struct sockaddr_in direc;
  DWORD Port = 9999;
  char Buffer[1024];
  int Len;
  bool Salir = false;

  //Inicializamos la librería winsock
  printf("Inicializando Cliente....\n\n");
  WSAStartup(MAKEWORD(2,2),&Wsa);

  //creamos el Sock y comenzamos el bucle principal
  while(!Salir){
    Sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if(Sock !=-1){
      //Dirección IP del servidor y Puerto
      host = gethostbyname("localhost");
      direc.sin_family=AF_INET;
      direc.sin_port = htons(Port);
      direc.sin_addr = *((struct in_addr *)host->h_addr);
      ZeroMemory(direc.sin_zero, 8);

      // Pedimos conexión al servidor
      printf("Esperando conexión al servidor...\n\n");
      while(connect(Sock, (sockaddr *)&direc, sizeof(sockaddr))){Sleep(200);}

      printf("Conexión aceptada\n\n");
      // Saludamos
      strcpy(Buffer, "Gracias por aceptar la conexión\n");
      printf(">> "); printf(Buffer);
      send(Sock, Buffer, lstrlen(Buffer)+1, 0);

      //mientras el Sock no se haya desconectado
      do {
        Len = recv(Sock, Buffer, sizeof(Buffer), 0);
        if(Len<0) continue;
        // Si hay satos, seguimos
        printf("- "); printf(Buffer);
        if(!strnicmp(Buffer, "Adios", 5)) {Sleep(400); Salir = true; break;}
        printf("\n>> ");
        gets(Buffer);
        strcat(Buffer, "\n");
        send(Sock, Buffer, lstrlen(Buffer)+1, 0);
      } while(Len && Len!=-1);
      closesocket(Sock);
    }
    Sleep(500);
  }

  WSACleanup();
  return 0;
} 


Saludos.

[aguml]

amigo ya he conseguido hacer eso pero ahora quiero enviar archivos y como en c++builder para el chat lo tengo asincronico pues no puedo ir recibiendo trozos e indicar al servidor que ya llegó para que siga ya que me los manda todos de golpe y lo mando en bloques de 1024 bytes y si pasa de 8192 bytes (8 bloques) el servidor da error al enviar y ademas al usar retval = Socket->ReceiveBuf(buffer,lenBuff); lo que obtengo es tanto la cadena que envio como flag para indicar que es un archivo lo que quiero enviar, como el contenido del archivo, todo en un bloque de 8192 y luego vuelve a entrar en el evento y me muestra el resto como mensajes de texto. ¿como hago para mandar bloques de un archivo y que el cliente lo reciba como tal y luego los una y obtenga un archivo igual que el original? Para archivos pequeños he hecho esto:

Código PHP:

#define SIZEBLOCK 1024
#define SIZEFLAG 11

char flagFile[SIZEFLAG] = {"\n\n_File_\n\n\0"};

void __fastcall TChatForm::ClientSocketRead(TObject *Sender,
      TCustomWinSocket *Socket)
{
  // Cuando el servidor envia datos al ciente y este los ha de procesar
  unsigned char *buffer;
  int retval,lenBuff;

  lenBuff = Socket->ReceiveLength();
  buffer = new char[lenBuff + 1];
  memset(buffer,0,sizeof(buffer));

  retval = Socket->ReceiveBuf(buffer,lenBuff);

  if(strcmp(buffer, flagFile) == 0)
  {
        unsigned char *aux = new char[1 + (lenBuff - SIZEFLAG)];
        memset(aux,0,sizeof(aux));
        memcpy(aux, buffer + SIZEFLAG, lenBuff - SIZEFLAG);
        FILE *salida;
        salida = fopen("salida.txt","wb");
        fwrite(aux,lenBuff - SIZEFLAG,1,salida);
        fclose(salida);
        delete [] aux;
  }else{
     //Si no es una imagen mostramos el mensaje enviado
     RichEdit1->SelStart = RichEdit1->Text.Length();
     RichEdit1->SelLength = 0;
     RichEdit1->SelAttributes->Color = clGreen;
     RichEdit1->Lines->Add(EditServer->Text + ": " + AnsiString( (char*)buffer));  // Añadir los datos al memo de recepción
  }
  delete [] buffer;
} 


Con eso puedo enviar un archivo de texto de 8192 - SIZEFLAG sin problemas pero si se pasa de ese tamaño ya tengo el problema.

[aguml]

A ver, para archivos pequeño he hecho esto y funciona:

Código PHP:

char flagFile[SIZEFLAG] = {"\n\n_File_\n\n\0"};
struct{
        char name[256];
        long size;
}archivo;

bool recvFile, recvStructFile;

void __fastcall TChatForm::ButtonSendFileClick(TObject *Sender)
{ //Aqui se envia el fichero

        long tamanio = 0;
        char buffer[SIZEBLOCK];
        FILE *hFile;
        int enviados = 0, leidos = 0, retval = 0;

        if(OpenDialog1->Execute())
        {
                hFile = fopen(OpenDialog1->FileName.c_str(),"rb");
                fseek(hFile, 0, SEEK_END);
                tamanio = ftell(hFile);

                fseek(hFile, 0, SEEK_SET);

                if(hFile)
                {
                   strcpy(archivo.name, ExtractFileName(OpenDialog1->FileName).c_str());
                   archivo.size = tamanio;

                   if(IsServer){
                      retval = ServerSocket->Socket->Connections[0]->SendBuf(flagFile, SIZEFLAG);
                      retval += ServerSocket->Socket->Connections[0]->SendBuf(&archivo, sizeof(archivo));
                   }else{
                      retval = ClientSocket->Socket->SendBuf(flagFile, SIZEFLAG);
                      retval += ClientSocket->Socket->SendBuf(&archivo, sizeof(archivo));
                   }

                   if(retval == (SIZEFLAG + sizeof(archivo)))
                   {
                           while(!feof(hFile))
                           {
                                //voy por aqui y no funciona
                                leidos = fread(buffer, sizeof(char), SIZEBLOCK,hFile);

                                if(IsServer){
                                   retval = ServerSocket->Socket->Connections[0]->SendBuf(buffer, leidos);
                                }else{
                                   retval = ClientSocket->Socket->SendBuf(buffer, leidos);
                                }

                                if(retval != leidos)
                                {
                                   RichEdit1->SelStart = RichEdit1->Text.Length();
                                   RichEdit1->SelLength = 0;
                                   RichEdit1->SelAttributes->Color = clRed;
                                   RichEdit1->Lines->Add("Error en el envio del fichero");
                                   break;
                                }else{
                                   enviados += retval;
                                }

                                if(ferror(hFile))
                                {
                                   RichEdit1->SelStart = RichEdit1->Text.Length();
                                   RichEdit1->SelLength = 0;
                                   RichEdit1->SelAttributes->Color = clRed;
                                   RichEdit1->Lines->Add("Error durante la lectura del fichero. Vuelva a intentarlo.");
                                   break;
                                }
                           }
                   }else{
                        RichEdit1->SelStart = RichEdit1->Text.Length();
                        RichEdit1->SelLength = 0;
                        RichEdit1->SelAttributes->Color = clRed;
                        RichEdit1->Lines->Add("Error inesperado al enviar el archivo.");
                   }
                   fclose(hFile);

                   if(tamanio != enviados)
                   {
                      RichEdit1->SelStart = RichEdit1->Text.Length();
                      RichEdit1->SelLength = 0;
                      RichEdit1->SelAttributes->Color = clRed;
                      RichEdit1->Lines->Add("Error en el envio del fichero. El tamaño del fichero original no coincide con el tamaño del fichero enviado.");
                   }
                }
        }
}
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
// Se produce cuando un socket de cliente debe leer la información de la conexión de socket.
//---------------------------------------------------------------------------
void __fastcall TChatForm::ClientSocketRead(TObject *Sender,
      TCustomWinSocket *Socket)
{
  // Cuando el servidor envia datos al ciente y este los ha de procesar
  unsigned char *buffer;
  int size,lenBuff;

  lenBuff = Socket->ReceiveLength();
  buffer = new char[lenBuff + 1];
  memset(buffer,0,sizeof(buffer));

  size = Socket->ReceiveBuf(buffer,lenBuff);

  if(strcmp(buffer, flagFile) == 0)
  {
        recvFile = true;
  }

  else if(recvFile == true && size == (sizeof(archivo.name) + sizeof(archivo.size)))
  {
        memcpy(archivo.name, buffer, sizeof(archivo.name));
        memcpy(&archivo.size, buffer + sizeof(archivo.name), sizeof(archivo.size));
        recvStructFile = true;
  }else if(recvFile == true && recvStructFile == true){
        FILE *salida;
        salida = fopen(AnsiString(ExtractFilePath(Application->ExeName) + "\\\\" + archivo.name).c_str(),"wb");
        fwrite(buffer, size, 1, salida);
        fclose(salida);
  }else{
     //Si no es una imagen mostramos el mensaje enviado
     RichEdit1->SelStart = RichEdit1->Text.Length();
     RichEdit1->SelLength = 0;
     RichEdit1->SelAttributes->Color = clGreen;
     RichEdit1->Lines->Add(EditServer->Text + ": " + AnsiString( (char*)buffer));  // Añadir los datos al memo de recepción
  }
  delete [] buffer;
}

//---------------------------------------------------------------------------
// Se produce cuando el socket de servidor debe leer la información de un socket cliente.
//---------------------------------------------------------------------------
void __fastcall TChatForm::ServerSocketClientRead(TObject *Sender,
      TCustomWinSocket *Socket)
{
  // Cuando el cliente envia datos al servidor y este los ha de procesar
  unsigned char *buffer;
  int size,lenBuff;

  lenBuff = Socket->ReceiveLength();
  buffer = new char[lenBuff + 1];
  memset(buffer,0,sizeof(buffer));

  size = Socket->ReceiveBuf(buffer,lenBuff);

  if(strcmp(buffer, flagFile) == 0)
  {
        recvFile = true;
  }

  else if(recvFile == true && size == (sizeof(archivo.name) + sizeof(archivo.size)))
  {
        memcpy(archivo.name, buffer, sizeof(archivo.name));
        memcpy(&archivo.size, buffer + sizeof(archivo.name), sizeof(archivo.size));
        recvStructFile = true;
  }else if(recvFile == true && recvStructFile == true){
        FILE *salida;
        salida = fopen(AnsiString(ExtractFilePath(Application->ExeName) + "\\\\" + archivo.name).c_str(),"wb");
        fwrite(buffer, size, 1, salida);
        fclose(salida);
  }else{
     // Cuando el cliente envia datos al servidor y este los ha de procesar
     RichEdit1->SelStart = RichEdit1->Text.Length();
     RichEdit1->SelLength = 0;
     RichEdit1->SelAttributes->Color = clGreen;
     RichEdit1->Lines->Add(Socket->RemoteHost + ": " + AnsiString( (char*)buffer));  // Añadir los datos al memo de recepción
  }
} 


Tiene un problema y es que cuando se hace un SendBuf, al ser asincronico, no espera respuesta y como tarde mas de la cuenta en llegar el bloque, se acumulan y se añaden los bloques unos a otros, o sea, si el primer paquete mide 11 y el segundo mide 260, como tarde mucho en llegar el primero llegara un solo paquete de 271 y asi con todo lo que se envie. Ese es el problema que tengo para poder enviar archivos mas grandes tambien. No se como hacer para que no envie otro paquete hasta que reciba el cliente el anterior y lo procese y asi con todos.

[aguml]

Bueno, he conseguido transferir archivos aunque no creo que sea del todo correcto lo que hago para conseguirlo . Primero paso una mascara para indicar que es un envio de archivo y a continuacion mando una estructura donde indico el nombre del archivo, su tamaño, y el número de bloques a enviar. He colocado un Sleep para poder enviar sin perder datos por el camino. Os adjunto el fuente para que si alguien quiere mirarlo y ayudarme a mejorarlo para hacerlo funcionar correctamente pues se lo agradeceria ya que a veces se pierden bytes por el camino aunque la mayor parte de las veces llega el fichero correctamente pero otras veces se queda el receptor esperando como si faltara algun bloque por llegar.

Aqui el link

[[escafandra]]

No creo que estés usando el método adecuado. Es mejor que la comunicación sea síncrona y ten en cuenta que los paquetes se pueden unir o separar. No tengo ahora tiempo de realizar un ejemplo. Puedes, también, usar la API TransmitFile

Te dejo un fragmento de código funcional para recibir ficheros por esta vía, previamente debes haber comunicado el tamaño del fichero y nombre a transferir (SizeFile y lpPathName):

Código PHP:

  int  Size = 1024*10;
  BYTE *Buffer = (BYTE*)VirtualAlloc(0, Size, MEM_COMMIT, PAGE_READWRITE);
  UINT  Len = 0;
  int   nBytes = 0;
  HANDLE hFile = CreateFile(lpPathName, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_FLAG_WRITE_THROUGH, 0);
  if(hFile != INVALID_HANDLE_VALUE){
    do {
      Len = Recv(Sock, Buffer, Size, 0, 10000);
      if(Len == -1) break;
      _lwrite((int)hFile, Buffer, Len);
      nBytes += Len;
    } while (nBytes != FileSize)
    CloseHandle(hFile);
  }
  VirtualFree(Buffer, 0, MEM_RELEASE); 


Saludos.

[[escafandra]]

Bueno, te he preparado un rápido ejemplo sobre el chat que te envié antes y sin usar componentes de VCL. Sokets "a pelo".

En el chat, si el cliente envía "Envia Fichero" (sin acento para no confundir caracteres), el servidor envía un fichero llamado Prueba0.bmp que es un bmp grande. El cliente lo recibe y lo guarda como Prueba.bmp. A continuación el server recibe la palabra y sigue la comunicación...

Te expongo las funciones que envían y reciben el fichero:

TransmitFile.h

Código PHP:

#ifndef TRANSMIT_FILE_H
#define TRANSMIT_FILE_H

void TransmitFile(SOCKET Sock, char* lpPathName);
void ReceiveFile(SOCKET Sock, char* lpPathName, int FileSize);
void ReceiveFile(SOCKET Sock);

#endif 


TransmitFile.cpp

Código PHP:

#include <windows.h>
#include <winsock2.h>
#include <Mswsock.h>

#include "TrasmitFile.h"

struct TFileData{
  char FilePath[MAX_PATH*2];
  int FileSize;
};

void TransmitFile(SOCKET Sock, char* lpPathName)
{
  if(Sock == INVALID_SOCKET || !lpPathName) return;
  if(!*lpPathName) return;

  char Msg[10];
  HFILE hFile = _lopen(lpPathName, OF_READ);
  if(hFile == -1) return;
  int FileSize = GetFileSize((HANDLE)hFile, 0);
  TFileData FileData;
  strcpy(FileData.FilePath, lpPathName);
  FileData.FileSize = FileSize;
  send(Sock, (char*)&FileData, sizeof(TFileData), 0);
  recv(Sock, Msg, sizeof(Msg),0);
  if(!strncmp(Msg, "Ok", 2)){
    TransmitFile(Sock, (HANDLE)hFile, FileSize, 0,0,0,0);
  }
  _lclose(hFile);
}

void ReceiveFile(SOCKET Sock)
{
  TFileData FileData;
  recv(Sock, (char*)&FileData, sizeof(FileData),0);
  send(Sock, "Ok", 2, 0);
  ReceiveFile(Sock, "Prueba.bmp", FileData.FileSize);

}

void ReceiveFile(SOCKET Sock, char* lpPathName, int FileSize)
{
  int  Size = 1024*10;
  BYTE *Buffer = (BYTE*)VirtualAlloc(0, Size, MEM_COMMIT, PAGE_READWRITE);
  UINT  Len = 0;
  int   nBytes = 0;
  HANDLE hFile = CreateFile(lpPathName, GENERIC_WRITE, 0, NULL, OPEN_ALWAYS, FILE_FLAG_WRITE_THROUGH, 0);
  if(hFile != INVALID_HANDLE_VALUE){
    do {
      Len = recv(Sock, Buffer, Size, 0);
      if(Len == -1) break;
      _lwrite((int)hFile, Buffer, Len);
      nBytes += Len;
    } while (nBytes != FileSize);
    CloseHandle(hFile);
  }
  VirtualFree(Buffer, 0, MEM_RELEASE);
} 


Usa la API TransmitFile, que usa socket, puedes sustituirla por una función equivalente a bajo nivel.

PD/ Borro el anterior chat porque este es idéntico, añadiendo la nueva funcionalidad

Saludos.

[aguml]

Amigo he estado haciendo pruebas con la api que comentas pero claro, tu usas un tipo SOCKET y yo intento hacer lo mismo con un TSocketServer y un TSocketClient y la verdad es que todo lo que pruebo acaba retornandome false en TransmitFile. He probado esto:

Código PHP:

bool transmitido;
if(IsServer){
   transmitido = TransmitFile((unsigned int)ServerSocket->Socket->Connections[0]->Handle, (HANDLE)hFile, tamanio, 0,0,0,0);
}else{
   transmitido = TransmitFile((unsigned int)ClientSocket->Socket->Handle, (HANDLE)hFile, tamanio, 0,0,0,0);
} 


y esto:

Código PHP:

bool transmitido;
if(IsServer){
   transmitido =  TransmitFile((unsigned  int)ServerSocket->Socket->Handle,  (HANDLE)hFile, tamanio, 0,0,0,0);
}else{
   transmitido = TransmitFile((unsigned int)ClientSocket->Socket->Handle, (HANDLE)hFile, tamanio, 0,0,0,0);
} 


y tambien esto:

Código PHP:

bool transmitido;
if(IsServer){
   transmitido =  TransmitFile((unsigned  int)ServerSocket->Handle,  (HANDLE)hFile, tamanio, 0,0,0,0);
}else{
   transmitido = TransmitFile((unsigned int)ClientSocket->Handle, (HANDLE)hFile, tamanio, 0,0,0,0);
} 


y en todos los casos retorna como false y en el receptor no hay señales de que se reciba algo. Son asincronicos y no se si esto tiene que ver.

[aguml]

Bueno amigo, he estado viendo el modo en que me indicabas y he modificado mi funcion para que use lo que me indicabas, o sea, uso TransmitFile y una funcion propia llamada ReceiveFile. El problema es que el archivo que recibo es corrupto porque termina la funcion de recepcion pero no recibo todos los bytes. He comprobado que en la funcion ReceiveFile salgo del bucle con el break en vez de salir porque nBytes sea igual a FileSize. Lo que pienso es que se pueden estar perdiendo bytes por el camino pero no tengo ni idea ya que uso TransmitFile y no se como funciona esta por dentro. Adjunto el proyecto por si quereis mirarlo a ver que puede estar pasando.

[[escafandra]]

Tienes un eror de concepto. Cuando esperas recibir el archivo y se dispara el evento SocketRead, en tu código, primero lees cosas (estructura del archivo, MD5...) con lo que estás perdiendo datos, pues en ese momento ya estás recibiendo los primeros bloques del archivo. Fíjate en este cambio que realizo en tu código y verás que ya funciona. Seguramente este error lo tenías en otras formas de leer tu archivo:

Código PHP:

void __fastcall TChatForm::SocketRead(TCustomWinSocket *Socket)
{
  if(recvFile == true && recvStructFile == true)
  {
           //Aqui recibimos el archivo
           int recibidos = ReceiveFile(Socket->SocketHandle, NewPath.c_str(), archivo.size);

           RichEdit1->SelStart = RichEdit1->Text.Length();
           RichEdit1->SelLength = 0;
           RichEdit1->SelAttributes->Color = clPurple;
           RichEdit1->Lines->Add("Finalizó la recepcion del archivo.");

           recvFile = false;
           recvStructFile = false;
           archivo.end = true;
           if(recibidos != archivo.size)
           {
                RichEdit1->SelStart = RichEdit1->Text.Length();
                RichEdit1->SelLength = 0;
                RichEdit1->SelAttributes->Color = clPurple;
                RichEdit1->Lines->Add("El archivo está corrupto. El tamaño del archivo enviado y del recibido son diferentes.");
           }else{
                RichEdit1->SelStart = RichEdit1->Text.Length();
                RichEdit1->SelLength = 0;
                RichEdit1->SelAttributes->Color = clPurple;
                RichEdit1->Lines->Add("Archivo recibido correctamente.");
           }
           Edit1->Enabled = true;
           ButtonSendFile->Enabled = true;
           TrackBarMiliseconds->Enabled = true;
           CheckBoxListen->Enabled = true;
           ButtonExit->Enabled = true;
           ButtonDisconnect->Enabled = true;

           //Calculo el MD5 del archivo recibido y lo comparo con el del archivo enviado
           char md5[33];

           memset(md5, 0, sizeof(md5));
           strcpy(md5, ObtenerMD5(NewPath.c_str()).c_str());
           
           if(strncmp(md5, archivo.MD5, 32) == 0)
           {
                RichEdit1->SelStart = RichEdit1->Text.Length();
                RichEdit1->SelLength = 0;
                RichEdit1->SelAttributes->Color = clPurple;
                RichEdit1->Lines->Add(AnsiString().sprintf("Los MD5 coinciden. MD5: %s", md5));
           }else{
                RichEdit1->SelStart = RichEdit1->Text.Length();
                RichEdit1->SelLength = 0;
                RichEdit1->SelAttributes->Color = clRed;
                RichEdit1->Lines->Add(AnsiString().sprintf("Los MD5 no coinciden. MD5 del enviado: %s | MD5 del recibido: %s", archivo.MD5, md5));
           }

           SetForegroundWindow(ChatForm->Handle);
  }


  // Cuando el servidor envia datos al ciente y este los ha de procesar
  char flagFile[SIZEFLAG] = {"\n\n_File_\n\n\0"};
  unsigned char *buffer;
  int size,lenBuff;
  lenBuff = Socket->ReceiveLength();
  buffer = new unsigned char[lenBuff];
  memset(buffer,0,sizeof(buffer));

  size = Socket->ReceiveBuf(buffer,lenBuff);
  if(strcmp(buffer, flagFile) == 0)
  {
        recvFile = true;
        RichEdit1->SelStart = RichEdit1->Text.Length();
        RichEdit1->SelLength = 0;
        RichEdit1->SelAttributes->Color = clPurple;
        RichEdit1->Lines->Add("Recibiendo archivo. Espera a que termine y no cierres la aplicación.");
        Edit1->Enabled = false;
        ButtonSendFile->Enabled = false;
        TrackBarMiliseconds->Enabled = false;
        CheckBoxListen->Enabled = false;
        ButtonExit->Enabled = false;
        ButtonDisconnect->Enabled = false;
  }
  else if(recvFile == true && size == sizeof(archivo) )
  {
        memcpy(archivo.name, buffer, sizeof(archivo.name));
        memcpy(&archivo.size, buffer + sizeof(archivo.name), sizeof(archivo.size));
        memcpy(&archivo.blocks, buffer + sizeof(archivo.name) + sizeof(archivo.size), sizeof(archivo.blocks));
        memcpy(&archivo.end, buffer + sizeof(archivo.name) + sizeof(archivo.size) + sizeof(archivo.blocks), sizeof(archivo.end));
        memcpy(&archivo.MD5, buffer + sizeof(archivo.name) + sizeof(archivo.size) + sizeof(archivo.blocks) + sizeof(archivo.end), sizeof(archivo.MD5));

        if(archivo.end == false)
        {
           NewPath = ExtractFilePath(Application->ExeName) +"_"+ archivo.name;

           if(FileExists(NewPath))
                DeleteFile(NewPath);
           recvStructFile = true;
        }
  } else{
     //Si no es una imagen mostramos el mensaje enviado
     RichEdit1->SelStart = RichEdit1->Text.Length();
     RichEdit1->SelLength = 0;
     RichEdit1->SelAttributes->Color = clGreen;
     RichEdit1->Lines->Add(Socket->RemoteHost + ": " + AnsiString((char*)buffer).SubString(1,size) );  // Añadir los datos al memo de recepción
  }
  delete [] buffer;
} 


Saludos.