Estoy trabajando en una tarea de programación de sockets en la que tengo que enviar un archivo entre sparc y la máquina Linux. Antes de enviar el archivo en char stream, debo obtener el tamaño del archivo e informar al cliente. Estas son algunas de las formas en que traté de obtener el tamaño, pero no estoy seguro de cuál es la adecuada.
Para fines de prueba, creé un archivo con contenido "prueba" (espacio + (cadena) prueba)
Método 1: usar fseeko() y ftello()
Este es un método que encontré en https://www.securecoding.cert.org/confluence/display/c/FIO19-C.+Do+not+use+fseek()+and+ftell()+to+compute+ el+tamaño+de+un+archivo+regular Mientras que fssek() tiene el problema de "Establecer el indicador de posición del archivo al final del archivo, como con fseek(archivo, 0, SEEK_END), tiene un comportamiento indefinido para un archivo binario stream", se dice que fseeko() abordó este problema, pero solo funciona en el sistema POSIX (lo cual está bien porque el entorno que estoy usando es Sparc y Linux)
fd = open(file_path, O_RDONLY); fp = fopen(file_path, "rb"); /* Ensure that the file is a regular file */ if ((fstat(fd, &st) != 0) || (!S_ISREG(st.st_mode))) { /* Handle error */ } if (fseeko(fp, 0 , SEEK_END) != 0) { /* Handle error */ } file_size = ftello(fp); fseeko(fp, 0, SEEK_SET); printf("file size %zu\n", file_size);Este método funciona bien y obtiene el tamaño correcto. Sin embargo, está limitado solo a archivos normales. Traté de buscar en Google el término "archivo normal", pero todavía no lo entiendo completamente. Y no sé si esta función es confiable para mi proyecto.
Método 2 - Usando strlen()
Desde el máx. El tamaño de un archivo en mi proyecto es de 4 MB, por lo que solo puedo llamar a un búfer de 4 MB. Después de eso, el archivo se lee en el búfer y traté de usar strlen para obtener el tamaño del archivo (o más correctamente, la longitud del contenido). Dado que strlen() es portátil, ¿puedo usar este método en su lugar? El fragmento de código es así
fp = fopen(file_path, "rb"); fread(file_buffer, 1024*1024*4, 1, fp); printf("strlen %zu\n", strlen(file_buffer));Este método también funciona y devuelve
strlen 8Sin embargo, no pude ver ningún enfoque similar en Internet usando este método. Así que estoy pensando que tal vez me he perdido algo o que hay algunas limitaciones de este enfoque de las que no me he dado cuenta.
Un archivo normal significa que no es nada especial como un dispositivo, un zócalo, una tubería, etc., sino un archivo "normal". Parece que según la descripción de su tarea antes de enviar, debe recuperar el tamaño del archivo normal. Así que tu camino es correcto:
FILE* fp = fopen(...); if(fp) { fseek(fp, 0 , SEEK_END); long fileSize = ftell(fp); fseek(fp, 0 , SEEK_SET);// needed for next read from beginning of file ... fclose(fp); }pero puedes hacerlo sin abrir el archivo:
#include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> struct stat buffer; int status; status = stat("path to file", &buffer); if(status == 0) { // size of file is in member buffer.st_size; }OP puede hacerlo de la manera más fácil como "el tamaño máximo de un archivo en mi proyecto es de 4 MB".
En lugar de usar strlen() , use el valor de retorno de fread() . stlen() se detiene en el primer carácter nulo, por lo que puede informar un valor demasiado pequeño. @Sami Kuhmonen Tampoco sabemos que la lectura de datos contenga ningún carácter nulo, por lo que puede que no sea una cadena. Agregue un carácter nulo (y asigne +1) si el código necesita usar datos como una cadena. Pero en ese caso, esperaría que el archivo se abriera en modo texto.
Tenga en cuenta que muchos sistemas operativos ni siquiera usan la memoria asignada hasta que se escribe.
¿Por qué malloc no "agota" la memoria de mi computadora?
fp = fopen(file_path, "rb"); if (fp) { #define MAX_FILE_SIZE 4194304 char *buf = malloc(MAX_FILE_SIZE); if (buf) { size_t numread = fread(buf, sizeof *buf, MAX_FILE_SIZE, fp); // shrink if desired char *tmp = realloc(buf, numread); if (tmp) { buf = tmp; // Use buf with numread char } free(buf); } fclose(fp); }Nota: Leer todo el archivo en la memoria puede no ser la mejor idea para empezar.