/root/firefox-clang/modules/libmar/src/mar_create.c

Bug Summary

File:	root/firefox-clang/modules/libmar/src/mar_create.c
Warning:	line 87, column 17 Read function called when stream is in EOF state. Function has no effect

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -O3 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name mar_create.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 -pic-is-pie -mframe-pointer=none -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=/root/firefox-clang/obj-x86_64-pc-linux-gnu/modules/libmar/src -fcoverage-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/modules/libmar/src -resource-dir /usr/lib/llvm-23/lib/clang/23 -D XP_UNIX -D DEBUG=1 -I /root/firefox-clang/modules/libmar/src -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/modules/libmar/src -I /root/firefox-clang/other-licenses/nsis/Contrib/CityHash/cityhash -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nspr -internal-isystem /usr/lib/llvm-23/lib/clang/23/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/16/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -ferror-limit 19 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -fdwarf2-cfi-asm -o /tmp/scan-build-2026-09-01-224014-2642839-1 -x c /root/firefox-clang/modules/libmar/src/mar_create.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 <sys/types.h>
6#include <sys/stat.h>
7#include <fcntl.h>
8#include <stdlib.h>
9#include <string.h>
10#include "mar_private.h"
11#include "mar_cmdline.h"
12#include "mar.h"

14#ifdef XP_WIN
15#  include <winsock2.h>
16#else
17#  include <netinet/in.h>
18#  include <unistd.h>
19#endif

21struct MarItemStack {
void* head;
uint32_t size_used;
uint32_t size_allocated;
uint32_t last_offset;
26};

28/**
* Push a new item onto the stack of items.  The stack is a single block
* of memory.
*/
32static int mar_push(struct MarItemStack* stack, uint32_t length, uint32_t flags,
                  const char* name) {
int namelen;
uint32_t n_offset, n_length, n_flags;
uint32_t size;
char* data;

namelen = strlen(name);
size = MAR_ITEM_SIZE(namelen)(3 * sizeof(uint32_t) + (namelen) + 1);

if (stack->size_allocated - stack->size_used < size) {
  /* increase size of stack */
  size_t size_needed = ROUND_UP(stack->size_used + size, BLOCKSIZE)(((stack->size_used + size) / (4096) + 1) * (4096));
  stack->head = realloc(stack->head, size_needed);
  if (!stack->head) {
    return -1;
  }
  stack->size_allocated = size_needed;
}

data = (((char*)stack->head) + stack->size_used);

n_offset = htonl(stack->last_offset)__bswap_32 (stack->last_offset);
n_length = htonl(length)__bswap_32 (length);
n_flags = htonl(flags)__bswap_32 (flags);

memcpy(data, &n_offset, sizeof(n_offset));
data += sizeof(n_offset);

memcpy(data, &n_length, sizeof(n_length));
data += sizeof(n_length);

memcpy(data, &n_flags, sizeof(n_flags));
data += sizeof(n_flags);

memcpy(data, name, namelen + 1);

stack->size_used += size;
stack->last_offset += length;
return 0;
72}

74static int mar_concat_file(FILE* fp, const char* path) {
FILE* in;
char buf[BLOCKSIZE4096];
size_t len;
int rv = 0;

in = fopen(path, "rb");
if (!in12.1
'in' is non-null
) {
13
←
Taking false branch→
  fprintf(stderrstderr, "ERROR: could not open file in mar_concat_file()\n");
  perror(path);
  return -1;
}

while ((len = fread(buf, 1, BLOCKSIZE4096, in)) > 0) {
14
←
Assuming stream reaches end-of-file here→
15
←
Assuming the condition is true→
16
←
Loop condition is true.  Entering loop body→
18
←
Read function called when stream is in EOF state. Function has no effect
  if (fwrite(buf, len, 1, fp) != 1) {
17
←
Taking false branch→
    rv = -1;
    break;
  }
}

fclose(in);
return rv;
96}

