¿procesos que charlan entre ellos usando tuberias con nombre?

[aguml]

Bueno, despues de mucho trabajo lo hice funcionar y va genial aunque seguramente tendrá fallos que no haya visto.
Ahora estoy liado con el envio y recepcion de archivos y para eso hago esto:

Para recibir:

Código PHP:

//---------------------------------------------------------------------------
// 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
  AnsiString MensajeRecibido;
  char aux[10];
  char buffer[1024];
  int retval;

  MensajeRecibido = Socket->ReceiveText();
  memcpy(aux,MensajeRecibido.c_str(),10);

  if(strncmp(aux, flagFile,10) == 0)
  {
     do{
        memset(buffer,0,sizeof(buffer));
        //Aqui gestiono para recibir el archivo
        retval = Socket->ReceiveBuf(buffer,SIZEBLOCK);
     }while(retval != -1);

  }else{
     //Si no es una imagen mostramos el mensaje enviado
     RichEdit1->SelStart = RichEdit1->Text.Length();
     RichEdit1->SelLength = 0;
     RichEdit1->SelAttributes->Color = clGreen;
     MensajeRecibido = EditServer->Text + ": " + MensajeRecibido;
     RichEdit1->Lines->Add(MensajeRecibido);  // Añadir los datos al memo de recepción
  }
}

//---------------------------------------------------------------------------
// Se produce cuando el socket de servidor debe leer la información de un socket cliente.
//---------------------------------------------------------------------------
void __fastcall TChatForm::ServerSocketClientRead(TObject *Sender,
      TCustomWinSocket *Socket)
{
  AnsiString MensajeRecibido;
  char aux[10];
  char buffer[1024];
  int retval;

  MensajeRecibido = Socket->ReceiveText();
  memcpy(aux,MensajeRecibido.c_str(),10);

  if(strncmp(aux, flagFile,10) == 0)
  {
     do{
        memset(buffer,0,sizeof(buffer));
        //Aqui gestiono para recibir el archivo
        retval = Socket->ReceiveBuf(buffer,SIZEBLOCK);
     }while(retval != -1);

  }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 + ": " + MensajeRecibido);  // Añadir los datos al memo de recepción
  }
} 


Para enviar:

Código PHP:

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)
                {
                   if(IsServer){
                      retval = ServerSocket->Socket->Connections[0]->SendBuf(flagFile, sizeFlag);
                   }else{
                      retval = ClientSocket->Socket->SendBuf(flagFile, sizeFlag);
                   }

                   if(retval == sizeFlag)
                   {
                           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.");
                   }
                }
        }
} 


El que manda el archivo da los errores "Error en el envio del fichero" y "Error en el envio del fichero. El tamaño del fichero original no coincide con el tamaño del fichero enviado." mientras que el que recibe, que lo que hace simplemente es una prueba recuperando toda la pila sin guardar nada, cuando termina da una excepcion. ¿que se me escapa para poder enviar un archivo? Adjunto el proyecto a ver si podeis mirarlo y me echan un cable.

[[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.