zip.c

Bug Summary

File:	s/cmd/signtool/zip.c
Warning:	line 67, column 9 Null pointer passed to 1st parameter expecting 'nonnull'

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name zip.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/nss/cmd/signtool -ffunction-sections -fdata-sections -fcoverage-compilation-dir=/nss/cmd/signtool -resource-dir /usr/lib/llvm-22/lib/clang/22 -D HAVE_STRERROR -D LINUX -D linux -D XP_UNIX -D XP_UNIX -D DEBUG -U NDEBUG -D _DEFAULT_SOURCE -D _BSD_SOURCE -D _POSIX_SOURCE -D SDB_MEASURE_USE_TEMP_DIR -D _REENTRANT -D DEBUG -U NDEBUG -D _DEFAULT_SOURCE -D _BSD_SOURCE -D _POSIX_SOURCE -D SDB_MEASURE_USE_TEMP_DIR -D _REENTRANT -D NSS_DISABLE_SSE3 -D NSS_NO_INIT_SUPPORT -D USE_UTIL_DIRECTLY -D NO_NSPR_10_SUPPORT -D SSL_DISABLE_DEPRECATED_CIPHER_SUITE_NAMES -I ../../../dist/Linux6.1_x86_64_gcc_glibc_PTH_64_DBG.OBJ/include -I ../../../dist/public/nss -I ../../../dist/private/nss -I ../../../dist/public/seccmd -internal-isystem /usr/lib/llvm-22/lib/clang/22/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/15/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -std=c99 -ferror-limit 19 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2025-11-18-221358-3012168-1 -x c zip.c

1/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

5#include "signtool.h"
6#include "zip.h"
7#include "zlib.h"
8#include "prmem.h"

10static void inttox(int in, char *out);
11static void longtox(long in, char *out);

13/****************************************************************
*
* J z i p O p e n
*
* Opens a new ZIP file and creates a new ZIPfile structure to
* control the process of installing files into a zip.
*/
20ZIPfile *
21JzipOpen(char *filename, char *comment)
22{
  ZIPfile *zipfile;
  PRExplodedTime prtime;

  zipfile = PORT_ZAllocPORT_ZAlloc_Util(sizeof(ZIPfile));
  if (!zipfile)
1
Assuming 'zipfile' is non-null→
2
←
Taking false branch→
      out_of_memory();

  /* Construct time and date */
  PR_ExplodeTime(PR_Now(), PR_LocalTimeParameters, &prtime);
  zipfile->date = ((prtime.tm_year - 1980) << 9) |
                  ((prtime.tm_month + 1) << 5) |
                  prtime.tm_mday;
  zipfile->time = (prtime.tm_hour << 11) |
                  (prtime.tm_min << 5) |
                  (prtime.tm_sec & 0x3f);

  zipfile->fp = NULL((void*)0);
  if (filename &&
3
←
Assuming 'filename' is non-null→
5
←
Taking false branch→
      (zipfile->fp = PR_Open(filename,
4
←
Assuming the condition is false→
                             PR_WRONLY0x02 |
                                 PR_CREATE_FILE0x08 |
                                 PR_TRUNCATE0x20,
                             0777)) == NULL((void*)0)) {
      char *nsprErr;
      if (PR_GetErrorTextLength()) {
          nsprErr = PR_Malloc(PR_GetErrorTextLength() + 1);
          PR_GetErrorText(nsprErr);
      } else {
          nsprErr = NULL((void*)0);
      }
      PR_fprintf(errorFD, "%s: can't open output jar, %s.%s\n",
                 PROGRAM_NAME"signtool",
                 filename, nsprErr ? nsprErr : "");
      if (nsprErr)
          PR_Free(nsprErr);
      errorCount++;
      exit(ERRX(-1));
  }

  zipfile->list = NULL((void*)0);
  if (filename5.1
'filename' is non-null
) {
6
←
Taking true branch→
      zipfile->filename = PORT_ZAllocPORT_ZAlloc_Util(strlen(filename) + 1);
7
←
Value assigned to field 'filename'→
      if (!zipfile->filename)
8
←
Assuming field 'filename' is null→
9
←
Taking true branch→
          out_of_memory();
      PORT_Strcpystrcpy(zipfile->filename, filename);
10
←
Null pointer passed to 1st parameter expecting 'nonnull'
  }
  if (comment) {
      zipfile->comment = PORT_ZAllocPORT_ZAlloc_Util(strlen(comment) + 1);
      if (!zipfile->comment)
          out_of_memory();
      PORT_Strcpystrcpy(zipfile->comment, comment);
  }

  return zipfile;
77}