98/**
* Writes out the product information block to the specified file.
*
* @param fp           The opened MAR file being created.
* @param stack        A pointer to the MAR item stack being used to create
*                     the MAR
* @param infoBlock    The product info block to store in the file.
* @return 0 on success.
*/
107static int mar_concat_product_info_block(
  FILE* fp, struct MarItemStack* stack,
  struct ProductInformationBlock* infoBlock) {
char buf[PIB_MAX_MAR_CHANNEL_ID_SIZE63 + PIB_MAX_PRODUCT_VERSION_SIZE31];
uint32_t additionalBlockID = 1, infoBlockSize, unused;
if (!fp || !infoBlock || !infoBlock->MARChannelID ||
    !infoBlock->productVersion) {
  return -1;
}

/* The MAR channel name must be < 64 bytes per the spec */
if (strlen(infoBlock->MARChannelID) > PIB_MAX_MAR_CHANNEL_ID_SIZE63) {
  return -1;
}

/* The product version must be < 32 bytes per the spec */
if (strlen(infoBlock->productVersion) > PIB_MAX_PRODUCT_VERSION_SIZE31) {
  return -1;
}

/* Although we don't need the product information block size to include the
   maximum MAR channel name and product version, we allocate the maximum
   amount to make it easier to modify the MAR file for repurposing MAR files
   to different MAR channels. + 2 is for the NULL terminators. */
infoBlockSize = sizeof(infoBlockSize) + sizeof(additionalBlockID) +
                PIB_MAX_MAR_CHANNEL_ID_SIZE63 + PIB_MAX_PRODUCT_VERSION_SIZE31 +
                2;
if (stack) {
  stack->last_offset += infoBlockSize;
}

/* Write out the product info block size */
infoBlockSize = htonl(infoBlockSize)__bswap_32 (infoBlockSize);
if (fwrite(&infoBlockSize, sizeof(infoBlockSize), 1, fp) != 1) {
  return -1;
}
infoBlockSize = ntohl(infoBlockSize)__bswap_32 (infoBlockSize);

/* Write out the product info block ID */
additionalBlockID = htonl(additionalBlockID)__bswap_32 (additionalBlockID);
if (fwrite(&additionalBlockID, sizeof(additionalBlockID), 1, fp) != 1) {
  return -1;
}
additionalBlockID = ntohl(additionalBlockID)__bswap_32 (additionalBlockID);

/* Write out the channel name and NULL terminator */
if (fwrite(infoBlock->MARChannelID, strlen(infoBlock->MARChannelID) + 1, 1,
           fp) != 1) {
  return -1;
}

/* Write out the product version string and NULL terminator */
if (fwrite(infoBlock->productVersion, strlen(infoBlock->productVersion) + 1,
           1, fp) != 1) {
  return -1;
}

/* Write out the rest of the block that is unused */
unused = infoBlockSize - (sizeof(infoBlockSize) + sizeof(additionalBlockID) +
                          strlen(infoBlock->MARChannelID) +
                          strlen(infoBlock->productVersion) + 2);
memset(buf, 0, sizeof(buf));
if (fwrite(buf, unused, 1, fp) != 1) {
  return -1;
}
return 0;
173}

