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

Bug Summary

File:	root/firefox-clang/modules/libmar/src/mar_read.c
Warning:	line 234, column 5 Value of 'errno' was not checked and may be overwritten by function 'fprintf'

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_read.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_read.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 <fcntl.h>
7#include <stdlib.h>
8#include <string.h>
9#include "city.h"
10#include "mar_private.h"
11#include "mar.h"
12#ifdef XP_WIN
13#  define strdup _strdup
14#endif

16/* This block must be at most 104 bytes.
 MAR channel name < 64 bytes, and product version < 32 bytes + 3 NULL
 terminator bytes. We only check for 96 though because we remove 8
 bytes above from the additionalBlockSize: We subtract
 sizeof(additionalBlockSize) and sizeof(additionalBlockID) */
21#define MAXADDITIONALBLOCKSIZE96 96

23static uint32_t mar_hash_name(const char* name) {
return CityHash64(name, strlen(name)) % TABLESIZE256;
25}

27static int mar_insert_item(MarFile* mar, const char* name, uint32_t namelen,
                         uint32_t offset, uint32_t length, uint32_t flags) {
MarItem *item, *root;
uint32_t hash;

item = (MarItem*)malloc(sizeof(MarItem) + namelen);
if (!item) {
  return -1;
}
item->next = NULL((void*)0);
item->offset = offset;
item->length = length;
item->flags = flags;
memcpy(item->name, name, namelen + 1);

hash = mar_hash_name(name);

root = mar->item_table[hash];
if (!root) {
  mar->item_table[hash] = item;
} else {
  /* append item */
  while (root->next) root = root->next;
  root->next = item;
}
return 0;
53}

55static int mar_consume_index(MarFile* mar, char** buf, const char* buf_end) {
/*
 * Each item has the following structure:
 *   uint32_t offset      (network byte order)
 *   uint32_t length      (network byte order)
 *   uint32_t flags       (network byte order)
 *   char     name[N]     (where N >= 1)
 *   char     null_byte;
 */
uint32_t offset;
uint32_t length;
uint32_t flags;
const char* name;
int namelen;

if ((buf_end - *buf) < (int)(3 * sizeof(uint32_t) + 2)) {
  return -1;
}

memcpy(&offset, *buf, sizeof(offset));
*buf += sizeof(offset);

memcpy(&length, *buf, sizeof(length));
*buf += sizeof(length);

memcpy(&flags, *buf, sizeof(flags));
*buf += sizeof(flags);

offset = ntohl(offset)__bswap_32 (offset);
length = ntohl(length)__bswap_32 (length);
flags = ntohl(flags)__bswap_32 (flags);

name = *buf;
/* find namelen; must take care not to read beyond buf_end */
while (**buf) {
  /* buf_end points one byte past the end of buf's allocation */
  if (*buf == (buf_end - 1)) {
    return -1;
  }
  ++(*buf);
}
namelen = (*buf - name);
/* must ensure that namelen is valid */
if (namelen < 0) {
  return -1;
}
/* consume null byte */
if (*buf == buf_end) {
  return -1;
}
++(*buf);

return mar_insert_item(mar, name, namelen, offset, length, flags);
108}

110static int mar_read_index(MarFile* mar) {
char id[MAR_ID_SIZE4], *buf, *bufptr, *bufend;
uint32_t offset_to_index, size_of_index;
size_t mar_position = 0;

/* verify MAR ID */
if (mar_read_buffer(mar, id, &mar_position, MAR_ID_SIZE4) != 0) {
  return -1;
}
if (memcmp(id, MAR_ID"MAR1", MAR_ID_SIZE4) != 0) {
  return -1;
}

if (mar_read_buffer(mar, &offset_to_index, &mar_position, sizeof(uint32_t)) !=
    0) {
  return -1;
}
offset_to_index = ntohl(offset_to_index)__bswap_32 (offset_to_index);

mar_position = 0;
if (mar_buffer_seek(mar, &mar_position, offset_to_index) != 0) {
  return -1;
}
if (mar_read_buffer(mar, &size_of_index, &mar_position, sizeof(uint32_t)) !=
    0) {
  return -1;
}
size_of_index = ntohl(size_of_index)__bswap_32 (size_of_index);

if (size_of_index > mar->data_len) {
  return -1;
}
buf = (char*)malloc(size_of_index);
if (!buf) {
  return -1;
}
if (mar_read_buffer(mar, buf, &mar_position, size_of_index) != 0) {
  free(buf);
  return -1;
}

bufptr = buf;
bufend = buf + size_of_index;
while (bufptr < bufend && mar_consume_index(mar, &bufptr, bufend) == 0);

free(buf);
return (bufptr == bufend) ? 0 : -1;
157}