79static void *
80my_alloc_func(void *opaque, uInt items, uInt size)
81{
  return PORT_AllocPORT_Alloc_Util(items * size);
83}

85static void
86my_free_func(void *opaque, void *address)
87{
  PORT_FreePORT_Free_Util(address);
89}

91static void
92handle_zerror(int err, char *msg)
93{
  if (!msg) {
      msg = "";
  }

  errorCount++; /* unless Z_OK...see below */

  switch (err) {
      case Z_OK0:
          PR_fprintf(errorFD, "No error: %s\n", msg);
          errorCount--; /* this was incremented above */
          break;
      case Z_MEM_ERROR(-4):
          PR_fprintf(errorFD, "Deflation ran out of memory: %s\n", msg);
          break;
      case Z_STREAM_ERROR(-2):
          PR_fprintf(errorFD, "Invalid compression level: %s\n", msg);
          break;
      case Z_VERSION_ERROR(-6):
          PR_fprintf(errorFD, "Incompatible compression library version: %s\n",
                     msg);
          break;
      case Z_DATA_ERROR(-3):
          PR_fprintf(errorFD, "Compression data error: %s\n", msg);
          break;
      default:
          PR_fprintf(errorFD, "Unknown error in compression library: %s\n", msg);
          break;
  }
122}