175/**
* Refreshes the product information block with the new information.
* The input MAR must not be signed or the function call will fail.
*
* @param path             The path to the MAR file whose product info block
*                         should be refreshed.
* @param infoBlock        Out parameter for where to store the result to
* @return 0 on success, -1 on failure
*/
184int refresh_product_info_block(const char* path,
                             struct ProductInformationBlock* infoBlock) {
FILE* fp;
int rv;
uint32_t numSignatures, additionalBlockSize, additionalBlockID,
    offsetAdditionalBlocks, numAdditionalBlocks, i;
int additionalBlocks, hasSignatureBlock;
int64_t oldPos;

rv = get_mar_file_info(path, &hasSignatureBlock, &numSignatures,
                       &additionalBlocks, &offsetAdditionalBlocks,
                       &numAdditionalBlocks);
if (rv) {
  fprintf(stderrstderr, "ERROR: Could not obtain MAR information.\n");
  return -1;
}

if (hasSignatureBlock && numSignatures) {
  fprintf(stderrstderr, "ERROR: Cannot refresh a signed MAR\n");
  return -1;
}

fp = fopen(path, "r+b");
if (!fp) {
  fprintf(stderrstderr, "ERROR: could not open target file: %s\n", path);
  return -1;
}

if (fseeko(fp, offsetAdditionalBlocks, SEEK_SET0)) {
  fprintf(stderrstderr, "ERROR: could not seek to additional blocks\n");
  fclose(fp);
  return -1;
}

for (i = 0; i < numAdditionalBlocks; ++i) {
  /* Get the position of the start of this block */
  oldPos = ftello(fp);

  /* Read the additional block size */
  if (fread(&additionalBlockSize, sizeof(additionalBlockSize), 1, fp) != 1) {
    fclose(fp);
    return -1;
  }
  additionalBlockSize = ntohl(additionalBlockSize)__bswap_32 (additionalBlockSize);

  /* Read the additional block ID */
  if (fread(&additionalBlockID, sizeof(additionalBlockID), 1, fp) != 1) {
    fclose(fp);
    return -1;
  }
  additionalBlockID = ntohl(additionalBlockID)__bswap_32 (additionalBlockID);

  if (PRODUCT_INFO_BLOCK_ID1 == additionalBlockID) {
    if (fseeko(fp, oldPos, SEEK_SET0)) {
      fprintf(stderrstderr, "Could not seek back to Product Information Block\n");
      fclose(fp);
      return -1;
    }

    if (mar_concat_product_info_block(fp, NULL((void*)0), infoBlock)) {
      fprintf(stderrstderr, "Could not concat Product Information Block\n");
      fclose(fp);
      return -1;
    }

    fclose(fp);
    return 0;
  }

  /* This is not the additional block you're looking for. Move along. */
  if (fseek(fp, additionalBlockSize, SEEK_CUR1)) {
    fprintf(stderrstderr, "ERROR: Could not seek past current block.\n");
    fclose(fp);
    return -1;
  }
}

/* If we had a product info block we would have already returned */
fclose(fp);
fprintf(stderrstderr, "ERROR: Could not refresh because block does not exist\n");
return -1;
265}