159/**
* Adds an offset and length to the MarFile's index_list
* @param mar     The MarFile that owns this offset length pair
* @param offset  The byte offset in the archive to be marked as processed
* @param length  The length corresponding to this byte offset
* @return int    1 on success, 0 if offset has been previously processed
*                -1 if unable to allocate space for the SeenIndexes
*/
167static int mar_insert_offset(MarFile* mar, uint32_t offset, uint32_t length) {
/* Ignore files with no length */
if (length == 0) {
  return 1;
}

SeenIndex* index = (SeenIndex*)malloc(sizeof(SeenIndex));
if (!index) {
  return -1;
}
index->next = NULL((void*)0);
index->offset = offset;
index->length = length;
uint32_t index_end = index->offset + index->length - 1;

/* If this is our first index store it at the front */
if (mar->index_list == NULL((void*)0)) {
  mar->index_list = index;
  return 1;
}

/* Search for matching indexes in the list of those previously visited */
SeenIndex* previous;
SeenIndex* current = mar->index_list;
while (current != NULL((void*)0)) {
  uint32_t current_end = current->offset + current->length - 1;

  /* If index has collided with the front or end of current or if current has
     collided with the front or end of index return false */
  if ((index->offset >= current->offset && index->offset <= current_end) ||
      (index_end >= current->offset && index_end <= current_end) ||
      (current->offset >= index->offset && current->offset <= index_end) ||
      (current_end >= index->offset && current_end <= index_end)) {
    free(index);
    return 0;
  }

  /* else move to the next in the list */
  previous = current;
  current = current->next;
}

/* These indexes are valid, track them */
previous->next = index;
return 1;
212}

214/**
* Internal shared code for mar_open and mar_wopen.
* Reads the entire MAR into memory. Fails if it is bigger than
* MAX_SIZE_OF_MAR_FILE bytes.
*/
219static MarReadResult mar_fpopen(FILE* fp, MarFile** out_mar) {
*out_mar = NULL((void*)0);
MarFile* mar;

mar = (MarFile*)malloc(sizeof(*mar));
if (!mar) {
4
←
Assuming 'mar' is non-null→
5
←
Taking false branch→
  return MAR_MEM_ERROR;
}

off_t buffer_size = -1;
if (fseeko(fp, 0, SEEK_END2) == 0) {
6
←
Taking true branch→
  buffer_size = ftello(fp);
}
rewind(fp);
7
←
After calling 'rewind' reading 'errno' is required to find out if the call has failed→
if (buffer_size7.1
'buffer_size' is < 0
 < 0) {
8
←
Taking true branch→
  fprintf(stderrstderr, "Warning: MAR size could not be determined\n");
9
←
Value of 'errno' was not checked and may be overwritten by function 'fprintf'
  buffer_size = MAX_SIZE_OF_MAR_FILE((int64_t)524288000);
}
if (buffer_size > MAX_SIZE_OF_MAR_FILE((int64_t)524288000)) {
  fprintf(stderrstderr, "ERROR: MAR exceeds maximum size (%lli)\n",
          (long long int)buffer_size);
  free(mar);
  return MAR_FILE_TOO_BIG_ERROR;
}

mar->buffer = malloc(buffer_size);
if (!mar->buffer) {
  fprintf(stderrstderr, "ERROR: MAR buffer could not be allocated\n");
  free(mar);
  return MAR_MEM_ERROR;
}
mar->data_len = fread(mar->buffer, 1, buffer_size, fp);
if (fgetc(fp) != EOF(-1)) {
  fprintf(stderrstderr, "ERROR: File is larger than buffer (%lli)\n",
          (long long int)buffer_size);
  free(mar->buffer);
  free(mar);
  return MAR_IO_ERROR;
}
if (ferror(fp)) {
  fprintf(stderrstderr, "ERROR: Failed to read MAR\n");
  free(mar->buffer);
  free(mar);
  return MAR_IO_ERROR;
}

mar->item_table_is_valid = 0;
memset(mar->item_table, 0, sizeof(mar->item_table));
mar->index_list = NULL((void*)0);

*out_mar = mar;
return MAR_READ_SUCCESS;
271}

