leer cualquier archivo en c...

[netoec84]

que tal... revise el faq y encontre algo de leer archivos, pero mi pregunta es de que manera leo un archivo de tal forma que no importe si es de texto o un archivo ejecutable, o una imagen, ya que deseo enviar esta informacion por un socket y creo que tiene que ver la manera como lo lea....

saludos

[Eternal Idol]

Como binario, nunca como texto.

[netoec84]

basta con que haga una lectura en el servidor en modo binario y una escritura en el cliente en modo binario? por que lei algo de lectura por estructuras... donde puedo encontrar informacion ?

[MaxExtreme]

Iniciado por netoec84

basta con que haga una lectura en el servidor en modo binario y una escritura en el cliente en modo binario? por que lei algo de lectura por estructuras... donde puedo encontrar informacion ?

No. _SIEMPRE_ usa el modo binario. El modo texto se incluye para poder leer _textos_ en cualquier sistema operativo (cada uno tiene su forma de marcar los saltos de línea y demás).

Lo de leer estructuras es para leer eso, datos contiguos rellenando los campos de una estructura "seguidos". Pero eso no te sirve.

Y te repito que todo archivo es lo mismo, no hay diferencia ni importan las extensiones. Todo se lee igual, pero se incluyó el modo texto para ese fin, pero SOLO para ese.

[netoec84]

Entiendo, pero ahora tengo otra duda, si lee un buffer del tipo char[] para pasar los datos y el archivo que se pasa es una imagen o un zip o un ejecutable y he visto que estos archivos contienen caracteres "raros" que sucede si uno de ellos es el caracter "fin de cadena" y este esta en una posicion media del arreglo (buffer char[]). Esto no produciria que la informacion llegue alterada?

Para que quede mas claro les pongo el codigo que tengo... funciona para cualquier archivo? he usado para texto, imagen .jpg y un zip. Aparentemente funciona, pero tengo la duda que expuse arriba.

SERVIDOR

Código:

#include <stdio.h>
#include <sys/types.h> 
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/fcntl.h>

void dostuff(int); 

void error(char *msg)
{
    perror(msg);
    exit(1);
}

int main(int argc, char *argv[])
{
     int sockfd, newsockfd, portno, clilen, pid;
     struct sockaddr_in serv_addr, cli_addr;

     if (argc < 2) {
         fprintf(stderr,"ERROR, no se ha ingresado el puerto\n");
         exit(1);
     }
     sockfd = socket(AF_INET, SOCK_STREAM, 0);

     if (sockfd < 0) 
        error("ERROR opening socket");

     bzero((char *) &serv_addr, sizeof(serv_addr));
     portno = atoi(argv[1]);
     serv_addr.sin_family = AF_INET;
     serv_addr.sin_addr.s_addr = INADDR_ANY;
     serv_addr.sin_port = htons(portno);

     if (bind(sockfd, (struct sockaddr *) &serv_addr,
              sizeof(serv_addr)) < 0) 
              error("ERROR en binding");

     listen(sockfd,5);

     clilen = sizeof(cli_addr);

     while (1) {
         newsockfd = accept(sockfd, 
               (struct sockaddr *) &cli_addr, &clilen);
         if (newsockfd < 0) 
             error("ERROR en accept");
         pid = fork();
         if (pid < 0)
             error("ERROR en fork");
         if (pid == 0)  {
             close(sockfd);
             dostuff(newsockfd);
             exit(0);
         }
         else close(newsockfd);
     } 
     return 0; 
}

void dostuff (int sock)
{
   int n;
   char buffer[256];
   char ruta[256];
   
   //Descriptores de archivos 
   int d_open, d_readbytes;

   //Buffer
   char buf[1024];   
   
   // Envia por socket el mensaje de ingreso de archivo
   n = write(sock,"Ingrese el archivo a copiar",28);
   if (n < 0) error("ERROR escribiendo en el socket");   

   // Lee la ruta del archivo...         
   bzero(ruta,256);
   n = read(sock,ruta,255);
   if (n < 0) error("ERROR leyendo del socket");
   
   // Abrir el fichero de entrada en lectura y binario
   printf("Se solicito el archivo: %s", ruta);
   d_open = open(ruta, O_RDONLY);
   
   while(1)
   {
	//Se lee el contenido del archivo
	d_readbytes = read(d_open, buf, 1024);
	if(d_readbytes <= 0)
		break;
	//Se escribe en el socket la información leída
	write(sock, buf, d_readbytes);
	//printf("%s", buf);
   }   
   n = write(sock,"",0);
   

   close(sock);

}

