从套接字读取时出现意外行为

Question

I've wrote the following function that reads http response from the server through the socket. I had no problems reading text pages like this page but when I try to read images:

the reading goes on without adding data to the buffer, even though the read returns the correct byte amount.

The function:

unsigned char *read_unknown_size(int fd) {
    int available_buf_size = 1000, tot_read = 0, curr_read_size;
    unsigned char *buf = calloc(available_buf_size, 1), *tmp_ptr;
    if (buf) {
        while ((curr_read_size = (int) read(fd, buf + tot_read, available_buf_size - tot_read)) != 0) {
            if (curr_read_size == -1) {
                perror("failed to read\n");
                //todo free mem
                exit(EXIT_FAILURE);
            } else {
                tot_read += curr_read_size;
                if (tot_read >= available_buf_size) { //the buffer is full
                    available_buf_size *= 2;
                    tmp_ptr = realloc(buf, available_buf_size + tot_read);
                    if (tmp_ptr) {
                        buf = tmp_ptr;
                        memset(buf+tot_read, 0, available_buf_size - tot_read);
                    }
                    else {
                        fprintf(stderr,"realloc failed\n");
                        exit(EXIT_FAILURE);
                    }
                }
            }
        }
    } else {
        fprintf(stderr,"calloc failed\n");
        exit(EXIT_FAILURE);
    }
    return buf;
}

The buffer after one reading of size 1000:

0x563a819da130 "HTTP/1.1 200 OK\r\nDate: Tue, 23 Nov 2021 19:32:01 GMT\r\nServer: Apache\r\nUpgrade: h2,h2c\r\nConnection: Upgrade, close\r\nLast-Modified: Sat, 11 Jan 2014 01:32:55 GMT\r\nAccept-Ranges: bytes\r\nContent-Length: 3900\r\nCache-Control: max-age=2592000\r\nExpires: Thu, 23 Dec 2021 19:32:01 GMT\r\nContent-Type: image/jpeg\r\n\r\nGIF89", <incomplete sequence \375>

A total of 379 character.

Edit: After reading the data, I'm writing it to a new file, the text pages works fine but I can't open images.

Answer 1

I believe the program is working, but you are simply printing out the buffer up until the first NUL character by using printf("%s", buf) or similar. Keep in mind the 6th character of GIF file is a NUL.

The problem is that the caller can't do anything useful because it has no way to know how much data is in the returned buffer. So, in order to do anything useful with the result of the function, it needs to return not just the buffer but the number of characters it read.

// Reads until EOF is encountered.
// Returns 0 on success.
// Returns -1 and sets errno on error.
int read_rest(int fd, unsigned char **buf_ptr, size_t *total_read_ptr) {
   unsigned char *buf        = NULL;
   size_t         buf_size   = 0;
   size_t         total_read = 0;

   while (1) {
      if ( total_read == buf_size ) {
         size_t new_size = buf_size * 2;  // Refine this.
         unsigned char *tmp = realloc(buf, new_size);
         if (!tmp)
            goto ERROR;

         buf      = tmp;
         buf_size = new_size;
      }

      ssize_t chunk_size = read(fd, buf + total_read, buf_size - total_read);
      if ( chunk_size < 0 )
         goto ERROR;

      if ( chunk_size == 0 ) {
         unsigned char *tmp = realloc(buf, buf_size);
         if (tmp)
            buf = tmp;

         *buf_ptr        = buf;
         *total_read_ptr = total_read;
         return 0;
      }

      total_read += chunk_size;
   }

ERROR:
   free(buf);
   *buf_ptr        = NULL;
   *total_read_ptr = 0;
   return -1;
}

Sample caller:

unsigned char *buf;
size_t         size;

if ( read_rest(fd, &buf, &size) == -1 ) {
   perror("Can't read from socket");
   exit(EXIT_FAILURE);
}

Now you have enough information to print out the contents of the buffer (eg using write ).

---

Comments on the original code:

• Think very hard before using casts. Using (int)read(...) makes no sense. This is incorrect.
• It's best to include the actual error (as perror does) when an error occurs.
• Printing out error messages is best done outside of the I/O function.