273MarReadResult mar_open(const char* path, MarFile** out_mar) {
*out_mar = NULL((void*)0);

FILE* fp;

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

MarReadResult result = mar_fpopen(fp, out_mar);
3
←
Calling 'mar_fpopen'→
fclose(fp);
return result;
288}

290#ifdef XP_WIN
291MarReadResult mar_wopen(const wchar_t* path, MarFile** out_mar) {
*out_mar = NULL((void*)0);

FILE* fp;

_wfopen_s(&fp, path, L"rb");
if (!fp) {
  fprintf(stderrstderr, "ERROR: could not open file in mar_wopen()\n");
  _wperror(path);
  return MAR_IO_ERROR;
}

MarReadResult result = mar_fpopen(fp, out_mar);
fclose(fp);
return result;
306}
307#endif

309void mar_close(MarFile* mar) {
MarItem* item;
SeenIndex* index;
int i;

free(mar->buffer);

for (i = 0; i < TABLESIZE256; ++i) {
  item = mar->item_table[i];
  while (item) {
    MarItem* temp = item;
    item = item->next;
    free(temp);
  }
}

while (mar->index_list != NULL((void*)0)) {
  index = mar->index_list;
  mar->index_list = index->next;
  free(index);
}

free(mar);
332}

334int mar_read_buffer(MarFile* mar, void* dest, size_t* position, size_t size) {
// size may be provided by the MAR, which we may not have finished validating
// the signature on yet. Make sure not to trust it in a way that could
// cause an overflow.
if (size > mar->data_len) {
  return -1;
}
if (*position > mar->data_len - size) {
  return -1;
}
memcpy(dest, mar->buffer + *position, size);
*position += size;
return 0;
347}

349int mar_read_buffer_max(MarFile* mar, void* dest, size_t* position,
                      size_t size) {
// size may be provided by the MAR, which we may not have finished validating
// the signature on yet. Make sure not to trust it in a way that could
// cause an overflow.
if (mar->data_len <= *position) {
  return 0;
}
size_t read_count = mar->data_len - *position;
if (read_count > size) {
  read_count = size;
}
memcpy(dest, mar->buffer + *position, read_count);
*position += read_count;
return read_count;
364}

366int mar_buffer_seek(MarFile* mar, size_t* position, size_t distance) {
// distance may be provided by the MAR, which we may not have finished
// validating the signature on yet. Make sure not to trust it in a way that
// could cause an overflow.
if (distance > mar->data_len) {
  return -1;
}
if (*position > mar->data_len - distance) {
  return -1;
}
*position += distance;
return 0;
378}

