¿procesos que charlan entre ellos usando tuberias con nombre?

[aguml]

Bueno amigos, ahora estoy liado con el tema de sockets y lo veo muy complejo aunque he encontrado un escrito que me ha ayudado mucho pero no lo tengo todo lo claro que deberia para seguir.
Ya he conseguido enviar y recibir mensajes de forma sincronica pero tengo un problema, el codigo de enviar y recibir lo hago a traves de un solo boton con lo que si envio no recibo hasta que vuelvo a enviar y algun que otro problema que se me presenta por este tema.
Supongo que habrá que gestionarlo con mensajes en vez de con los eventos de un boton para poder separar el envio y la recepcion pero hasta ahi he llegado. ¿alquien puede ayudarme con esto?
Este es el escrito que he encontrado y en el que me he apoyado para hacer lo que tengo hasta ahora: Pinchar aquí

Adjunto lo que tengo para que podais ojearlo a ver si podeis ayudarme.
Me gustaria hacerlo de forma sincronica y, cuando ya lo tenga, a ver si podeis ayudarme tambien con el modo asincronico que con lo que explica el escrito no lo tengo nada claro
Gracias por adelantado.

[aguml]

me acabo de enterar que el builder tiene componentes para eso y he encontrado dos sitios interesantes que tengo que examinar bien: sitio 1 y sitio 2

[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