mar_create.c

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim:set ts=2 sw=2 sts=2 et cindent: */
/* 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/. */
 
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <onlineupdate/mar_private.h>
#include <onlineupdate/mar_cmdline.h>
#include <onlineupdate/mar.h>
 
#ifdef _WIN32
#include <winsock2.h>
#else
#include <netinet/in.h>
#include <unistd.h>
#endif
 
struct MarItemStack {
  void *head;
  uint32_t size_used;
  uint32_t size_allocated;
  uint32_t last_offset;
};
 
static 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);
 
  if (stack->size_allocated - stack->size_used < size) {
    /* increase size of stack */
    size_t size_needed = ROUND_UP(stack->size_used + size, BLOCKSIZE);
    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);
  n_length = htonl(length);
  n_flags = htonl(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;
}
 
static int mar_concat_file(FILE *fp, const char *path) {
  FILE *in;
  char buf[BLOCKSIZE];
  size_t len;
  int rv = 0;
 
  in = fopen(path, "rb");
  if (!in) {
    fprintf(stderr, "ERROR: could not open file in mar_concat_file()\n");
    perror(path);
    return -1;
  }
 
  while ((len = fread(buf, 1, BLOCKSIZE, in)) > 0) {
    if (fwrite(buf, len, 1, fp) != 1) {
      rv = -1;
      break;
    }
  }
 
  fclose(in);
  return rv;
}
 
static int
mar_concat_product_info_block(FILE *fp,
                              struct MarItemStack *stack,
                              struct ProductInformationBlock *infoBlock)
{
  char buf[PIB_MAX_MAR_CHANNEL_ID_SIZE + PIB_MAX_PRODUCT_VERSION_SIZE];
  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_SIZE) {
    return -1;
  }
 
  /* The product version must be < 32 bytes per the spec */
  if (strlen(infoBlock->productVersion) > PIB_MAX_PRODUCT_VERSION_SIZE) {
    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_SIZE +
                  PIB_MAX_PRODUCT_VERSION_SIZE + 2;
  if (stack) {
    stack->last_offset += infoBlockSize;
  }
 
  /* Write out the product info block size */
  infoBlockSize = htonl(infoBlockSize);
  if (fwrite(&infoBlockSize,
      sizeof(infoBlockSize), 1, fp) != 1) {
    return -1;
  }
  infoBlockSize = ntohl(infoBlockSize);
 
  /* Write out the product info block ID */
  additionalBlockID = htonl(additionalBlockID);
  if (fwrite(&additionalBlockID,
      sizeof(additionalBlockID), 1, fp) != 1) {
    return -1;
  }
  additionalBlockID = ntohl(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;
}
 
int
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;
 
  rv = get_mar_file_info(path,
                         &hasSignatureBlock,
                         &numSignatures,
                         &additionalBlocks,
                         &offsetAdditionalBlocks,
                         &numAdditionalBlocks);
  if (rv) {
    fprintf(stderr, "ERROR: Could not obtain MAR information.\n");
    return -1;
  }
 
  if (hasSignatureBlock && numSignatures) {
    fprintf(stderr, "ERROR: Cannot refresh a signed MAR\n");
    return -1;
  }
 
  fp = fopen(path, "r+b");
  if (!fp) {
    fprintf(stderr, "ERROR: could not open target file: %s\n", path);
    return -1;
  }
 
  if (fseeko(fp, offsetAdditionalBlocks, SEEK_SET)) {
    fprintf(stderr, "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 */
    int64_t oldPos = ftello(fp);
 
    /* Read the additional block size */
    if (fread(&additionalBlockSize,
              sizeof(additionalBlockSize),
              1, fp) != 1) {
      fclose(fp);
      return -1;
    }
    additionalBlockSize = ntohl(additionalBlockSize);
 
    /* Read the additional block ID */
    if (fread(&additionalBlockID,
              sizeof(additionalBlockID),
              1, fp) != 1) {
      fclose(fp);
      return -1;
    }
    additionalBlockID = ntohl(additionalBlockID);
 
    if (PRODUCT_INFO_BLOCK_ID == additionalBlockID) {
      if (fseeko(fp, oldPos, SEEK_SET)) {
        fprintf(stderr, "Could not seek back to Product Information Block\n");
        fclose(fp);
        return -1;
      }
 
      if (mar_concat_product_info_block(fp, NULL, infoBlock)) {
        fprintf(stderr, "Could not concat Product Information Block\n");
        fclose(fp);
        return -1;
      }
 
      fclose(fp);
      return 0;
    } else {
      /* This is not the additional block you're looking for. Move along. */
      if (fseek(fp, additionalBlockSize, SEEK_CUR)) {
        fprintf(stderr, "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(stderr, "ERROR: Could not refresh because block does not exist\n");
  return -1;
}
 
int 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 (!fp) {
    fprintf(stderr, "ERROR: could not create target file: %s\n", dest);
    return -1;
  }
 
  if (fwrite(MAR_ID, MAR_ID_SIZE, 1, fp) != 1)
    goto failure;
  if (fwrite(&offset_to_index, sizeof(uint32_t), 1, fp) != 1)
    goto failure;
 
  stack.last_offset = MAR_ID_SIZE +
                      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) {
    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) {
    goto failure;
  }
 
  /* Write out the number of additional sections, for now just 1
     for the product info block */
  numAdditionalSections = htonl(1);
  if (fwrite(&numAdditionalSections,
             sizeof(numAdditionalSections), 1, fp) != 1) {
    goto failure;
  }
  numAdditionalSections = ntohl(numAdditionalSections);
 
  if (mar_concat_product_info_block(fp, &stack, infoBlock)) {
    goto failure;
  }
 
  for (i = 0; i < num_files; ++i) {
    if (stat(files[i], &st)) {
      fprintf(stderr, "ERROR: file not found: %s\n", files[i]);
      goto failure;
    }
 
    if (mar_push(&stack, st.st_size, st.st_mode & 0777, files[i]))
      goto failure;
 
    /* concatenate input file to archive */
    if (mar_concat_file(fp, files[i]))
      goto failure;
  }
 
  /* write out the index (prefixed with length of index) */
  size_of_index = htonl(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 assume that the MAR file
     size is less than or equal to MAX_SIZE_OF_MAR_FILE. */
  if (ftell(fp) > MAX_SIZE_OF_MAR_FILE) {
    goto failure;
  }
 
  /* write out offset to index file in network byte order */
  offset_to_index = htonl(stack.last_offset);
  if (fseek(fp, MAR_ID_SIZE, SEEK_SET))
    goto failure;
  if (fwrite(&offset_to_index, sizeof(offset_to_index), 1, fp) != 1)
    goto failure;
  offset_to_index = ntohl(stack.last_offset);
 
  sizeOfEntireMAR = ((uint64_t)stack.last_offset) +
                    stack.size_used +
                    sizeof(size_of_index);
  sizeOfEntireMAR = HOST_TO_NETWORK64(sizeOfEntireMAR);
  if (fwrite(&sizeOfEntireMAR, sizeof(sizeOfEntireMAR), 1, fp) != 1)
    goto failure;
  sizeOfEntireMAR = NETWORK_TO_HOST64(sizeOfEntireMAR);
 
  rv = 0;
failure:
  if (stack.head)
    free(stack.head);
  fclose(fp);
  if (rv)
    remove(dest);
  return rv;
}