380/**
* Determines the MAR file information.
*
* @param mar                    An open MAR file.
* @param mar_position           The current position in the MAR.
*                               Its value will be updated to the current
*                               position in the MAR after the function exits.
*                               Since its initial value will never actually be
*                               used, this is effectively an outparam.
* @param hasSignatureBlock      Optional out parameter specifying if the MAR
*                               file has a signature block or not.
* @param numSignatures          Optional out parameter for storing the number
*                               of signatures in the MAR file.
* @param hasAdditionalBlocks    Optional out parameter specifying if the MAR
*                               file has additional blocks or not.
* @param offsetAdditionalBlocks Optional out parameter for the offset to the
*                               first additional block. Value is only valid if
*                               hasAdditionalBlocks is not equal to 0.
* @param numAdditionalBlocks    Optional out parameter for the number of
*                               additional blocks.  Value is only valid if
*                               hasAdditionalBlocks is not equal to 0.
* @return 0 on success and non-zero on failure.
*/
403int get_open_mar_file_info(MarFile* mar, size_t* mar_position,
                         int* hasSignatureBlock, uint32_t* numSignatures,
                         int* hasAdditionalBlocks,
                         uint32_t* offsetAdditionalBlocks,
                         uint32_t* numAdditionalBlocks) {
uint32_t offsetToIndex, offsetToContent, signatureCount, signatureLen, i;

/* One of hasSignatureBlock or hasAdditionalBlocks must be non NULL */
if (!hasSignatureBlock && !hasAdditionalBlocks) {
  return -1;
}

/* Skip to the start of the offset index */
*mar_position = 0;
if (mar_buffer_seek(mar, mar_position, MAR_ID_SIZE4) != 0) {
  return -1;
}

/* Read the offset to the index. */
if (mar_read_buffer(mar, &offsetToIndex, mar_position,
                    sizeof(offsetToIndex)) != 0) {
  return -1;
}
offsetToIndex = ntohl(offsetToIndex)__bswap_32 (offsetToIndex);

if (numSignatures) {
  /* Skip past the MAR file size field */
  if (mar_buffer_seek(mar, mar_position, sizeof(uint64_t)) != 0) {
    return -1;
  }

  /* Read the number of signatures field */
  if (mar_read_buffer(mar, numSignatures, mar_position,
                      sizeof(*numSignatures)) != 0) {
    return -1;
  }
  *numSignatures = ntohl(*numSignatures)__bswap_32 (*numSignatures);
}

/* Skip to the first index entry past the index size field
   We do it in 2 calls because offsetToIndex + sizeof(uint32_t)
   could overflow in theory. */
*mar_position = 0;
if (mar_buffer_seek(mar, mar_position, offsetToIndex) != 0) {
  return -1;
}

if (mar_buffer_seek(mar, mar_position, sizeof(uint32_t)) != 0) {
  return -1;
}

/* Read the first offset to content field. */
if (mar_read_buffer(mar, &offsetToContent, mar_position,
                    sizeof(offsetToContent)) != 0) {
  return -1;
}
offsetToContent = ntohl(offsetToContent)__bswap_32 (offsetToContent);

/* Check if we have a new or old MAR file */
if (hasSignatureBlock) {
  if (offsetToContent == MAR_ID_SIZE4 + sizeof(uint32_t)) {
    *hasSignatureBlock = 0;
  } else {
    *hasSignatureBlock = 1;
  }
}

/* If the caller doesn't care about the product info block
   value, then just return */
if (!hasAdditionalBlocks) {
  return 0;
}

/* Skip to the start of the signature block */
*mar_position = 0;
if (mar_buffer_seek(mar, mar_position, SIGNATURE_BLOCK_OFFSET16) != 0) {
  return -1;
}

/* Get the number of signatures */
if (mar_read_buffer(mar, &signatureCount, mar_position,
                    sizeof(signatureCount)) != 0) {
  return -1;
}
signatureCount = ntohl(signatureCount)__bswap_32 (signatureCount);

/* Check that we have less than the max amount of signatures so we don't
   waste too much of either updater's or signmar's time. */
if (signatureCount > MAX_SIGNATURES8) {
  return -1;
}

/* Skip past the whole signature block */
for (i = 0; i < signatureCount; i++) {
  /* Skip past the signature algorithm ID */
  if (mar_buffer_seek(mar, mar_position, sizeof(uint32_t)) != 0) {
    return -1;
  }

  /* Read the signature length and skip past the signature */
  if (mar_read_buffer(mar, &signatureLen, mar_position, sizeof(uint32_t)) !=
      0) {
    return -1;
  }
  signatureLen = ntohl(signatureLen)__bswap_32 (signatureLen);
  if (mar_buffer_seek(mar, mar_position, signatureLen) != 0) {
    return -1;
  }
}

if (*mar_position <= (size_t)INT64_MAX(9223372036854775807L) &&
    (int64_t)mar_position == (int64_t)offsetToContent) {
  *hasAdditionalBlocks = 0;
} else {
  if (numAdditionalBlocks) {
    /* We have an additional block, so read in the number of additional blocks
       and set the offset. */
    *hasAdditionalBlocks = 1;
    if (mar_read_buffer(mar, numAdditionalBlocks, mar_position,
                        sizeof(uint32_t)) != 0) {
      return -1;
    }
    *numAdditionalBlocks = ntohl(*numAdditionalBlocks)__bswap_32 (*numAdditionalBlocks);
    if (offsetAdditionalBlocks) {
      if (*mar_position > (size_t)UINT32_MAX(4294967295U)) {
        return -1;
      }
      *offsetAdditionalBlocks = (uint32_t)*mar_position;
    }
  } else if (offsetAdditionalBlocks) {
    /* numAdditionalBlocks is not specified but offsetAdditionalBlocks
       is, so fill it! */
    if (mar_buffer_seek(mar, mar_position, sizeof(uint32_t)) != 0) {
      return -1;
    }
    if (*mar_position > (size_t)UINT32_MAX(4294967295U)) {
      return -1;
    }
    *offsetAdditionalBlocks = (uint32_t)*mar_position;
  }
}

return 0;
546}