CLIENTE

Código:

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h> 
#include <sys/fcntl.h>

void error(char *msg)
{
    perror(msg);
    exit(0);
}

int main(int argc, char *argv[])
{
    int sockfd, portno, n;
    struct sockaddr_in serv_addr;
    struct hostent *server;
    char buffer[256];
    char ruta[256];
    char aux[] = {"cpy_"};
    

   //Buffer
   char buf[1024];  
   int fd;
    
    if (argc < 3) {
       fprintf(stderr,"uso %s host puerto\n", argv[0]);
       exit(0);
    }

    portno = atoi(argv[2]);
    sockfd = socket(AF_INET, SOCK_STREAM, 0);

    if (sockfd < 0) 
        error("ERROR opening socket");

    server = gethostbyname(argv[1]);

    if (server == NULL) {
        fprintf(stderr,"ERROR, no existe el host\n");
        exit(0);
    }
    bzero((char *) &serv_addr, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    bcopy((char *)server->h_addr, 
         (char *)&serv_addr.sin_addr.s_addr,
         server->h_length);
    serv_addr.sin_port = htons(portno);

    if (connect(sockfd,&serv_addr,sizeof(serv_addr)) < 0) 
        error("ERROR conectando");

    //lee el mensaje del servidor
    bzero(buffer,256);
    n = read(sockfd,buffer,255);
    if (n < 0) error("ERROR leyendo del socket");
    printf("%s\n",buffer);	
	
    //Envia el nombre del archivo que se quiere descargar
    bzero(buffer,256);
    fgets(buffer,255,stdin);
    strcpy(ruta, buffer);
    strcat(aux, ruta);
    strcpy(ruta, aux);
    n = write(sockfd,buffer,strlen(buffer)-1);
    if (n < 0) error("ERROR escribiendo en el socket");

    if ((fd=creat(ruta,0644))==-1)
	printf("\nno puede crear\n");
    
    //lee el mensaje del servidor
    while(1)
    {
    	bzero(buf,1024);
    	n = read(sockfd,buf,1023);
    	if (n<=0)
		break;
		
	if (write (fd,buf,n) !=n)
		printf("\nerror al escribir\n");
    }
        

    close(fd);
    return 0;
}

Saludos

[Instru]

Mira, si vas a leer un archivo binario, usa el tipo de dato unsigned char que en la mayoria de los OS es el equivalente BYTE, si no, entonces por ahi entre las librerias esta la definicin de BYTE.

Si usas el modo binario, que inporta el "fin de cadena" no pasa nada, en cambio, si usas el modo tecto, entonces si afecta, esa es la diferencia.

Saludos

[MaxExtreme]

Esos archivos no contienen caracteres "raros". Te repito que son todos iguales. Son bytes como ha dicho Instru. Lo que pasa es qe uno de texto contiene los valores que corresponde en ASCII aparte de otros como el salto de línea.

Un byte se puede definir como "unsigned char".

Y lo del "fin de cadena" no se si te refieres a '\0', pero te repito que eso no cambia nada.

[Eternal Idol]

En sintesis TODOS los archivos son una coleccion de bytes (que es la minima unidad de informacion en el disco) y no tiene la mas minima importancia su contenido para enviarlos si lo unico que haces el leerlos y transmitirlos tal cual estan en disco.

[Instru]

Asi es...
Si vas a pasarlos por un socket, no tienes de que preocuparte...

saludos

[netoec84]

ok... resumiendo (si no he entendido mal) debo abrir en el servidor en modo binario el archivo pasarlo por el buffer del socket, que es del tipo unsigned char[] y en el cliente escribirlo tambien en modo binario....

[MaxExtreme]

Sí, pero siempre es así.

Lo de los sockets es irrelevante...