124/****************************************************************
*
* J z i p A d d
*
* Adds a new file into a ZIP file.  The ZIP file must have already
* been opened with JzipOpen.
*/
131int
132JzipAdd(char *fullname, char *filename, ZIPfile *zipfile, int lvl)
133{
  ZIPentry *entry;
  PRFileDesc *readfp;
  PRFileDesc *zipfp;
  unsigned long crc;
  unsigned long local_size_pos;
  int num;
  int err;
  int deflate_percent;
  z_stream zstream;
  Bytef inbuf[BUFSIZ8192];
  Bytef outbuf[BUFSIZ8192];

  if (!fullname || !filename || !zipfile) {
      return -1;
  }

  zipfp = zipfile->fp;
  if (!zipfp)
      return -1;

  if ((readfp = PR_Open(fullname, PR_RDONLY0x01, 0777)) == NULL((void*)0)) {
      char *nsprErr;
      if (PR_GetErrorTextLength()) {
          nsprErr = PR_Malloc(PR_GetErrorTextLength() + 1);
          PR_GetErrorText(nsprErr);
      } else {
          nsprErr = NULL((void*)0);
      }
      PR_fprintf(errorFD, "%s: %s\n", fullname, nsprErr ? nsprErr : "");
      errorCount++;
      if (nsprErr)
          PR_Free(nsprErr);
      exit(ERRX(-1));
  }

  /*
   * Make sure the input file is not the output file.
   * Add a few bytes to the end of the JAR file and see if the input file
   * twitches
   */
  {
      PRInt32 endOfJar;
      PRInt32 inputSize;
      PRBool isSame;

      inputSize = PR_Available(readfp);

      endOfJar = PR_Seek(zipfp, 0L, PR_SEEK_CUR);

      if (PR_Write(zipfp, "abcde", 5) < 5) {
          char *nsprErr;

          if (PR_GetErrorTextLength()) {
              nsprErr = PR_Malloc(PR_GetErrorTextLength() + 1);
              PR_GetErrorText(nsprErr);
          } else {
              nsprErr = NULL((void*)0);
          }
          PR_fprintf(errorFD, "Writing to zip file: %s\n",
                     nsprErr ? nsprErr : "");
          if (nsprErr)
              PR_Free(nsprErr);
          errorCount++;
          exit(ERRX(-1));
      }

      isSame = (PR_Available(readfp) != inputSize);

      PR_Seek(zipfp, endOfJar, PR_SEEK_SET);

      if (isSame) {
          /* It's the same file! Forget it! */
          PR_Close(readfp);
          return 0;
      }
  }

  if (verbosity >= 0) {
      PR_fprintf(outputFD, "adding %s to %s...", fullname, zipfile->filename);
  }

  entry = PORT_ZAllocPORT_ZAlloc_Util(sizeof(ZIPentry));
  if (!entry)
      out_of_memory();

  entry->filename = PORT_StrdupPORT_Strdup_Util(filename);
  entry->comment = NULL((void*)0);

  /* Set up local file header */
  longtox(LSIG0x04034B50l, entry->local.signature);
  inttox(strlen(filename), entry->local.filename_len);
  inttox(zipfile->time, entry->local.time);
  inttox(zipfile->date, entry->local.date);
  inttox(Z_DEFLATED8, entry->local.method);

  /* Set up central directory entry */
  longtox(CSIG0x02014B50l, entry->central.signature);
  inttox(strlen(filename), entry->central.filename_len);
  if (entry->comment) {
      inttox(strlen(entry->comment), entry->central.commentfield_len);
  }
  longtox(PR_Seek(zipfile->fp, 0, PR_SEEK_CUR),
          entry->central.localhdr_offset);
  inttox(zipfile->time, entry->central.time);
  inttox(zipfile->date, entry->central.date);
  inttox(Z_DEFLATED8, entry->central.method);

  /* Compute crc.  Too bad we have to process the whole file to do this*/
  crc = crc32(0L, NULL((void*)0), 0);
  while ((num = PR_Read(readfp, inbuf, BUFSIZ8192)) > 0) {
      crc = crc32(crc, inbuf, num);
  }
  PR_Seek(readfp, 0L, PR_SEEK_SET);

  /* Store CRC */
  longtox(crc, entry->local.crc32);
  longtox(crc, entry->central.crc32);

  /* Stick this entry onto the end of the list */
  entry->next = NULL((void*)0);
  if (zipfile->list == NULL((void*)0)) {
      /* First entry */
      zipfile->list = entry;
  } else {
      ZIPentry *pe;

      pe = zipfile->list;
      while (pe->next != NULL((void*)0)) {
          pe = pe->next;
      }
      pe->next = entry;
  }

  /*
   * Start writing stuff out
   */

  local_size_pos = PR_Seek(zipfp, 0, PR_SEEK_CUR) + 18;
  /* File header */
  if (PR_Write(zipfp, &entry->local, sizeof(struct ZipLocal)) <
      sizeof(struct ZipLocal)) {
      char *nsprErr;
      if (PR_GetErrorTextLength()) {
          nsprErr = PR_Malloc(PR_GetErrorTextLength() + 1);
          PR_GetErrorText(nsprErr);
      } else {
          nsprErr = NULL((void*)0);
      }
      PR_fprintf(errorFD, "Writing zip data: %s\n", nsprErr ? nsprErr : "");
      if (nsprErr)
          PR_Free(nsprErr);
      errorCount++;
      exit(ERRX(-1));
  }

  /* File Name */
  if (PR_Write(zipfp, filename, strlen(filename)) < strlen(filename)) {
      char *nsprErr;
      if (PR_GetErrorTextLength()) {
          nsprErr = PR_Malloc(PR_GetErrorTextLength() + 1);
          PR_GetErrorText(nsprErr);
      } else {
          nsprErr = NULL((void*)0);
      }
      PR_fprintf(errorFD, "Writing zip data: %s\n", nsprErr ? nsprErr : "");
      if (nsprErr)
          PR_Free(nsprErr);
      errorCount++;
      exit(ERRX(-1));
  }

  /*
   * File data
   */
  /* Initialize zstream */
  zstream.zalloc = my_alloc_func;
  zstream.zfree = my_free_func;
  zstream.opaque = NULL((void*)0);
  zstream.next_in = inbuf;
  zstream.avail_in = BUFSIZ8192;
  zstream.next_out = outbuf;
  zstream.avail_out = BUFSIZ8192;
  /* Setting the windowBits to -MAX_WBITS is an undocumented feature of
   * zlib (see deflate.c in zlib).  It is the same thing that Java does
   * when you specify the nowrap option for deflation in java.util.zip.
   * It causes zlib to leave out its headers and footers, which don't
   * work in PKZIP files.
   */
  err = deflateInit2(&zstream, lvl, Z_DEFLATED,deflateInit2_((&zstream),(lvl),(8),(-15),(8), (0), "1.3.1"
, (int)sizeof(z_stream))
                     -MAX_WBITS, 8 /*default*/, Z_DEFAULT_STRATEGY)deflateInit2_((&zstream),(lvl),(8),(-15),(8), (0), "1.3.1"
, (int)sizeof(z_stream));
  if (err != Z_OK0) {
      handle_zerror(err, zstream.msg);
      exit(ERRX(-1));
  }

  while ((zstream.avail_in = PR_Read(readfp, inbuf, BUFSIZ8192)) > 0) {
      zstream.next_in = inbuf;
      /* Process this chunk of data */
      while (zstream.avail_in > 0) {
          err = deflate(&zstream, Z_NO_FLUSH0);
          if (err != Z_OK0) {
              handle_zerror(err, zstream.msg);
              exit(ERRX(-1));
          }
          if (zstream.avail_out <= 0) {
              if (PR_Write(zipfp, outbuf, BUFSIZ8192) < BUFSIZ8192) {
                  char *nsprErr;
                  if (PR_GetErrorTextLength()) {
                      nsprErr = PR_Malloc(PR_GetErrorTextLength() + 1);
                      PR_GetErrorText(nsprErr);
                  } else {
                      nsprErr = NULL((void*)0);
                  }
                  PR_fprintf(errorFD, "Writing zip data: %s\n",
                             nsprErr ? nsprErr : "");
                  if (nsprErr)
                      PR_Free(nsprErr);
                  errorCount++;
                  exit(ERRX(-1));
              }
              zstream.next_out = outbuf;
              zstream.avail_out = BUFSIZ8192;
          }
      }
  }

  /* Now flush everything */
  while (1) {
      err = deflate(&zstream, Z_FINISH4);
      if (err == Z_STREAM_END1) {
          break;
      } else if (err == Z_OK0) {
          /* output buffer full, repeat */
      } else {
          handle_zerror(err, zstream.msg);
          exit(ERRX(-1));
      }
      if (PR_Write(zipfp, outbuf, BUFSIZ8192) < BUFSIZ8192) {
          char *nsprErr;
          if (PR_GetErrorTextLength()) {
              nsprErr = PR_Malloc(PR_GetErrorTextLength() + 1);
              PR_GetErrorText(nsprErr);
          } else {
              nsprErr = NULL((void*)0);
          }
          PR_fprintf(errorFD, "Writing zip data: %s\n",
                     nsprErr ? nsprErr : "");
          if (nsprErr)
              PR_Free(nsprErr);
          errorCount++;
          exit(ERRX(-1));
      }
      zstream.avail_out = BUFSIZ8192;
      zstream.next_out = outbuf;
  }

  /* If there's any output left, write it out. */
  if (zstream.next_out != outbuf) {
      if (PR_Write(zipfp, outbuf, zstream.next_out - outbuf) <
          zstream.next_out - outbuf) {
          char *nsprErr;
          if (PR_GetErrorTextLength()) {
              nsprErr = PR_Malloc(PR_GetErrorTextLength() + 1);
              PR_GetErrorText(nsprErr);
          } else {
              nsprErr = NULL((void*)0);
          }
          PR_fprintf(errorFD, "Writing zip data: %s\n",
                     nsprErr ? nsprErr : "");
          if (nsprErr)
              PR_Free(nsprErr);
          errorCount++;
          exit(ERRX(-1));
      }
      zstream.avail_out = BUFSIZ8192;
      zstream.next_out = outbuf;
  }

  /* Now that we know the compressed size, write this to the headers */
  longtox(zstream.total_in, entry->local.orglen);
  longtox(zstream.total_out, entry->local.size);
  if (PR_Seek(zipfp, local_size_pos, PR_SEEK_SET) == -1) {
      char *nsprErr;
      if (PR_GetErrorTextLength()) {
          nsprErr = PR_Malloc(PR_GetErrorTextLength() + 1);
          PR_GetErrorText(nsprErr);
      } else {
          nsprErr = NULL((void*)0);
      }
      PR_fprintf(errorFD, "Accessing zip file: %s\n", nsprErr ? nsprErr : "");
      if (nsprErr)
          PR_Free(nsprErr);
      errorCount++;
      exit(ERRX(-1));
  }
  if (PR_Write(zipfp, entry->local.size, 8) != 8) {
      char *nsprErr;
      if (PR_GetErrorTextLength()) {
          nsprErr = PR_Malloc(PR_GetErrorTextLength() + 1);
          PR_GetErrorText(nsprErr);
      } else {
          nsprErr = NULL((void*)0);
      }
      PR_fprintf(errorFD, "Writing zip data: %s\n", nsprErr ? nsprErr : "");
      if (nsprErr)
          PR_Free(nsprErr);
      errorCount++;
      exit(ERRX(-1));
  }
  if (PR_Seek(zipfp, 0L, PR_SEEK_END) == -1) {
      char *nsprErr;
      if (PR_GetErrorTextLength()) {
          nsprErr = PR_Malloc(PR_GetErrorTextLength() + 1);
          PR_GetErrorText(nsprErr);
      } else {
          nsprErr = NULL((void*)0);
      }
      PR_fprintf(errorFD, "Accessing zip file: %s\n",
                 nsprErr ? nsprErr : "");
      if (nsprErr)
          PR_Free(nsprErr);
      errorCount++;
      exit(ERRX(-1));
  }
  longtox(zstream.total_in, entry->central.orglen);
  longtox(zstream.total_out, entry->central.size);

  /* Close out the deflation operation */
  err = deflateEnd(&zstream);
  if (err != Z_OK0) {
      handle_zerror(err, zstream.msg);
      exit(ERRX(-1));
  }

  PR_Close(readfp);

  if ((zstream.total_in > zstream.total_out) && (zstream.total_in > 0)) {
      deflate_percent = (int)((zstream.total_in -
                               zstream.total_out) *
                              100 / zstream.total_in);
  } else {
      deflate_percent = 0;
  }
  if (verbosity >= 0) {
      PR_fprintf(outputFD, "(deflated %d%%)\n", deflate_percent);
  }

  return 0;
482}