548/**
* Reads the product info block from the MAR file's additional block section.
* The caller is responsible for freeing the fields in infoBlock
* if the return is successful.
*
* @param infoBlock Out parameter for where to store the result to
* @return 0 on success, -1 on failure
*/
556int read_product_info_block(char* path,
                          struct ProductInformationBlock* infoBlock) {
int rv;
MarFile* mar;
MarReadResult result = mar_open(path, &mar);
if (result != MAR_READ_SUCCESS) {
  fprintf(stderrstderr,
          "ERROR: could not open file in read_product_info_block()\n");
  return -1;
}
rv = mar_read_product_info_block(mar, infoBlock);
mar_close(mar);
return rv;
569}

571/**
* Reads the product info block from the MAR file's additional block section.
* The caller is responsible for freeing the fields in infoBlock
* if the return is successful.
*
* @param infoBlock Out parameter for where to store the result to
* @return 0 on success, -1 on failure
*/
579int mar_read_product_info_block(MarFile* mar,
                              struct ProductInformationBlock* infoBlock) {
uint32_t offsetAdditionalBlocks, numAdditionalBlocks, additionalBlockSize,
    additionalBlockID;
int hasAdditionalBlocks;
size_t mar_position = 0;

/* The buffer size is 97 bytes because the MAR channel name < 64 bytes, and
   product version < 32 bytes + 3 NULL terminator bytes. */
char buf[MAXADDITIONALBLOCKSIZE96 + 1] = {'\0'};
if (get_open_mar_file_info(mar, &mar_position, NULL((void*)0), NULL((void*)0),
                           &hasAdditionalBlocks, &offsetAdditionalBlocks,
                           &numAdditionalBlocks) != 0) {
  return -1;
}

/* We only have the one additional block type and only one is expected to be
   in a MAR file so check if any exist and process the first found */
if (numAdditionalBlocks > 0) {
  /* Read the additional block size */
  if (mar_read_buffer(mar, &additionalBlockSize, &mar_position,
                      sizeof(additionalBlockSize)) != 0) {
    return -1;
  }
  additionalBlockSize = ntohl(additionalBlockSize)__bswap_32 (additionalBlockSize) -
                        sizeof(additionalBlockSize) -
                        sizeof(additionalBlockID);

  /* Additional Block sizes should only be 96 bytes long */
  if (additionalBlockSize > MAXADDITIONALBLOCKSIZE96) {
    return -1;
  }

  /* Read the additional block ID */
  if (mar_read_buffer(mar, &additionalBlockID, &mar_position,
                      sizeof(additionalBlockID)) != 0) {
    return -1;
  }
  additionalBlockID = ntohl(additionalBlockID)__bswap_32 (additionalBlockID);

  if (PRODUCT_INFO_BLOCK_ID1 == additionalBlockID) {
    const char* location;
    int len;

    if (mar_read_buffer(mar, buf, &mar_position, additionalBlockSize) != 0) {
      return -1;
    }

    /* Extract the MAR channel name from the buffer.  For now we
       point to the stack allocated buffer but we strdup this
       if we are within bounds of each field's max length. */
    location = buf;
    len = strlen(location);
    infoBlock->MARChannelID = location;
    location += len + 1;
    if (len >= 64) {
      infoBlock->MARChannelID = NULL((void*)0);
      return -1;
    }

    /* Extract the version from the buffer */
    len = strlen(location);
    infoBlock->productVersion = location;
    if (len >= 32) {
      infoBlock->MARChannelID = NULL((void*)0);
      infoBlock->productVersion = NULL((void*)0);
      return -1;
    }
    infoBlock->MARChannelID = strdup(infoBlock->MARChannelID);
    infoBlock->productVersion = strdup(infoBlock->productVersion);
    return 0;
  } else {
    /* This is not the additional block you're looking for. Move along. */
    if (mar_buffer_seek(mar, &mar_position, additionalBlockSize) != 0) {
      return -1;
    }
  }
}

/* If we had a product info block we would have already returned */
return -1;
660}