267/**
* Create a MAR file from a set of files.
* @param dest      The path to the file to create.  This path must be
*                  compatible with fopen.
* @param numfiles  The number of files to store in the archive.
* @param files     The list of null-terminated file paths.  Each file
*                  path must be compatible with fopen.
* @param infoBlock The information to store in the product information block.
* @return A non-zero value if an error occurs.
*/
277int mar_create(const char* dest, int num_files, char** files,
             struct ProductInformationBlock* infoBlock) {
struct MarItemStack stack;
uint32_t offset_to_index = 0, size_of_index, numSignatures,
         numAdditionalSections;
uint64_t sizeOfEntireMAR = 0;
struct stat st;
FILE* fp;
int i, rv = -1;

memset(&stack, 0, sizeof(stack));

fp = fopen(dest, "wb");
if (!fp0.1
'fp' is non-null
) {
1
Taking false branch→
  fprintf(stderrstderr, "ERROR: could not create target file: %s\n", dest);
  return -1;
}

if (fwrite(MAR_ID"MAR1", MAR_ID_SIZE4, 1, fp) != 1) {
2
←
Taking false branch→
  goto failure;
}
if (fwrite(&offset_to_index, sizeof(uint32_t), 1, fp) != 1) {
3
←
Taking false branch→
  goto failure;
}

stack.last_offset = MAR_ID_SIZE4 + sizeof(offset_to_index) +
                    sizeof(numSignatures) + sizeof(numAdditionalSections) +
                    sizeof(sizeOfEntireMAR);

/* We will circle back on this at the end of the MAR creation to fill it */
if (fwrite(&sizeOfEntireMAR, sizeof(sizeOfEntireMAR), 1, fp) != 1) {
4
←
Taking false branch→
  goto failure;
}

/* Write out the number of signatures, for now only at most 1 is supported */
numSignatures = 0;
if (fwrite(&numSignatures, sizeof(numSignatures), 1, fp) != 1) {
5
←
Taking false branch→
  goto failure;
}

/* Write out the number of additional sections, for now just 1
   for the product info block */
numAdditionalSections = htonl(1)__bswap_32 (1);
if (fwrite(&numAdditionalSections, sizeof(numAdditionalSections), 1, fp) !=
6
←
Taking false branch→
    1) {
  goto failure;
}
numAdditionalSections = ntohl(numAdditionalSections)__bswap_32 (numAdditionalSections);

if (mar_concat_product_info_block(fp, &stack, infoBlock)) {
7
←
Taking false branch→
  goto failure;
}

for (i = 0; i < num_files; ++i) {
8
←
Assuming 'i' is < 'num_files'→
9
←
Loop condition is true.  Entering loop body→
  if (stat(files[i], &st)) {
10
←
Taking false branch→
    fprintf(stderrstderr, "ERROR: file not found: %s\n", files[i]);
    goto failure;
  }

  if (mar_push(&stack, st.st_size, st.st_mode & 0777, files[i])) {
11
←
Taking false branch→
    goto failure;
  }

  /* concatenate input file to archive */
  if (mar_concat_file(fp, files[i])) {
12
←
Calling 'mar_concat_file'→
    goto failure;
  }
}

/* write out the index (prefixed with length of index) */
size_of_index = htonl(stack.size_used)__bswap_32 (stack.size_used);
if (fwrite(&size_of_index, sizeof(size_of_index), 1, fp) != 1) {
  goto failure;
}
if (fwrite(stack.head, stack.size_used, 1, fp) != 1) {
  goto failure;
}

/* To protect against invalid MAR files, we assumes that the MAR file
   size is less than or equal to MAX_SIZE_OF_MAR_FILE. */
if (ftell(fp) > MAX_SIZE_OF_MAR_FILE((int64_t)524288000)) {
  goto failure;
}

/* write out offset to index file in network byte order */
offset_to_index = htonl(stack.last_offset)__bswap_32 (stack.last_offset);
if (fseek(fp, MAR_ID_SIZE4, SEEK_SET0)) {
  goto failure;
}
if (fwrite(&offset_to_index, sizeof(offset_to_index), 1, fp) != 1) {
  goto failure;
}
offset_to_index = ntohl(stack.last_offset)__bswap_32 (stack.last_offset);

sizeOfEntireMAR =
    ((uint64_t)stack.last_offset) + stack.size_used + sizeof(size_of_index);
sizeOfEntireMAR = HOST_TO_NETWORK64(sizeOfEntireMAR)(((((uint64_t)sizeOfEntireMAR) & 0xFF) << 56) | (((
(uint64_t)sizeOfEntireMAR) >> 8) & 0xFF) << 48
) | (((((uint64_t)sizeOfEntireMAR) >> 16) & 0xFF) <<
 40) | (((((uint64_t)sizeOfEntireMAR) >> 24) & 0xFF
) << 32) | (((((uint64_t)sizeOfEntireMAR) >> 32) &
 0xFF) << 24) | (((((uint64_t)sizeOfEntireMAR) >>
 40) & 0xFF) << 16) | (((((uint64_t)sizeOfEntireMAR
) >> 48) & 0xFF) << 8) | (((uint64_t)sizeOfEntireMAR
) >> 56);
if (fwrite(&sizeOfEntireMAR, sizeof(sizeOfEntireMAR), 1, fp) != 1) {
  goto failure;
}
sizeOfEntireMAR = NETWORK_TO_HOST64(sizeOfEntireMAR)(((((uint64_t)sizeOfEntireMAR) & 0xFF) << 56) | (((
(uint64_t)sizeOfEntireMAR) >> 8) & 0xFF) << 48
) | (((((uint64_t)sizeOfEntireMAR) >> 16) & 0xFF) <<
 40) | (((((uint64_t)sizeOfEntireMAR) >> 24) & 0xFF
) << 32) | (((((uint64_t)sizeOfEntireMAR) >> 32) &
 0xFF) << 24) | (((((uint64_t)sizeOfEntireMAR) >>
 40) & 0xFF) << 16) | (((((uint64_t)sizeOfEntireMAR
) >> 48) & 0xFF) << 8) | (((uint64_t)sizeOfEntireMAR
) >> 56);

rv = 0;
380failure:
if (stack.head) {
  free(stack.head);
}
fclose(fp);
if (rv) {
  remove(dest);
}
return rv;
389}