484/********************************************************************
* J z i p C l o s e
*
* Finishes the ZipFile. ALSO DELETES THE ZIPFILE STRUCTURE PASSED IN!!
*/
489int
490JzipClose(ZIPfile *zipfile)
491{
  ZIPentry *pe, *dead;
  PRFileDesc *zipfp;
  struct ZipEnd zipend;
  unsigned int entrycount = 0;

  if (!zipfile) {
      return -1;
  }

  if (!zipfile->filename) {
      /* bogus */
      return 0;
  }

  zipfp = zipfile->fp;
  zipfile->central_start = PR_Seek(zipfp, 0L, PR_SEEK_CUR);

  /* Write out all the central directories */
  pe = zipfile->list;
  while (pe) {
      entrycount++;

      /* Write central directory info */
      if (PR_Write(zipfp, &pe->central, sizeof(struct ZipCentral)) <
          sizeof(struct ZipCentral)) {
          char *nsprErr;
          if (PR_GetErrorTextLength()) {
              nsprErr = PR_Malloc(PR_GetErrorTextLength() + 1);
              PR_GetErrorText(nsprErr);
          } else {
              nsprErr = NULL((void*)0);
          }
          PR_fprintf(errorFD, "Writing zip data: %s\n",
                     nsprErr ? nsprErr : "");
          if (nsprErr)
              PR_Free(nsprErr);
          errorCount++;
          exit(ERRX(-1));
      }

      /* Write filename */
      if (PR_Write(zipfp, pe->filename, strlen(pe->filename)) <
          strlen(pe->filename)) {
          char *nsprErr;
          if (PR_GetErrorTextLength()) {
              nsprErr = PR_Malloc(PR_GetErrorTextLength() + 1);
              PR_GetErrorText(nsprErr);
          } else {
              nsprErr = NULL((void*)0);
          }
          PR_fprintf(errorFD, "Writing zip data: %s\n",
                     nsprErr ? nsprErr : "");
          if (nsprErr)
              PR_Free(nsprErr);
          errorCount++;
          exit(ERRX(-1));
      }

      /* Write file comment */
      if (pe->comment) {
          if (PR_Write(zipfp, pe->comment, strlen(pe->comment)) <
              strlen(pe->comment)) {
              char *nsprErr;
              if (PR_GetErrorTextLength()) {
                  nsprErr = PR_Malloc(PR_GetErrorTextLength() + 1);
                  PR_GetErrorText(nsprErr);
              } else {
                  nsprErr = NULL((void*)0);
              }
              PR_fprintf(errorFD, "Writing zip data: %s\n",
                         nsprErr ? nsprErr : "");
              if (nsprErr)
                  PR_Free(nsprErr);
              errorCount++;
              exit(ERRX(-1));
          }
      }

      /* Delete the structure */
      dead = pe;
      pe = pe->next;
      if (dead->filename) {
          PORT_FreePORT_Free_Util(dead->filename);
      }
      if (dead->comment) {
          PORT_FreePORT_Free_Util(dead->comment);
      }
      PORT_FreePORT_Free_Util(dead);
  }
  zipfile->central_end = PR_Seek(zipfile->fp, 0L, PR_SEEK_CUR);

  /* Create the ZipEnd structure */
  PORT_Memsetmemset(&zipend, 0, sizeof(zipend));
  longtox(ESIG0x06054B50l, zipend.signature);
  inttox(entrycount, zipend.total_entries_disk);
  inttox(entrycount, zipend.total_entries_archive);
  longtox(zipfile->central_end - zipfile->central_start,
          zipend.central_dir_size);
  longtox(zipfile->central_start, zipend.offset_central_dir);
  if (zipfile->comment) {
      inttox(strlen(zipfile->comment), zipend.commentfield_len);
  }

  /* Write out ZipEnd xtructure */
  if (PR_Write(zipfp, &zipend, sizeof(zipend)) < sizeof(zipend)) {
      char *nsprErr;
      if (PR_GetErrorTextLength()) {
          nsprErr = PR_Malloc(PR_GetErrorTextLength() + 1);
          PR_GetErrorText(nsprErr);
      } else {
          nsprErr = NULL((void*)0);
      }
      PR_fprintf(errorFD, "Writing zip data: %s\n",
                 nsprErr ? nsprErr : "");
      if (nsprErr)
          PR_Free(nsprErr);
      errorCount++;
      exit(ERRX(-1));
  }

  /* Write out Zipfile comment */
  if (zipfile->comment) {
      if (PR_Write(zipfp, zipfile->comment, strlen(zipfile->comment)) <
          strlen(zipfile->comment)) {
          char *nsprErr;
          if (PR_GetErrorTextLength()) {
              nsprErr = PR_Malloc(PR_GetErrorTextLength() + 1);
              PR_GetErrorText(nsprErr);
          } else {
              nsprErr = NULL((void*)0);
          }
          PR_fprintf(errorFD, "Writing zip data: %s\n",
                     nsprErr ? nsprErr : "");
          if (nsprErr)
              PR_Free(nsprErr);
          errorCount++;
          exit(ERRX(-1));
      }
  }

  PR_Close(zipfp);

  /* Free the memory of the zipfile structure */
  if (zipfile->filename) {
      PORT_FreePORT_Free_Util(zipfile->filename);
  }
  if (zipfile->comment) {
      PORT_FreePORT_Free_Util(zipfile->comment);
  }
  PORT_FreePORT_Free_Util(zipfile);

  return 0;
644}

646/**********************************************
*  i n t t o x
*
*  Converts a two byte ugly endianed integer
*  to our platform's integer.
*
*/

654static void
655inttox(int in, char *out)
656{
  out[0] = (in & 0xFF);
  out[1] = (in & 0xFF00) >> 8;
659}

661/*********************************************
*  l o n g t o x
*
*  Converts a four byte ugly endianed integer
*  to our platform's integer.
*
*/

669static void
670longtox(long in, char *out)
671{
  out[0] = (in & 0xFF);
  out[1] = (in & 0xFF00) >> 8;
  out[2] = (in & 0xFF0000) >> 16;
  out[3] = (in & 0xFF000000) >> 24;
676}