662const MarItem* mar_find_item(MarFile* mar, const char* name) {
uint32_t hash;
const MarItem* item;

if (!mar->item_table_is_valid) {
  if (mar_read_index(mar)) {
    return NULL((void*)0);
  } else {
    mar->item_table_is_valid = 1;
  }
}

hash = mar_hash_name(name);

item = mar->item_table[hash];
while (item && strcmp(item->name, name) != 0) {
  item = item->next;
}

/* If this is the first time seeing this item's indexes, return it */
if (mar_insert_offset(mar, item->offset, item->length) == 1) {
  return item;
} else {
  fprintf(stderrstderr, "ERROR: file content collision in mar_find_item()\n");
  return NULL((void*)0);
}
688}

690int mar_enum_items(MarFile* mar, MarItemCallback callback, void* closure) {
MarItem* item;
int i, rv;

if (!mar->item_table_is_valid) {
  if (mar_read_index(mar)) {
    return -1;
  } else {
    mar->item_table_is_valid = 1;
  }
}

for (i = 0; i < TABLESIZE256; ++i) {
  item = mar->item_table[i];
  while (item) {
    /* if this is the first time seeing this item's indexes, process it */
    if (mar_insert_offset(mar, item->offset, item->length) == 1) {
      rv = callback(mar, item, closure);
      if (rv) {
        return rv;
      }
    } else {
      fprintf(stderrstderr, "ERROR: file content collision in mar_enum_items()\n");
      return 1;
    }
    item = item->next;
  }
}

return 0;
720}

722int mar_read(MarFile* mar, const MarItem* item, int offset, uint8_t* buf,
           int bufsize) {
int nr;
size_t mar_position = 0;

if (offset == (int)item->length) {
  return 0;
}
if (offset > (int)item->length) {
  return -1;
}

nr = item->length - offset;
if (nr > bufsize) {
  nr = bufsize;
}

// Avoid adding item->offset and offset directly, just in case of overflow.
if (mar_buffer_seek(mar, &mar_position, item->offset)) {
  return -1;
}
if (mar_buffer_seek(mar, &mar_position, offset)) {
  return -1;
}

return mar_read_buffer_max(mar, buf, &mar_position, nr);
748}

750/**
* Determines the MAR file information.
*
* @param path                   The path of the MAR file to check.
* @param hasSignatureBlock      Optional out parameter specifying if the MAR
*                               file has a signature block or not.
* @param numSignatures          Optional out parameter for storing the number
*                               of signatures in the MAR file.
* @param hasAdditionalBlocks    Optional out parameter specifying if the MAR
*                               file has additional blocks or not.
* @param offsetAdditionalBlocks Optional out parameter for the offset to the
*                               first additional block. Value is only valid if
*                               hasAdditionalBlocks is not equal to 0.
* @param numAdditionalBlocks    Optional out parameter for the number of
*                               additional blocks.  Value is only valid if
*                               has_additional_blocks is not equal to 0.
* @return 0 on success and non-zero on failure.
*/
768int get_mar_file_info(const char* path, int* hasSignatureBlock,
                    uint32_t* numSignatures, int* hasAdditionalBlocks,
                    uint32_t* offsetAdditionalBlocks,
                    uint32_t* numAdditionalBlocks) {
int rv;
MarFile* mar;
size_t mar_position = 0;
MarReadResult result = mar_open(path, &mar);
1
Calling 'mar_open'→
if (result != MAR_READ_SUCCESS) {
  fprintf(stderrstderr, "ERROR: could not read file in get_mar_file_info()\n");
  return -1;
}

rv = get_open_mar_file_info(mar, &mar_position, hasSignatureBlock,
                            numSignatures, hasAdditionalBlocks,
                            offsetAdditionalBlocks, numAdditionalBlocks);

mar_close(mar);
return rv;
787}