Simplify goobspatch: the in and out members of xzfile don't need to be malloced separately

chrome/installer/mac/third_party/bsdiff/goobspatch.c

 /*-
  * Copyright 2003-2005 Colin Percival
  * All rights reserved
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted providing that the following conditions 
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 51 matching lines @@
         int i;
         for (i = 0; i < SHA_DIGEST_LENGTH; ++i)
                 sprintf(&sha1str[i * 2], "%02x", sha1[i]);
 }
 
 /* xzfile is a provisional stdio-like interface to xz/lzma2-compressed data.
  * liblzma does not currently include this functionality. The interface is
  * read-only and only supports sequential access. */
 
 typedef struct {
+        /* in and out are the underlying buffers to be used with lzma_stream. */
+        u_char in[BUFSIZ];
+        u_char out[BUFSIZ];
+
         lzma_stream ls;
         FILE *f;
 
-        /* in and out are the underlying buffers to be used with lzma_stream. */
-        u_char *in;
-        u_char *out;
-
         /* read_out points to the first byte in out not yet consumed by an
          * xzread call. read_out_len tracks the amount of data available in
          * out beginning at read_out. */
         u_char *read_out;
         size_t read_out_len;
 
         /* Error and end-of-file indicators. */
         lzma_ret err;
         int eof;
 } xzfile;
 
 /* Initializes and returns a new xzfile pointer that will read from f. On
  * failure, returns NULL. If err is non-NULL, it will be set to indicate any
  * error that may have occurred. */
 static xzfile *xzdopen(FILE *f, lzma_ret *err)
 {
         xzfile *xzf;
         lzma_stream ls = LZMA_STREAM_INIT;
         uint64_t physmem, memlimit;
 
         if (!(xzf = malloc(sizeof(xzfile)))) {
                 if (err) *err = LZMA_MEM_ERROR;
                 return NULL;
         }
 
         xzf->ls = ls;
         xzf->f = f;
 
-        xzf->in = NULL;
-        xzf->out = NULL;
-        if (!(xzf->in = malloc(BUFSIZ)) || !(xzf->out = malloc(BUFSIZ))) {
-                if (err) *err = LZMA_MEM_ERROR;
-                free(xzf->out);
-                free(xzf->in);
-                free(xzf);
-                return NULL;
-        }
-
         xzf->read_out = xzf->out;
         xzf->read_out_len = 0;
 
         xzf->err = LZMA_OK;
         xzf->eof = 0;
 
         /* Use the same memory limits used by xzdec and xz. Use 40% of
          * physical memory if 80MB or more, otherwise use 80% of physical
          * memory if 80MB or less, otherwise use 80MB. If physical memory
          * can't be determined, use 128MB. These limits should be sufficient
          * for any decompression on any general-purpose system. */
         physmem = lzma_physmem();
         if (physmem == 0)
                 physmem = 128 * 1024 * 1024;
         memlimit = 40 * physmem / 100;
         if (memlimit < 80 * 1024 * 1024) {
                 memlimit = 80 * physmem / 100;
                 if (memlimit > 80 * 1024 * 1024)
                         memlimit = 80 * 1024 * 1024;
         }
 
         xzf->err = lzma_stream_decoder(&xzf->ls, memlimit,
                                        LZMA_TELL_NO_CHECK |
                                            LZMA_TELL_UNSUPPORTED_CHECK);
         if (xzf->err != LZMA_OK) {
                 if (err) *err = xzf->err;
-                free(xzf->out);
-                free(xzf->in);
                 free(xzf);
                 return NULL;
         }
 
         if (err) *err = xzf->err;
         return xzf;
 }
 
 /* Closes an xzfile opened by xzopen, freeing all memory and closing all
  * files. Returns LZMA_OK normally, or LZMA_STREAM_END if fclose fails. */
 static lzma_ret xzclose(xzfile *xzf)
 {
         lzma_ret lzma_err = LZMA_OK;
 
         lzma_end(&xzf->ls);
         if (fclose(xzf->f) != 0)
                 lzma_err = LZMA_STREAM_END;
-        free(xzf->out);
-        free(xzf->in);
         free(xzf);
 
         return lzma_err;
 }
 
 /* Reads len uncompressed bytes from xzf into buf. Returns the number of bytes
  * read, which may be less than len at the end of the file. Upon error, if
  * err is non-NULL, it will be set to an appropriate value, which will either
  * be a return value from lzma_code (with the exception of LZMA_STREAM_END,
  * which is remapped to LZMA_OK), or LZMA_STREAM_END to indicate an I/O error.
@@ skipping 352 matching lines @@
         /* Write the new file */
         if(((fd=open(argv[2],O_CREAT|O_TRUNC|O_WRONLY,0644))<0) ||
                 (write(fd,new,newsize)!=newsize) || (close(fd)==-1))
                 err(1,"open/write/close(%s)",argv[2]);
 
         free(new);
         free(old);
 
         return 0;
 }