hfsplus.c File Reference

#include "hfsplus.h"
#include "messages.h"
#include "writer.h"
#include "image.h"
#include "filesrc.h"
#include "eltorito.h"
#include "libisofs.h"
#include "util.h"
#include "ecma119.h"
#include "system_area.h"
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

Include dependency graph for hfsplus.c:

Go to the source code of this file.

Macros
#define	Libisofs_ts_debuG   yes
#define	HFSPLUS_DEFAULT_BLOCK_SIZE   2048
#define	HFSPLUS_MAX_BLOCK_SIZE   2048

Functions
uint16_t	iso_hfsplus_cichar (uint16_t x)
static int	pad_up_block (Ecma119Image *t)
static int	filesrc_block_and_size (Ecma119Image *t, IsoFileSrc *src, uint32_t *start_block, uint64_t *total_size)
static uint8_t	get_class (uint16_t v)
int	iso_get_hfsplus_name (char *input_charset, int imgid, char *name, uint16_t **result, uint32_t *result_len, uint16_t **cmp_name)
static int	set_hfsplus_name (Ecma119Image *t, char *name, HFSPlusNode *node)
static int	hfsplus_count_tree (Ecma119Image *t, IsoNode *iso)
static int	create_tree (Ecma119Image *t, IsoNode *iso, uint32_t parent_id)
	Create the low level Hfsplus tree from the high level ISO tree. More...
static int	cmp_node (const void *f1, const void *f2)
static int	hfsplus_tail_writer_compute_data_blocks (IsoImageWriter *writer)
static int	hfsplus_writer_compute_data_blocks (IsoImageWriter *writer)
static uint32_t	mac_time_offset (uint32_t t)
int	nop_writer_write_vol_desc (IsoImageWriter *writer)
static uid_t	px_get_uid (Ecma119Image *t, IsoNode *n)
static uid_t	px_get_gid (Ecma119Image *t, IsoNode *n)
static mode_t	px_get_mode (Ecma119Image *t, IsoNode *n, int isdir)
int	write_sb (Ecma119Image *t)
static int	hfsplus_writer_write_data (IsoImageWriter *writer)
static int	hfsplus_tail_writer_write_data (IsoImageWriter *writer)
static int	hfsplus_writer_free_data (IsoImageWriter *writer)
static int	nop_writer_free_data (IsoImageWriter *writer)
static int	search_mangled_pos (Ecma119Image *target, uint32_t idx, uint32_t *new_idx, uint32_t search_start, uint32_t search_end, int flag)
static void	rotate_hfs_list (Ecma119Image *target, uint32_t old_idx, uint32_t new_idx, int flag)
static int	subst_symlink_dest_comp (Ecma119Image *target, uint32_t idx, char **dest, unsigned int *dest_len, char **comp_start, char **comp_end, char *new_name, int flag)
static int	update_symlink (Ecma119Image *target, uint32_t changed_idx, char *new_name, uint32_t link_idx, int *depth, int flag)
static int	update_name_followers (Ecma119Image *target, uint32_t idx, char *new_name, uint16_t *old_name, uint16_t *old_cmp_name, uint32_t old_strlen)
static int	try_mangle (Ecma119Image *target, uint32_t idx, uint32_t prev_idx, uint32_t search_start, uint32_t search_end, uint32_t *new_idx, char *prefix, int flag)
static int	mangle_leafs (Ecma119Image *target, int flag)
void	iso_setup_hfsplus_block_size (Ecma119Image *target)
int	hfsplus_writer_create (Ecma119Image *target)
int	hfsplus_tail_writer_create (Ecma119Image *target)
int	iso_hfsplus_xinfo_func (void *data, int flag)
	The function that is used to mark struct iso_hfsplus_xinfo_data at IsoNodes and finally disposes such structs when their IsoNodes get disposed. More...
struct iso_hfsplus_xinfo_data *	iso_hfsplus_xinfo_new (int flag)
	Create an instance of struct iso_hfsplus_xinfo_new(). More...
int	iso_hfsplus_xinfo_cloner (void *old_data, void **new_data, int flag)

Macro Definition Documentation

HFSPLUS_DEFAULT_BLOCK_SIZE

#define HFSPLUS_DEFAULT_BLOCK_SIZE   2048

Definition at line 47 of file hfsplus.c.

HFSPLUS_MAX_BLOCK_SIZE

#define HFSPLUS_MAX_BLOCK_SIZE   2048

Definition at line 51 of file hfsplus.c.

Libisofs_ts_debuG

#define Libisofs_ts_debuG   yes

Definition at line 20 of file hfsplus.c.

Function Documentation

cmp_node()

static int cmp_node ( const void *  f1, const void *  f2  )

static

Definition at line 416 of file hfsplus.c.

{
  HFSPlusNode *f = (HFSPlusNode*) f1;
  HFSPlusNode *g = (HFSPlusNode*) f2;
  const uint16_t empty[1] = {0};
  const uint16_t *a, *b; 
  if (f->parent_id > g->parent_id)
    return +1;
  if (f->parent_id < g->parent_id)
    return -1;
  a = f->cmp_name;
  b = g->cmp_name;
  if (!a)
    a = empty;
  if (!b)
    b = empty;
 
  return ucscmp(a, b);
}

References hfsplus_node::cmp_name, hfsplus_node::parent_id, and ucscmp().

Referenced by hfsplus_writer_create(), mangle_leafs(), and search_mangled_pos().

create_tree()

static int create_tree ( Ecma119Image *  t, IsoNode *  iso, uint32_t  parent_id  )

static

Create the low level Hfsplus tree from the high level ISO tree.

Returns

1 success, 0 file ignored, < 0 error

Definition at line 299 of file hfsplus.c.

{
    int ret;
    uint32_t cat_id, cleaf;
    int i;
 
    if (t == NULL || iso == NULL) {
        return ISO_NULL_POINTER;
    }
 
    if (iso->hidden & LIBISO_HIDE_ON_HFSPLUS) {
        /* file will be ignored */
        return 0;
    }
 
    if (iso->type != LIBISO_FILE && iso->type != LIBISO_DIR
    && iso->type != LIBISO_SYMLINK && iso->type != LIBISO_SPECIAL)
      return 0;
 
    cat_id = t->hfsp_cat_id++;
 
    for (i = 0; i < ISO_HFSPLUS_BLESS_MAX; i++)
      if (t->hfsplus_blessed[i] == iso) {
 
#ifdef Libisofs_ts_debuG
    iso_msg_debug(t->image->id, "hfsplus bless %d to cat_id %u ('%s')",
                                i, cat_id, iso->name);
#endif /* Libisofs_ts_debuG */
 
    t->hfsp_bless_id[i] = cat_id;
      }
 
    t->hfsp_leafs[t->hfsp_curleaf].node = iso;
    t->hfsp_leafs[t->hfsp_curleaf].parent_id = parent_id;
    ret = set_hfsplus_name (t, iso->name, &t->hfsp_leafs[t->hfsp_curleaf]);
    if (ret < 0)
        return ret;
    t->hfsp_leafs[t->hfsp_curleaf].cat_id = cat_id;
    t->hfsp_leafs[t->hfsp_curleaf].unix_type = UNIX_NONE;
    t->hfsp_leafs[t->hfsp_curleaf].symlink_dest = NULL;
 
    switch (iso->type)
      {
      case LIBISO_SYMLINK:
    {
      IsoSymlink *sym = (IsoSymlink*) iso;
      t->hfsp_leafs[t->hfsp_curleaf].type = HFSPLUS_FILE;
      t->hfsp_leafs[t->hfsp_curleaf].symlink_dest = strdup(sym->dest);
      if (t->hfsp_leafs[t->hfsp_curleaf].symlink_dest == NULL)
          return ISO_OUT_OF_MEM;
      t->hfsp_leafs[t->hfsp_curleaf].unix_type = UNIX_SYMLINK;
      t->hfsp_leafs[t->hfsp_curleaf].used_size = t->hfsp_leafs[t->hfsp_curleaf].strlen * 2 + 8 + 2 + sizeof (struct hfsplus_catfile_common) + 2 * sizeof (struct hfsplus_forkdata);
      break;
    }
      case LIBISO_SPECIAL:
    t->hfsp_leafs[t->hfsp_curleaf].unix_type = UNIX_SPECIAL;
    t->hfsp_leafs[t->hfsp_curleaf].type = HFSPLUS_FILE;
    t->hfsp_leafs[t->hfsp_curleaf].used_size = t->hfsp_leafs[t->hfsp_curleaf].strlen * 2 + 8 + 2 + sizeof (struct hfsplus_catfile_common) + 2 * sizeof (struct hfsplus_forkdata);
    break;
 
      case LIBISO_FILE:
    {
      IsoFile *file = (IsoFile*) iso;
      t->hfsp_leafs[t->hfsp_curleaf].type = HFSPLUS_FILE;
      ret = iso_file_src_create(t, file, &t->hfsp_leafs[t->hfsp_curleaf].file);
      if (ret < 0) {
            return ret;
      }
      t->hfsp_leafs[t->hfsp_curleaf].used_size = t->hfsp_leafs[t->hfsp_curleaf].strlen * 2 + 8 + 2 + sizeof (struct hfsplus_catfile_common) + 2 * sizeof (struct hfsplus_forkdata);
    }
    break;
      case LIBISO_DIR:
    {
      t->hfsp_leafs[t->hfsp_curleaf].type = HFSPLUS_DIR;
      t->hfsp_leafs[t->hfsp_curleaf].used_size = t->hfsp_leafs[t->hfsp_curleaf].strlen * 2 + 8 + 2 + sizeof (struct hfsplus_catfile_common);
      break;
    }
      default:
    return ISO_ASSERT_FAILURE;
      }
    cleaf = t->hfsp_curleaf;
    t->hfsp_leafs[t->hfsp_curleaf].nchildren = 0;
    t->hfsp_curleaf++;
 
    t->hfsp_leafs[t->hfsp_curleaf].name = t->hfsp_leafs[t->hfsp_curleaf - 1].name;
    t->hfsp_leafs[t->hfsp_curleaf].cmp_name = NULL;
    t->hfsp_leafs[t->hfsp_curleaf].strlen = t->hfsp_leafs[t->hfsp_curleaf - 1].strlen;
    t->hfsp_leafs[t->hfsp_curleaf].used_size = t->hfsp_leafs[t->hfsp_curleaf].strlen * 2 + 8 + 2 + sizeof (struct hfsplus_catfile_thread);
    t->hfsp_leafs[t->hfsp_curleaf].node = iso;
    t->hfsp_leafs[t->hfsp_curleaf].type = (iso->type == LIBISO_DIR) ? HFSPLUS_DIR_THREAD : HFSPLUS_FILE_THREAD;
    t->hfsp_leafs[t->hfsp_curleaf].file = 0;
    t->hfsp_leafs[t->hfsp_curleaf].cat_id = parent_id;
    t->hfsp_leafs[t->hfsp_curleaf].parent_id = cat_id;
    t->hfsp_leafs[t->hfsp_curleaf].unix_type = UNIX_NONE;
    t->hfsp_curleaf++;
 
    if (iso->type == LIBISO_DIR)
      {
    IsoNode *pos;
    IsoDir *dir = (IsoDir*)iso;
 
    pos = dir->children;
    while (pos)
      {
        int cret;
        cret = create_tree(t, pos, cat_id);
        if (cret < 0)
          return cret;
        pos = pos->next;
        if (cret > 0)
          t->hfsp_leafs[cleaf].nchildren++;
      }
      }
    return ISO_SUCCESS;
}

References hfsplus_node::cat_id, Iso_Dir::children, hfsplus_node::cmp_name, Iso_Symlink::dest, hfsplus_node::file, ecma119_image::hfsp_bless_id, ecma119_image::hfsp_cat_id, ecma119_image::hfsp_curleaf, ecma119_image::hfsp_leafs, ecma119_image::hfsplus_blessed, HFSPLUS_DIR, HFSPLUS_DIR_THREAD, HFSPLUS_FILE, HFSPLUS_FILE_THREAD, Iso_Node::hidden, Iso_Image::id, ecma119_image::image, ISO_ASSERT_FAILURE, iso_file_src_create(), ISO_HFSPLUS_BLESS_MAX, iso_msg_debug(), ISO_NULL_POINTER, ISO_OUT_OF_MEM, ISO_SUCCESS, LIBISO_DIR, LIBISO_FILE, LIBISO_HIDE_ON_HFSPLUS, LIBISO_SPECIAL, LIBISO_SYMLINK, hfsplus_node::name, Iso_Node::name, hfsplus_node::nchildren, Iso_Node::next, hfsplus_node::node, hfsplus_node::parent_id, set_hfsplus_name(), hfsplus_node::strlen, hfsplus_node::symlink_dest, hfsplus_node::type, Iso_Node::type, hfsplus_node::unix_type, and hfsplus_node::used_size.

Referenced by hfsplus_writer_create().

filesrc_block_and_size()

static int filesrc_block_and_size ( Ecma119Image *  t, IsoFileSrc *  src, uint32_t *  start_block, uint64_t *  total_size  )

static

Definition at line 79 of file hfsplus.c.

{
    int i;
    uint32_t pos;
 
    *start_block = 0;
    *total_size = 0;
    if (src->nsections <= 0)
        return 0;
    pos = *start_block = src->sections[0].block;
    for (i = 0; i < src->nsections; i++) {
        *total_size += src->sections[i].size;
        if (pos != src->sections[i].block) {
            iso_msg_submit(t->image->id, ISO_SECT_SCATTERED, 0,
                      "File sections do not form consecutive array of blocks");
            return ISO_SECT_SCATTERED;
        }
        /* If .size is not aligned to blocks then there is a byte gap.
           No need to trace the exact byte address.
        */
        pos = src->sections[i].block + src->sections[i].size / 2048;
    }
    return 1;
}

References iso_file_section::block, Iso_Image::id, ecma119_image::image, iso_msg_submit(), ISO_SECT_SCATTERED, Iso_File_Src::nsections, Iso_File_Src::sections, and iso_file_section::size.

Referenced by hfsplus_writer_write_data().

get_class()

static uint8_t get_class ( uint16_t  v )

static

Definition at line 106 of file hfsplus.c.

{
  uint16_t s;
  uint8_t high, low;
  s = iso_ntohs (v);
  high = s >> 8;
  low = v & 0xff;
  if (!hfsplus_class_pages[high])
    return 0;
  return hfsplus_class_pages[high][low];
}

References hfsplus_class_pages, and iso_ntohs().

Referenced by iso_get_hfsplus_name().

hfsplus_count_tree()

static int hfsplus_count_tree ( Ecma119Image *  t, IsoNode *  iso  )

static

Definition at line 250 of file hfsplus.c.

{
    if (t == NULL || iso == NULL) {
        return ISO_NULL_POINTER;
    }
 
    if (iso->hidden & LIBISO_HIDE_ON_HFSPLUS) {
        /* file will be ignored */
        return 0;
    }
 
    switch (iso->type) {
    case LIBISO_SYMLINK:
    case LIBISO_SPECIAL:
    case LIBISO_FILE:
      t->hfsp_nfiles++;
      return ISO_SUCCESS;
    case LIBISO_DIR:
      t->hfsp_ndirs++;
      {
    IsoNode *pos;
    IsoDir *dir = (IsoDir*)iso;
    pos = dir->children;
    while (pos) {
      int cret;
      cret = hfsplus_count_tree(t, pos);
      if (cret < 0) {
        /* error */
        return cret;
      }
      pos = pos->next;
    }
      }
      return ISO_SUCCESS;
    case LIBISO_BOOT:
      return ISO_SUCCESS;
    default:
      /* should never happen */
      return ISO_ASSERT_FAILURE;
    }
}

References Iso_Dir::children, ecma119_image::hfsp_ndirs, ecma119_image::hfsp_nfiles, Iso_Node::hidden, ISO_ASSERT_FAILURE, ISO_NULL_POINTER, ISO_SUCCESS, LIBISO_BOOT, LIBISO_DIR, LIBISO_FILE, LIBISO_HIDE_ON_HFSPLUS, LIBISO_SPECIAL, LIBISO_SYMLINK, Iso_Node::next, and Iso_Node::type.

Referenced by hfsplus_writer_create().

hfsplus_tail_writer_compute_data_blocks()

static int hfsplus_tail_writer_compute_data_blocks ( IsoImageWriter *  writer )

static

Definition at line 438 of file hfsplus.c.

{
  Ecma119Image *t;
  uint32_t hfsp_size, hfsp_curblock, block_fac, block_size;
    
  if (writer == NULL) {
    return ISO_OUT_OF_MEM;
  }
 
  t = writer->target;
  block_size = t->opts->hfsp_block_size;
  block_fac = t->hfsp_iso_block_fac;
 
#ifdef Libisofs_ts_debuG
  iso_msg_debug(t->image->id, "hfsplus tail writer start = %.f",
                ((double) t->curblock) * 2048.0);
#endif
 
  hfsp_curblock = t->curblock * block_fac;
  hfsp_size = hfsp_curblock - t->hfsp_part_start + 1;
 
  /* We need one bit for every block. */
  /* So if we allocate x blocks we have to satisfy:
     8 * block_size * x >= total_size + x
     (8 * block_size - 1) * x >= total_size
  */
  t->hfsp_allocation_blocks = hfsp_size / (8 * block_size - 1) + 1;
  t->hfsp_allocation_file_start = hfsp_curblock;
  hfsp_curblock += t->hfsp_allocation_blocks;
 
  /* write_data() will need to pad up ISO block before superblock copy */
  t->curblock = hfsp_curblock / block_fac;
  if (hfsp_curblock % block_fac)
      t->curblock++;
  hfsp_curblock = t->curblock * block_fac;
 
  /* Superblock always occupies 2K */
  hfsp_curblock += block_fac;
  t->curblock++;
 
#ifdef Libisofs_ts_debuG
  iso_msg_debug(t->image->id, "hfsplus tail writer end = %.f",
                ((double) hfsp_curblock) * block_size);
#endif
 
  t->hfsp_total_blocks = hfsp_curblock - t->hfsp_part_start;
 
  return iso_quick_apm_entry(t->apm_req, &(t->apm_req_count),
                             t->hfsp_part_start / block_fac,
                 t->hfsp_total_blocks / block_fac +
                 !!(t->hfsp_total_blocks % block_fac),
                            "HFSPLUS_Hybrid", "Apple_HFS");
}

References ecma119_image::apm_req, ecma119_image::apm_req_count, ecma119_image::curblock, ecma119_image::hfsp_allocation_blocks, ecma119_image::hfsp_allocation_file_start, iso_write_opts::hfsp_block_size, ecma119_image::hfsp_iso_block_fac, ecma119_image::hfsp_part_start, ecma119_image::hfsp_total_blocks, Iso_Image::id, ecma119_image::image, iso_msg_debug(), ISO_OUT_OF_MEM, iso_quick_apm_entry(), ecma119_image::opts, and Iso_Image_Writer::target.

Referenced by hfsplus_tail_writer_create().

hfsplus_tail_writer_create()

int hfsplus_tail_writer_create

(

Ecma119Image *

target

)

Definition at line 1817 of file hfsplus.c.

{
    IsoImageWriter *writer;
 
    writer = calloc(1, sizeof(IsoImageWriter));
    if (writer == NULL) {
        return ISO_OUT_OF_MEM;
    }
 
    writer->compute_data_blocks = hfsplus_tail_writer_compute_data_blocks;
    writer->write_vol_desc = nop_writer_write_vol_desc;
    writer->write_data = hfsplus_tail_writer_write_data;
    writer->free_data = nop_writer_free_data;
    writer->data = NULL;
    writer->target = target;
 
    /* add this writer to image */
    target->writers[target->nwriters++] = writer;
 
    return ISO_SUCCESS;
}

References Iso_Image_Writer::compute_data_blocks, Iso_Image_Writer::data, Iso_Image_Writer::free_data, hfsplus_tail_writer_compute_data_blocks(), hfsplus_tail_writer_write_data(), ISO_OUT_OF_MEM, ISO_SUCCESS, nop_writer_free_data(), nop_writer_write_vol_desc(), ecma119_image::nwriters, Iso_Image_Writer::target, Iso_Image_Writer::write_data, Iso_Image_Writer::write_vol_desc, and ecma119_image::writers.

Referenced by ecma119_image_new().

hfsplus_tail_writer_write_data()

static int hfsplus_tail_writer_write_data ( IsoImageWriter *  writer )

static

Definition at line 1042 of file hfsplus.c.

{
    int ret;
    static char buffer[2 * HFSPLUS_MAX_BLOCK_SIZE];
    uint32_t complete_blocks, remaining_blocks, block_size;
    int over;
    Ecma119Image *t;
 
    if (writer == NULL) {
        return ISO_NULL_POINTER;
    }
 
    t = writer->target;
    block_size = t->opts->hfsp_block_size;
 
#ifdef Libisofs_ts_debuG
    iso_msg_debug(t->image->id, "hfsplus tail writer writes at = %.f",
                  (double) t->bytes_written);
#endif
 
    memset (buffer, -1, sizeof (buffer));
    complete_blocks = (t->hfsp_allocation_size - 1) / block_size;
    remaining_blocks = t->hfsp_allocation_blocks - complete_blocks;
 
    while (complete_blocks--)
      {
    ret = iso_write(t, buffer, block_size);
    if (ret < 0)
      return ret;
      }
    over = (t->hfsp_allocation_size - 1) % block_size;
    if (over)
      {
    memset (buffer + over, 0, sizeof (buffer) - over);
    buffer[over] = 0xff00 >> (t->hfsp_total_blocks % 8);
    ret = iso_write(t, buffer, block_size);
    if (ret < 0)
      return ret;
    remaining_blocks--;
      }
    memset (buffer, 0, sizeof (buffer));
    /* When we have both FAT and HFS+ we may to overestimate needed blocks a bit.  */
    while (remaining_blocks--)
      {
    ret = iso_write(t, buffer, block_size);
    if (ret < 0)
      return ret;
      }
 
    ret = pad_up_block(t);
    if (ret < 0)
    return ret;
    iso_msg_debug(t->image->id, "%d written", (int) t->bytes_written);
 
    ret = write_sb (t);
 
#ifdef Libisofs_ts_debuG
    iso_msg_debug(t->image->id, "hfsplus tail writer ends at = %.f",
                  (double) t->bytes_written);
#endif
 
    return ret;
}

References ecma119_image::bytes_written, ecma119_image::hfsp_allocation_blocks, ecma119_image::hfsp_allocation_size, iso_write_opts::hfsp_block_size, ecma119_image::hfsp_total_blocks, HFSPLUS_MAX_BLOCK_SIZE, Iso_Image::id, ecma119_image::image, iso_msg_debug(), ISO_NULL_POINTER, iso_write(), ecma119_image::opts, pad_up_block(), Iso_Image_Writer::target, and write_sb().

Referenced by hfsplus_tail_writer_create().

hfsplus_writer_compute_data_blocks()

static int hfsplus_writer_compute_data_blocks ( IsoImageWriter *  writer )

static

Definition at line 494 of file hfsplus.c.

{
    Ecma119Image *t;
    uint32_t i, hfsp_curblock;
    uint32_t block_fac, block_size;
 
    if (writer == NULL) {
        return ISO_OUT_OF_MEM;
    }
 
    t = writer->target;
    block_size = t->opts->hfsp_block_size;
    block_fac = t->hfsp_iso_block_fac;
 
    iso_msg_debug(t->image->id, "(b) curblock=%d, nodes =%d", t->curblock, t->hfsp_nnodes);
    t->hfsp_part_start = t->curblock * block_fac;
 
    hfsp_curblock = t->curblock * block_fac;
 
    /* Superblock always occupies 2K */
    hfsp_curblock += block_fac;
 
    t->hfsp_catalog_file_start = hfsp_curblock;
 
/* 
    hfsp_curblock += (t->hfsp_nnodes * t->hfsp_cat_node_size + block_size - 1) / block_size;
*/
    hfsp_curblock += 2 * t->hfsp_nnodes;
 
    t->hfsp_extent_file_start = hfsp_curblock;
    hfsp_curblock++;
 
    iso_msg_debug(t->image->id, "(d) hfsp_curblock=%d, nodes =%d", hfsp_curblock, t->hfsp_nnodes);
 
    for (i = 0; i < t->hfsp_nleafs; i++)
      if (t->hfsp_leafs[i].unix_type == UNIX_SYMLINK)
    {
          t->hfsp_leafs[i].symlink_block = hfsp_curblock;
          hfsp_curblock += (strlen(t->hfsp_leafs[i].symlink_dest) +
                            block_size - 1) / block_size;
    }
 
    t->curblock = hfsp_curblock / block_fac;
    if (hfsp_curblock % block_fac)
        t->curblock++;
 
    iso_msg_debug(t->image->id, "(a) curblock=%d, nodes =%d", t->curblock, t->hfsp_nnodes);
 
    return ISO_SUCCESS;
}

References ecma119_image::curblock, iso_write_opts::hfsp_block_size, ecma119_image::hfsp_catalog_file_start, ecma119_image::hfsp_extent_file_start, ecma119_image::hfsp_iso_block_fac, ecma119_image::hfsp_leafs, ecma119_image::hfsp_nleafs, ecma119_image::hfsp_nnodes, ecma119_image::hfsp_part_start, Iso_Image::id, ecma119_image::image, iso_msg_debug(), ISO_OUT_OF_MEM, ISO_SUCCESS, ecma119_image::opts, hfsplus_node::symlink_block, hfsplus_node::symlink_dest, Iso_Image_Writer::target, and hfsplus_node::unix_type.

Referenced by hfsplus_writer_create().

hfsplus_writer_create()

int hfsplus_writer_create

(

Ecma119Image *

target

)

Definition at line 1590 of file hfsplus.c.

{
    int ret;
    IsoImageWriter *writer = NULL;
    int max_levels;
    int level = 0;
    IsoNode *pos;
    IsoDir *dir;
    int i;
    uint32_t cat_node_size;
 
    writer = calloc(1, sizeof(IsoImageWriter));
    if (writer == NULL) {
        ret = ISO_OUT_OF_MEM;
        goto ex;
    }
 
    make_hfsplus_decompose_pages();
    make_hfsplus_class_pages();
 
    iso_setup_hfsplus_block_size(target);
    cat_node_size = target->hfsp_cat_node_size;
 
    writer->compute_data_blocks = hfsplus_writer_compute_data_blocks;
    writer->write_vol_desc = nop_writer_write_vol_desc;
    writer->write_data = hfsplus_writer_write_data;
    writer->free_data = hfsplus_writer_free_data;
    writer->data = NULL;
    writer->target = target;
 
    iso_msg_debug(target->image->id, "Creating HFS+ tree...");
    target->hfsp_nfiles = 0;
    target->hfsp_ndirs = 0;
    target->hfsp_cat_id = 16;
    ret = hfsplus_count_tree(target, (IsoNode*)target->image->root);
    if (ret < 0)
        goto ex;
 
    for (i = 0; i < ISO_HFSPLUS_BLESS_MAX; i++)
      target->hfsp_bless_id[i] = 0;
 
    target->hfsp_nleafs = 2 * (target->hfsp_nfiles + target->hfsp_ndirs);
    target->hfsp_curleaf = 0;
 
    target->hfsp_leafs = calloc (target->hfsp_nleafs, sizeof (target->hfsp_leafs[0]));
    if (target->hfsp_leafs == NULL) {
        ret = ISO_OUT_OF_MEM;
        goto ex;
    }
    ret = set_hfsplus_name (target, target->image->volume_id,
                            &target->hfsp_leafs[target->hfsp_curleaf]);
    if (ret < 0)
        goto ex;
    target->hfsp_leafs[target->hfsp_curleaf].node = (IsoNode *) target->image->root;
    target->hfsp_leafs[target->hfsp_curleaf].used_size = target->hfsp_leafs[target->hfsp_curleaf].strlen * 2 + 8 + 2 + sizeof (struct hfsplus_catfile_common);
 
    target->hfsp_leafs[target->hfsp_curleaf].type = HFSPLUS_DIR;
    target->hfsp_leafs[target->hfsp_curleaf].file = 0;
    target->hfsp_leafs[target->hfsp_curleaf].cat_id = 2;
    target->hfsp_leafs[target->hfsp_curleaf].parent_id = 1;
    target->hfsp_leafs[target->hfsp_curleaf].nchildren = 0;
    target->hfsp_leafs[target->hfsp_curleaf].unix_type = UNIX_NONE;
    target->hfsp_curleaf++;
 
    target->hfsp_leafs[target->hfsp_curleaf].name = target->hfsp_leafs[target->hfsp_curleaf - 1].name;
    target->hfsp_leafs[target->hfsp_curleaf].cmp_name = 0;
    target->hfsp_leafs[target->hfsp_curleaf].strlen = target->hfsp_leafs[target->hfsp_curleaf - 1].strlen;
    target->hfsp_leafs[target->hfsp_curleaf].used_size = target->hfsp_leafs[target->hfsp_curleaf].strlen * 2 + 8 + 2 + sizeof (struct hfsplus_catfile_thread);
    target->hfsp_leafs[target->hfsp_curleaf].node = (IsoNode *) target->image->root;
    target->hfsp_leafs[target->hfsp_curleaf].type = HFSPLUS_DIR_THREAD;
    target->hfsp_leafs[target->hfsp_curleaf].file = 0;
    target->hfsp_leafs[target->hfsp_curleaf].cat_id = 1;
    target->hfsp_leafs[target->hfsp_curleaf].parent_id = 2;
    target->hfsp_leafs[target->hfsp_curleaf].unix_type = UNIX_NONE;
    target->hfsp_curleaf++;
 
    dir = (IsoDir*)target->image->root;
 
    pos = dir->children;
    while (pos)
      {
    int cret;
    cret = create_tree(target, pos, 2);
    if (cret < 0) {
        ret = cret;
        goto ex;
    }
    pos = pos->next;
    if (cret > 0)
        target->hfsp_leafs[0].nchildren++;
      }
 
    qsort(target->hfsp_leafs, target->hfsp_nleafs,
          sizeof(*target->hfsp_leafs), cmp_node);
 
    ret = mangle_leafs(target, 0);
    if (ret < 0)
        goto ex;
 
    for (max_levels = 0; target->hfsp_nleafs >> max_levels; max_levels++);
    max_levels += 2;
    target->hfsp_levels = calloc (max_levels, sizeof (target->hfsp_levels[0]));
    if (target->hfsp_levels == NULL) {
    ret = ISO_OUT_OF_MEM;
    goto ex;
    }
 
    target->hfsp_nnodes = 1;
    {
      uint32_t last_start = 0;
      uint32_t i;
      unsigned bytes_rem = cat_node_size - sizeof (struct hfsplus_btnode) - 2;
 
      target->hfsp_levels[level].nodes = calloc ((target->hfsp_nleafs + 1),  sizeof (target->hfsp_levels[level].nodes[0]));
      if (!target->hfsp_levels[level].nodes) {
      ret = ISO_OUT_OF_MEM;
      goto ex;
      }
      target->hfsp_levels[level].level_size = 0;  
      for (i = 0; i < target->hfsp_nleafs; i++)
    {
      if (bytes_rem < target->hfsp_leafs[i].used_size)
        {
          target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].start = last_start;
          target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].cnt = i - last_start;
          if (target->hfsp_leafs[last_start].cmp_name)
        {
          target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].strlen = target->hfsp_leafs[last_start].strlen;
          target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].str = target->hfsp_leafs[last_start].name;
        }
          else
        {
          target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].strlen = 0;
          target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].str = NULL;
        }
          target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].parent_id = target->hfsp_leafs[last_start].parent_id;
          target->hfsp_levels[level].level_size++;
          last_start = i;
          bytes_rem = cat_node_size - sizeof (struct hfsplus_btnode) - 2;
        }
      bytes_rem -= target->hfsp_leafs[i].used_size;
    }
 
      target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].start = last_start;
      target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].cnt = i - last_start;
      if (target->hfsp_leafs[last_start].cmp_name)
    {
      target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].strlen = target->hfsp_leafs[last_start].strlen;
      target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].str = target->hfsp_leafs[last_start].name;
    }
      else
    {
      target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].strlen = 0;
      target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].str = NULL;
    }
      target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].parent_id = target->hfsp_leafs[last_start].parent_id;
      target->hfsp_levels[level].level_size++;
      target->hfsp_nnodes += target->hfsp_levels[level].level_size;
    }
 
    while (target->hfsp_levels[level].level_size > 1)
      {
    uint32_t last_start = 0;
    uint32_t i;
    uint32_t last_size;
    unsigned bytes_rem = cat_node_size - sizeof (struct hfsplus_btnode) - 2;
 
    last_size = target->hfsp_levels[level].level_size;
 
    level++;
 
    target->hfsp_levels[level].nodes = calloc (((last_size + 1) / 2),  sizeof (target->hfsp_levels[level].nodes[0]));
    if (!target->hfsp_levels[level].nodes) {
        ret = ISO_OUT_OF_MEM;
        goto ex;
        }
    
    target->hfsp_levels[level].level_size = 0;  
 
    for (i = 0; i < last_size; i++)
      {
        uint32_t used_size;
        used_size = target->hfsp_levels[level - 1].nodes[i].strlen * 2 + 14;
        if (bytes_rem < used_size)
        {
          target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].start = last_start;
          target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].cnt = i - last_start;
          target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].strlen = target->hfsp_levels[level - 1].nodes[last_start].strlen;
          target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].str = target->hfsp_levels[level - 1].nodes[last_start].str;
          target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].parent_id = target->hfsp_levels[level - 1].nodes[last_start].parent_id;
          target->hfsp_levels[level].level_size++;
          last_start = i;
          bytes_rem = cat_node_size - sizeof (struct hfsplus_btnode) - 2;
        }
      bytes_rem -= used_size;
    }
 
    target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].start = last_start;
    target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].cnt = i - last_start;
    target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].strlen = target->hfsp_levels[level - 1].nodes[last_start].strlen;
    target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].str = target->hfsp_levels[level - 1].nodes[last_start].str;
    target->hfsp_levels[level].nodes[target->hfsp_levels[level].level_size].parent_id = target->hfsp_levels[level - 1].nodes[last_start].parent_id;
    target->hfsp_levels[level].level_size++;
    target->hfsp_nnodes += target->hfsp_levels[level].level_size;
      }
 
    target->hfsp_nlevels = level + 1;
 
    if (target->hfsp_nnodes > (cat_node_size - 0x100) * 8)
      {
    iso_msg_submit(target->image->id, ISO_HFSPLUS_TOO_MANY_FILES, 0,
            "HFS+ map nodes aren't implemented");
    ret = ISO_HFSPLUS_TOO_MANY_FILES;
    goto ex;
      }
 
    /* add this writer to image */
    target->writers[target->nwriters++] = writer;
    writer = NULL;
 
    ret = ISO_SUCCESS;
ex:;
    if (writer != NULL)
        free(writer);
    return ret;
}

References hfsplus_node::cat_id, Iso_Dir::children, hfsplus_node::cmp_name, cmp_node(), hfsplus_btree_node::cnt, Iso_Image_Writer::compute_data_blocks, create_tree(), Iso_Image_Writer::data, hfsplus_node::file, Iso_Image_Writer::free_data, ecma119_image::hfsp_bless_id, ecma119_image::hfsp_cat_id, ecma119_image::hfsp_cat_node_size, ecma119_image::hfsp_curleaf, ecma119_image::hfsp_leafs, ecma119_image::hfsp_levels, ecma119_image::hfsp_ndirs, ecma119_image::hfsp_nfiles, ecma119_image::hfsp_nleafs, ecma119_image::hfsp_nlevels, ecma119_image::hfsp_nnodes, hfsplus_count_tree(), HFSPLUS_DIR, HFSPLUS_DIR_THREAD, hfsplus_writer_compute_data_blocks(), hfsplus_writer_free_data(), hfsplus_writer_write_data(), Iso_Image::id, ecma119_image::image, ISO_HFSPLUS_BLESS_MAX, ISO_HFSPLUS_TOO_MANY_FILES, iso_msg_debug(), iso_msg_submit(), ISO_OUT_OF_MEM, iso_setup_hfsplus_block_size(), ISO_SUCCESS, hfsplus_btree_level::level_size, make_hfsplus_class_pages(), make_hfsplus_decompose_pages(), mangle_leafs(), hfsplus_node::name, hfsplus_node::nchildren, Iso_Node::next, hfsplus_node::node, hfsplus_btree_level::nodes, nop_writer_write_vol_desc(), ecma119_image::nwriters, hfsplus_btree_node::parent_id, hfsplus_node::parent_id, Iso_Image::root, set_hfsplus_name(), hfsplus_btree_node::start, hfsplus_btree_node::str, hfsplus_btree_node::strlen, hfsplus_node::strlen, Iso_Image_Writer::target, hfsplus_node::type, hfsplus_node::unix_type, hfsplus_node::used_size, Iso_Image::volume_id, Iso_Image_Writer::write_data, Iso_Image_Writer::write_vol_desc, and ecma119_image::writers.

Referenced by ecma119_image_new().

hfsplus_writer_free_data()

static int hfsplus_writer_free_data ( IsoImageWriter *  writer )

static

Definition at line 1107 of file hfsplus.c.

{
    /* free the Hfsplus tree */
    Ecma119Image *t = writer->target;
    uint32_t i;
    for (i = 0; i < t->hfsp_curleaf; i++)
      if (t->hfsp_leafs[i].type != HFSPLUS_FILE_THREAD
      && t->hfsp_leafs[i].type != HFSPLUS_DIR_THREAD)
    {
      free (t->hfsp_leafs[i].name);
      free (t->hfsp_leafs[i].cmp_name);
      if (t->hfsp_leafs[i].symlink_dest != NULL)
          free (t->hfsp_leafs[i].symlink_dest);
    }
    free(t->hfsp_leafs);
    for (i = 0; i < t->hfsp_nlevels; i++)
      free (t->hfsp_levels[i].nodes);
    free(t->hfsp_levels);
    return ISO_SUCCESS;
}

References hfsplus_node::cmp_name, ecma119_image::hfsp_curleaf, ecma119_image::hfsp_leafs, ecma119_image::hfsp_levels, ecma119_image::hfsp_nlevels, HFSPLUS_DIR_THREAD, HFSPLUS_FILE_THREAD, ISO_SUCCESS, hfsplus_node::name, hfsplus_btree_level::nodes, hfsplus_node::symlink_dest, Iso_Image_Writer::target, and hfsplus_node::type.

Referenced by hfsplus_writer_create().

hfsplus_writer_write_data()

static int hfsplus_writer_write_data ( IsoImageWriter *  writer )

static

Definition at line 673 of file hfsplus.c.

{
    int ret;
    static char buffer[2 * HFSPLUS_MAX_BLOCK_SIZE];
    Ecma119Image *t;
    struct hfsplus_btnode *node_head;
    struct hfsplus_btheader *tree_head;
    int level;
    uint32_t curpos = 1, i, block_fac, cat_node_size, block_size;
 
    if (writer == NULL) {
        return ISO_NULL_POINTER;
    }
 
    t = writer->target;
    block_size = t->opts->hfsp_block_size;
    block_fac = t->hfsp_iso_block_fac;
    cat_node_size = t->hfsp_cat_node_size;
 
    iso_msg_debug(t->image->id, "(b) %d written", (int) t->bytes_written / 0x800);
 
    ret = write_sb (t);
    if (ret < 0)
      return ret;
 
    iso_msg_debug(t->image->id, "(c) %d written", (int) t->bytes_written / 0x800);
 
    iso_msg_debug(t->image->id, "real catalog_file_start = %d\n", (int)t->bytes_written / 2048);
 
    memset (buffer, 0, sizeof (buffer));
    node_head = (struct hfsplus_btnode *) buffer;
    node_head->type = 1;
    iso_msb ((uint8_t *) &node_head->count, 3, 2);
    tree_head = (struct hfsplus_btheader *) (node_head + 1);
    iso_msb ((uint8_t *) &tree_head->depth, t->hfsp_nlevels, 2);
    iso_msb ((uint8_t *) &tree_head->root, 1, 4);
    iso_msb ((uint8_t *) &tree_head->leaf_records, t->hfsp_nleafs, 4);
    iso_msb ((uint8_t *) &tree_head->first_leaf_node, t->hfsp_nnodes - t->hfsp_levels[0].level_size, 4);
    iso_msb ((uint8_t *) &tree_head->last_leaf_node, t->hfsp_nnodes - 1, 4);
    iso_msb ((uint8_t *) &tree_head->nodesize, cat_node_size, 2);
    iso_msb ((uint8_t *) &tree_head->keysize, 6 + 2 * LIBISO_HFSPLUS_NAME_MAX, 2);
    iso_msb ((uint8_t *) &tree_head->total_nodes, t->hfsp_nnodes, 4);
    iso_msb ((uint8_t *) &tree_head->free_nodes, 0, 4);
    iso_msb ((uint8_t *) &tree_head->clump_size, cat_node_size, 4);
    tree_head->key_compare = 0xcf;
    iso_msb ((uint8_t *) &tree_head->attributes, 2 | 4, 4);
    memset (buffer + 0xf8, -1, t->hfsp_nnodes / 8);
    buffer[0xf8 + (t->hfsp_nnodes / 8)] = 0xff00 >> (t->hfsp_nnodes % 8);
 
    buffer[cat_node_size - 1] = sizeof (*node_head);
    buffer[cat_node_size - 3] = sizeof (*node_head) + sizeof (*tree_head);
    buffer[cat_node_size - 5] = (char) 0xf8;
    buffer[cat_node_size - 7] = (char) ((cat_node_size - 8) & 0xff);
    buffer[cat_node_size - 8] = (cat_node_size - 8) >> 8;
 
#ifdef Libisofs_hfsplus_verbose_debuG
    iso_msg_debug(t->image->id, "Write\n");
#endif
 
    ret = iso_write(t, buffer, cat_node_size);
    if (ret < 0)
        return ret;
 
    for (level = t->hfsp_nlevels - 1; level > 0; level--)
      {
    uint32_t i;
    uint32_t next_lev = curpos + t->hfsp_levels[level].level_size;
    for (i = 0; i < t->hfsp_levels[level].level_size; i++)
      {
        uint32_t curoff;
        uint32_t j;
        uint32_t curnode = t->hfsp_levels[level].nodes[i].start;
        memset (buffer, 0, sizeof (buffer));
        node_head = (struct hfsplus_btnode *) buffer;
        if (i != t->hfsp_levels[level].level_size - 1)
          iso_msb ((uint8_t *) &node_head->next, curpos + i + 1, 4);
        if (i != 0)
          iso_msb ((uint8_t *) &node_head->prev, curpos + i - 1, 4);
        node_head->type = 0;
        node_head->height = level + 1;
        iso_msb ((uint8_t *) &node_head->count, t->hfsp_levels[level].nodes[i].cnt, 2);
        curoff = sizeof (struct hfsplus_btnode);
        for (j = 0; j < t->hfsp_levels[level].nodes[i].cnt; j++)
          {
        iso_msb ((uint8_t *) buffer + cat_node_size - j * 2 - 2, curoff, 2);
 
        iso_msb ((uint8_t *) buffer + curoff, 2 * t->hfsp_levels[level - 1].nodes[curnode].strlen + 6, 2);
        iso_msb ((uint8_t *) buffer + curoff + 2, t->hfsp_levels[level - 1].nodes[curnode].parent_id, 4);
        iso_msb ((uint8_t *) buffer + curoff + 6, t->hfsp_levels[level - 1].nodes[curnode].strlen, 2);
        curoff += 8;
        memcpy ((uint8_t *) buffer + curoff, t->hfsp_levels[level - 1].nodes[curnode].str, 2 * t->hfsp_levels[level - 1].nodes[curnode].strlen);
        curoff += 2 * t->hfsp_levels[level - 1].nodes[curnode].strlen;
        iso_msb ((uint8_t *) buffer + curoff, next_lev + curnode, 4);
        curoff += 4;
        curnode++;
          }
        iso_msb ((uint8_t *) buffer +  cat_node_size - j * 2 - 2, curoff, 2);
 
#ifdef Libisofs_hfsplus_verbose_debuG
        iso_msg_debug(t->image->id, "Write\n");
#endif
 
        ret = iso_write(t, buffer, cat_node_size);
 
        if (ret < 0)
          return ret;
      }
    curpos = next_lev;
      }
 
    {
      uint32_t i;
      uint32_t next_lev = curpos + t->hfsp_levels[level].level_size;
      for (i = 0; i < t->hfsp_levels[level].level_size; i++)
    {
      uint32_t curoff;
      uint32_t j;
      uint32_t curnode = t->hfsp_levels[level].nodes[i].start;
      memset (buffer, 0, sizeof (buffer));
      node_head = (struct hfsplus_btnode *) buffer;
      if (i != t->hfsp_levels[level].level_size - 1)
        iso_msb ((uint8_t *) &node_head->next, curpos + i + 1, 4);
      if (i != 0)
        iso_msb ((uint8_t *) &node_head->prev, curpos + i - 1, 4);
      node_head->type = -1;
      node_head->height = level + 1;
      iso_msb ((uint8_t *) &node_head->count, t->hfsp_levels[level].nodes[i].cnt, 2);
      curoff = sizeof (struct hfsplus_btnode);
      for (j = 0; j < t->hfsp_levels[level].nodes[i].cnt; j++)
        {
          iso_msb ((uint8_t *) buffer + cat_node_size - j * 2 - 2, curoff, 2);
 
#ifdef Libisofs_hfsplus_verbose_debuG
 
          if (t->hfsp_leafs[curnode].node->name == NULL)
        {
          iso_msg_debug(t->image->id, "%d out of %d",
                (int) curnode, t->hfsp_nleafs);
        }
          else
        {
          iso_msg_debug(t->image->id, "%d out of %d, %s",
                (int) curnode, t->hfsp_nleafs,
                t->hfsp_leafs[curnode].node->name);
        }
 
#endif /* Libisofs_hfsplus_verbose_debuG */
 
          switch (t->hfsp_leafs[curnode].type)
        {
        case HFSPLUS_FILE_THREAD:
        case HFSPLUS_DIR_THREAD:
          {
            struct hfsplus_catfile_thread *thread;
            iso_msb ((uint8_t *) buffer + curoff, 6, 2);
            iso_msb ((uint8_t *) buffer + curoff + 2, t->hfsp_leafs[curnode].parent_id, 4);
            iso_msb ((uint8_t *) buffer + curoff + 6, 0, 2);
            curoff += 8;
            thread = (struct hfsplus_catfile_thread *) (buffer + curoff);
            ((uint8_t *) &thread->type)[1] = t->hfsp_leafs[curnode].type;
            iso_msb ((uint8_t *) &thread->parentid, t->hfsp_leafs[curnode].cat_id, 4);
            iso_msb ((uint8_t *) &thread->namelen, t->hfsp_leafs[curnode].strlen, 2);
            curoff += sizeof (*thread);
            memcpy (buffer + curoff, t->hfsp_leafs[curnode].name, t->hfsp_leafs[curnode].strlen * 2);
            curoff += t->hfsp_leafs[curnode].strlen * 2;
            break;
          }
        case HFSPLUS_FILE:
        case HFSPLUS_DIR:
          {
            struct hfsplus_catfile_common *common;
            struct hfsplus_forkdata *data_fork;
            iso_msb ((uint8_t *) buffer + curoff, 6 + 2 * t->hfsp_leafs[curnode].strlen, 2);
            iso_msb ((uint8_t *) buffer + curoff + 2, t->hfsp_leafs[curnode].parent_id, 4);
            iso_msb ((uint8_t *) buffer + curoff + 6, t->hfsp_leafs[curnode].strlen, 2);
            curoff += 8;
            memcpy (buffer + curoff, t->hfsp_leafs[curnode].name, t->hfsp_leafs[curnode].strlen * 2);
            curoff += t->hfsp_leafs[curnode].strlen * 2;
 
            common = (struct hfsplus_catfile_common *) (buffer + curoff);
            ((uint8_t *) &common->type)[1] = t->hfsp_leafs[curnode].type;
            iso_msb ((uint8_t *) &common->valence, t->hfsp_leafs[curnode].nchildren, 4);
            iso_msb ((uint8_t *) &common->fileid, t->hfsp_leafs[curnode].cat_id, 4);
            common->ctime = mac_time_offset(t->hfsp_leafs[curnode].node->ctime);
            common->mtime = mac_time_offset(t->hfsp_leafs[curnode].node->mtime);
            /* FIXME: distinguish attr_mtime and mtime.  */
            common->attr_mtime = mac_time_offset(t->hfsp_leafs[curnode].node->mtime);
            common->atime = mac_time_offset(t->hfsp_leafs[curnode].node->atime);
            iso_msb ((uint8_t *) &common->uid, px_get_uid (t, t->hfsp_leafs[curnode].node), 4);
            iso_msb ((uint8_t *) &common->gid, px_get_gid (t, t->hfsp_leafs[curnode].node), 4);
            iso_msb ((uint8_t *) &common->mode, px_get_mode (t, t->hfsp_leafs[curnode].node, (t->hfsp_leafs[curnode].type == HFSPLUS_DIR)), 2);
 
            /*
              FIXME:
              uint8_t user_flags;
              uint8_t group_flags;
 
              finder info
            */
            if (t->hfsp_leafs[curnode].type == HFSPLUS_FILE)
              {
            if (t->hfsp_leafs[curnode].unix_type == UNIX_SYMLINK)
              {
                memcpy (common->file_type, "slnk", 4);
                memcpy (common->file_creator, "rhap", 4);
              }
            else
              {
                struct iso_hfsplus_xinfo_data *xinfo;
                ret = iso_node_get_xinfo(t->hfsp_leafs[curnode].node,
                             iso_hfsplus_xinfo_func,
                             (void *) &xinfo);
                if (ret > 0)
                  {
                memcpy (common->file_type, xinfo->type_code,
                    4);
                memcpy (common->file_creator,
                    xinfo->creator_code, 4);
 
#ifdef Libisofs_ts_debuG
{
char crtp[14];
 
crtp[0] = '\'';
memcpy(crtp+1, xinfo->creator_code, 4);
strcpy(crtp + 5, "','");
memcpy(crtp + 8, xinfo->type_code, 4);
crtp[12] = '\'';
crtp[13]= 0;
iso_msg_debug(t->image->id,
        "hfsplus creator,type %s to '%s/%s'",
        crtp, ((IsoNode *) t->hfsp_leafs[curnode].node->parent)->name,
        t->hfsp_leafs[curnode].node->name);
}
#endif /* Libisofs_ts_debuG */
 
                  }
                else if (ret < 0)
                  return ret;
                else 
                  {
                memcpy (common->file_type, "????", 4);
                memcpy (common->file_creator, "????", 4);
                  }
              }
 
            if (t->hfsp_leafs[curnode].unix_type == UNIX_SPECIAL
                && (S_ISBLK(t->hfsp_leafs[curnode].node->mode)
                || S_ISCHR(t->hfsp_leafs[curnode].node->mode)))
              iso_msb ((uint8_t *) &common->special,
                   (((IsoSpecial*) t->hfsp_leafs[curnode].node)->dev & 0xffffffff),
                   4);
 
            iso_msb ((uint8_t *) &common->flags, 2, 2);
              }
            else if (t->hfsp_leafs[curnode].type == HFSPLUS_DIR)
              {
            iso_msb ((uint8_t *) &common->flags, 0, 2);
              }
            curoff += sizeof (*common);
            if (t->hfsp_leafs[curnode].type == HFSPLUS_FILE)
              {
            uint64_t sz;
            uint32_t blk;
            data_fork = (struct hfsplus_forkdata *) (buffer + curoff);
 
            if (t->hfsp_leafs[curnode].unix_type == UNIX_SYMLINK)
              {
                blk = t->hfsp_leafs[curnode].symlink_block;
                sz = strlen(t->hfsp_leafs[curnode].symlink_dest);
              }
            else if (t->hfsp_leafs[curnode].unix_type == UNIX_SPECIAL)
              {
                blk = 0;
                sz = 0;
              }
            else
              {
                ret = filesrc_block_and_size(t,
                             t->hfsp_leafs[curnode].file,
                             &blk, &sz);
                if (ret <= 0)
                  return ret;
                blk *= block_fac;
              }
            if (sz == 0)
              blk = t->hfsp_part_start;
            iso_msb ((uint8_t *) &data_fork->size, sz >> 32, 4);
            iso_msb ((uint8_t *) &data_fork->size + 4, sz, 4);
            iso_msb ((uint8_t *) &data_fork->clumpsize, block_size, 4);
            iso_msb ((uint8_t *) &data_fork->blocks, (sz + block_size - 1) / block_size, 4);
            iso_msb ((uint8_t *) &data_fork->extents[0].start, blk - t->hfsp_part_start, 4);
            iso_msb ((uint8_t *) &data_fork->extents[0].count, (sz + block_size - 1) / block_size, 4);
            
            curoff += sizeof (*data_fork) * 2;
            /* FIXME: resource fork */
              }
            break;
          }
        }
          curnode++;
        }
      iso_msb ((uint8_t *) buffer + cat_node_size - j * 2 - 2, curoff, 2);
 
#ifdef Libisofs_hfsplus_verbose_debuG
      iso_msg_debug(t->image->id, "Write\n");
#endif
 
      ret = iso_write(t, buffer, cat_node_size);
      if (ret < 0)
        return ret;
    }
    curpos = next_lev;
    }
    memset (buffer, 0, sizeof (buffer));
 
    iso_msg_debug(t->image->id, "real extent_file_start = %d\n", (int)t->bytes_written / 2048);
 
    node_head = (struct hfsplus_btnode *) buffer;
    node_head->type = 1;
    iso_msb ((uint8_t *) &node_head->count, 3, 2);
    tree_head = (struct hfsplus_btheader *) (node_head + 1);
    iso_msb ((uint8_t *) &tree_head->nodesize, block_size, 2);
    iso_msb ((uint8_t *) &tree_head->keysize, 10, 2);
    iso_msb ((uint8_t *) &tree_head->total_nodes, 1, 4);
    iso_msb ((uint8_t *) &tree_head->free_nodes, 0, 4);
    iso_msb ((uint8_t *) &tree_head->clump_size, block_size, 4);
    iso_msb ((uint8_t *) &tree_head->attributes, 2, 4);
    buffer[0xf8] = (char) 0x80;
 
    buffer[block_size - 1] = sizeof (*node_head);
    buffer[block_size - 3] = sizeof (*node_head) + sizeof (*tree_head);
    buffer[block_size - 5] = (char) 0xf8;
    buffer[block_size - 7] = (char) ((block_size - 8) & 0xff);
    buffer[block_size - 8] = (block_size - 8) >> 8;
 
    ret = iso_write(t, buffer, block_size);
    if (ret < 0)
        return ret;
 
    iso_msg_debug(t->image->id, "(d) %d written", (int) t->bytes_written / 0x800);
    memset (buffer, 0, sizeof (buffer));
    for (i = 0; i < t->hfsp_nleafs; i++)
      if (t->hfsp_leafs[i].unix_type == UNIX_SYMLINK)
    {
      int overhead;
 
      ret = iso_write(t, t->hfsp_leafs[i].symlink_dest,
                          strlen(t->hfsp_leafs[i].symlink_dest));
      if (ret < 0)
        return ret;
      overhead = strlen(t->hfsp_leafs[i].symlink_dest) % block_size;
      if (overhead)
        overhead = block_size - overhead;
      ret = iso_write(t, buffer, overhead);
      if (ret < 0)
        return ret;
    }
 
    /* Need to align for start of next writer */
    ret = pad_up_block(t);
    if (ret < 0)
    return ret;
 
    iso_msg_debug(t->image->id, "(a) %d written", (int) t->bytes_written / 0x800);
    return ISO_SUCCESS;
}

References hfsplus_catfile_common::atime, Iso_Node::atime, hfsplus_catfile_common::attr_mtime, hfsplus_btheader::attributes, hfsplus_forkdata::blocks, ecma119_image::bytes_written, hfsplus_node::cat_id, hfsplus_btheader::clump_size, hfsplus_forkdata::clumpsize, hfsplus_btree_node::cnt, hfsplus_extent::count, hfsplus_btnode::count, iso_hfsplus_xinfo_data::creator_code, hfsplus_catfile_common::ctime, Iso_Node::ctime, hfsplus_btheader::depth, hfsplus_forkdata::extents, hfsplus_node::file, hfsplus_catfile_common::file_creator, hfsplus_catfile_common::file_type, hfsplus_catfile_common::fileid, filesrc_block_and_size(), hfsplus_btheader::first_leaf_node, hfsplus_catfile_common::flags, hfsplus_btheader::free_nodes, hfsplus_catfile_common::gid, hfsplus_btnode::height, iso_write_opts::hfsp_block_size, ecma119_image::hfsp_cat_node_size, ecma119_image::hfsp_iso_block_fac, ecma119_image::hfsp_leafs, ecma119_image::hfsp_levels, ecma119_image::hfsp_nleafs, ecma119_image::hfsp_nlevels, ecma119_image::hfsp_nnodes, ecma119_image::hfsp_part_start, HFSPLUS_DIR, HFSPLUS_DIR_THREAD, HFSPLUS_FILE, HFSPLUS_FILE_THREAD, HFSPLUS_MAX_BLOCK_SIZE, Iso_Image::id, ecma119_image::image, iso_hfsplus_xinfo_func(), iso_msb(), iso_msg_debug(), iso_node_get_xinfo(), ISO_NULL_POINTER, ISO_SUCCESS, iso_write(), hfsplus_btheader::key_compare, hfsplus_btheader::keysize, hfsplus_btheader::last_leaf_node, hfsplus_btheader::leaf_records, hfsplus_btree_level::level_size, LIBISO_HFSPLUS_NAME_MAX, mac_time_offset(), hfsplus_catfile_common::mode, Iso_Node::mode, hfsplus_catfile_common::mtime, Iso_Node::mtime, hfsplus_node::name, Iso_Node::name, hfsplus_catfile_thread::namelen, hfsplus_node::nchildren, hfsplus_btnode::next, hfsplus_node::node, hfsplus_btree_level::nodes, hfsplus_btheader::nodesize, ecma119_image::opts, pad_up_block(), Iso_Node::parent, hfsplus_btree_node::parent_id, hfsplus_node::parent_id, hfsplus_catfile_thread::parentid, hfsplus_btnode::prev, px_get_gid(), px_get_mode(), px_get_uid(), hfsplus_btheader::root, hfsplus_forkdata::size, hfsplus_catfile_common::special, hfsplus_btree_node::start, hfsplus_extent::start, hfsplus_btree_node::str, hfsplus_btree_node::strlen, hfsplus_node::strlen, hfsplus_node::symlink_block, hfsplus_node::symlink_dest, Iso_Image_Writer::target, hfsplus_btheader::total_nodes, hfsplus_node::type, hfsplus_btnode::type, hfsplus_catfile_thread::type, hfsplus_catfile_common::type, iso_hfsplus_xinfo_data::type_code, hfsplus_catfile_common::uid, hfsplus_node::unix_type, hfsplus_catfile_common::valence, and write_sb().

Referenced by hfsplus_writer_create().

iso_get_hfsplus_name()

int iso_get_hfsplus_name	(	char *	input_charset,
		int	imgid,
		char *	name,
		uint16_t **	result,
		uint32_t *	result_len,
		uint16_t **	cmp_name
	)

Definition at line 118 of file hfsplus.c.

{
    int ret;
    uint16_t *ucs_name, *iptr, *optr;
    uint32_t curlen;
    int done;
 
    if (name == NULL) {
        /* it is not necessarily an error, it can be the root */
        return ISO_SUCCESS;
    }
 
    ret = str2utf16be(input_charset, name, &ucs_name);
    if (ret < 0) {
        iso_msg_debug(imgid, "Cannot convert '%s'", name);
        return ret;
    }
 
    curlen = ucslen (ucs_name);
    *result = calloc ((curlen * HFSPLUS_MAX_DECOMPOSE_LEN + 1),
                     sizeof (uint16_t));
    if (*result == NULL) {
        free(ucs_name);
        return ISO_OUT_OF_MEM;
    }
 
    for (iptr = ucs_name, optr = *result; *iptr; iptr++)
      {
    const uint16_t *dptr;
    uint16_t val = iso_ntohs (*iptr);
    uint8_t high = val >> 8;
    uint8_t low = val & 0xff;
 
    if (val == ':')
      {
        *optr++ = iso_htons ('/');
        continue;
      }
 
    if (val >= 0xac00 && val <= 0xd7a3)
      {
        uint16_t s, l, v, t;
        s = val - 0xac00;
        l = s / (21 * 28);
        v = (s % (21 * 28)) / 28;
        t = s % 28;
        *optr++ = iso_htons (l + 0x1100);
        *optr++ = iso_htons (v + 0x1161);
        if (t)
          *optr++ = iso_htons (t + 0x11a7);
        continue;
      }
    if (!hfsplus_decompose_pages[high])
      {
        *optr++ = *iptr;
        continue;
      }
    dptr = hfsplus_decompose_pages[high][low];
    if (!dptr[0])
      {
        *optr++ = *iptr;
        continue;
      }
    for (; *dptr; dptr++)
      *optr++ = iso_htons (*dptr);
      }
    *optr = 0;
 
    do
      {
    uint8_t last_class;
    done = 0;
    if (!ucs_name[0])
      break;
    last_class = get_class (ucs_name[0]);
    for (optr = *result + 1; *optr; optr++)
      {
        uint8_t new_class = get_class (*optr);
 
        if (last_class == 0 || new_class == 0
        || last_class <= new_class)
          last_class = new_class;
        else
          {
        uint16_t t;
        t = *(optr - 1);
        *(optr - 1) = *optr;
        *optr = t;
          }
      }
      }
    while (done);
 
    *cmp_name = calloc ((ucslen (*result) + 1), sizeof (uint16_t));
    if (*cmp_name == NULL) {
        free(ucs_name);
        free(*result);
        *result = NULL;
        return ISO_OUT_OF_MEM;
    }
 
    for (iptr = *result, optr = *cmp_name; *iptr; iptr++)
      {
    *optr = iso_hfsplus_cichar(*iptr);
    if (*optr != 0)
        optr++;
      }
    *optr = 0;
 
    free (ucs_name);
 
    *result_len = ucslen (*result);
    return ISO_SUCCESS;
}

References get_class(), hfsplus_decompose_pages, HFSPLUS_MAX_DECOMPOSE_LEN, iso_hfsplus_cichar(), iso_htons(), iso_msg_debug(), iso_ntohs(), ISO_OUT_OF_MEM, ISO_SUCCESS, str2utf16be(), and ucslen().

Referenced by iso_conv_name_chars(), and set_hfsplus_name().

iso_hfsplus_cichar()

uint16_t iso_hfsplus_cichar

(

uint16_t

x

)

Definition at line 444 of file hfsplus_case.c.

{
    int page, i;
    uint16_t ret;
    uint8_t low, high;
 
    high = ((uint8_t *) &x)[0];
    low = ((uint8_t *) &x)[1];
 
    page = what_page(x);
    if (page < 0)
        return x; /* No translation needed */
    if (page == 0)
        return cmp_name_page0(x); /* Accelerator for ASCII subset */
 
    for (i = utf16be_transl_starts[page] * 4; i < utf16be_transl_count * 4;
         i += 4) {
        if (utf16be_transl[i] != high)
    break;
        if (utf16be_transl[i + 1] == low) { 
            ((uint8_t *) &ret)[0] = utf16be_transl[i + 2];
            ((uint8_t *) &ret)[1] = utf16be_transl[i + 3];
            return ret;
        }
    }
    return x;
}

References cmp_name_page0(), utf16be_transl, utf16be_transl_count, utf16be_transl_starts, and what_page().

Referenced by iso_get_hfsplus_name().

iso_hfsplus_xinfo_cloner()

int iso_hfsplus_xinfo_cloner	(	void *	old_data,
		void **	new_data,
		int	flag
	)

Definition at line 1864 of file hfsplus.c.

{
    *new_data = NULL;
    if (flag)
        return ISO_XINFO_NO_CLONE;
    if (old_data == NULL)
        return 0;
    *new_data = iso_hfsplus_xinfo_new(0);
    if(*new_data == NULL)
       return ISO_OUT_OF_MEM;
    memcpy(*new_data, old_data, sizeof(struct iso_hfsplus_xinfo_data));
    return ISO_SUCCESS;
}

References iso_hfsplus_xinfo_new(), ISO_OUT_OF_MEM, ISO_SUCCESS, and ISO_XINFO_NO_CLONE.

Referenced by iso_init_with_flag().

iso_hfsplus_xinfo_func()

int iso_hfsplus_xinfo_func	(	void *	data,
		int	flag
	)

The function that is used to mark struct iso_hfsplus_xinfo_data at IsoNodes and finally disposes such structs when their IsoNodes get disposed.

Usually an application does not call this function, but only uses it as parameter of xinfo calls like iso_node_add_xinfo() or iso_node_get_xinfo().

Since

1.2.4

Definition at line 1841 of file hfsplus.c.

{
    if (flag == 1 && data != NULL)
        free(data);
    return 1;
}

Referenced by hfsplus_writer_write_data(), and iso_init_with_flag().

iso_hfsplus_xinfo_new()

struct iso_hfsplus_xinfo_data* iso_hfsplus_xinfo_new

(

int

flag

)

Create an instance of struct iso_hfsplus_xinfo_new().

Parameters

flag	Bitfield for control purposes. Unused yet. Submit 0.

Returns

A pointer to the new object NULL indicates failure to allocate memory

Since

1.2.4

Definition at line 1849 of file hfsplus.c.

{
    struct iso_hfsplus_xinfo_data *o;
 
    o = calloc(1, sizeof(struct iso_hfsplus_xinfo_data));
    if (o == NULL)
        return NULL;
    o->version = 0;
    return o;
}

References iso_hfsplus_xinfo_data::version.

Referenced by iso_hfsplus_xinfo_cloner().

iso_setup_hfsplus_block_size()

void iso_setup_hfsplus_block_size

(

Ecma119Image *

target

)

Definition at line 1582 of file hfsplus.c.

{
    if (target->opts->hfsp_block_size == 0)
        target->opts->hfsp_block_size = HFSPLUS_DEFAULT_BLOCK_SIZE;
    target->hfsp_cat_node_size = 2 * target->opts->hfsp_block_size;
    target->hfsp_iso_block_fac = 2048 / target->opts->hfsp_block_size;
}

References iso_write_opts::hfsp_block_size, ecma119_image::hfsp_cat_node_size, ecma119_image::hfsp_iso_block_fac, HFSPLUS_DEFAULT_BLOCK_SIZE, and ecma119_image::opts.

Referenced by ecma119_image_new(), and hfsplus_writer_create().

mac_time_offset()

static uint32_t mac_time_offset ( uint32_t  t )

inlinestatic

Definition at line 546 of file hfsplus.c.

{
    uint32_t val;
    iso_msb ((uint8_t *) &val, t + 2082844800, sizeof(val));
    return val;
}

References iso_msb().

Referenced by hfsplus_writer_write_data(), and write_sb().

mangle_leafs()

static int mangle_leafs ( Ecma119Image *  target, int  flag  )

static

Definition at line 1467 of file hfsplus.c.

{
    int ret;
    uint32_t i, new_idx, prev, first_prev;
 
    iso_msg_debug(target->image->id, "%s", "HFS+ mangling started ...");
 
    /* Look for the first owner of a name */
    for (prev = 0; prev < target->hfsp_nleafs; prev++) {
        if (target->hfsp_leafs[prev].type == HFSPLUS_DIR_THREAD ||
            target->hfsp_leafs[prev].type == HFSPLUS_FILE_THREAD ||
            target->hfsp_leafs[prev].node == NULL ||
            target->hfsp_leafs[prev].name == NULL ||
            target->hfsp_leafs[prev].cmp_name == NULL)
    continue;
        if (target->hfsp_leafs[prev].node->name == NULL)
    continue;
    break;
    }
 
    first_prev = prev; 
    for (i = prev + 1; i < target->hfsp_nleafs; i++) {
        if (target->hfsp_leafs[i].type == HFSPLUS_DIR_THREAD ||
            target->hfsp_leafs[i].type == HFSPLUS_FILE_THREAD ||
            target->hfsp_leafs[i].node == NULL ||
            target->hfsp_leafs[i].name == NULL ||
            target->hfsp_leafs[i].cmp_name == NULL)
    continue;
        if (target->hfsp_leafs[i].node->name == NULL)
    continue;
        if (cmp_node(&(target->hfsp_leafs[prev]), &(target->hfsp_leafs[i]))
            != 0) {
            prev = i;
    continue;
        }
        target->hfsp_collision_count++;
 
 
#ifdef Libisofs_with_mangle_masK
 
        /* >>> Development sketch: */
 
        /* >>> define in libisofs.h : enum with LIBISO_NOMANGLE_xyz 
                                      xinfo function for uint32_t
        */
 
        /* >>> inquire xinfo for mangle protection : uint32_t mangle_mask */
 
        if (mangle_mask & (1 << LIBISO_NOMANGLE_HFSPLUS)) {
 
            /* >>> Get full ISO-RR paths of colliding nodes and print
                   error message */;
 
            return ISO_HFSP_NO_MANGLE;
        } else {
 
#else /* Libisofs_with_mangle_masK */
 
        {
 
#endif /* ! Libisofs_with_mangle_masK */
 
 
            ret= try_mangle(target, i, prev, i + 1, target->hfsp_nleafs,
                            &new_idx, target->hfsp_leafs[i].node->name, 0);
            if (ret == 0)
                ret= try_mangle(target, i, prev, 0, target->hfsp_nleafs,
                                &new_idx, "MANGLED", 0);
            if (ret < 0)
                return(ret);
            if (new_idx > i) {
                i--; /* an unprocessed candidate has been rotated to i */
            } else {
                prev = i; /* advance */
            }
        }
    }
 
    if (target->hfsp_collision_count > 0) {
        /* Mangling cannot be properly performed if the name owners do not
           stay in sorting order.
        */
        prev = first_prev;
        for (i = prev + 1; i < target->hfsp_nleafs; i++) {
            if (target->hfsp_leafs[i].type == HFSPLUS_DIR_THREAD ||
                target->hfsp_leafs[i].type == HFSPLUS_FILE_THREAD ||
                target->hfsp_leafs[i].node == NULL ||
                target->hfsp_leafs[i].name == NULL ||
                target->hfsp_leafs[i].cmp_name == NULL)
        continue;
            if (target->hfsp_leafs[i].node->name == NULL)
        continue;
            if (cmp_node(&(target->hfsp_leafs[prev]),
                         &(target->hfsp_leafs[i])) > 0) {
 
                iso_msg_debug(target->image->id,
                     "*********** Mangling messed up sorting *************\n");
 
        break;
            }
            prev = i;
        }
 
        /* Only the owners of names were considered during mangling.
           The HFSPLUS_*_THREAD types must get in line by sorting again.
        */
        qsort(target->hfsp_leafs, target->hfsp_nleafs,
              sizeof(*target->hfsp_leafs), cmp_node);
    }
    iso_msg_debug(target->image->id,
                  "HFS+ mangling done. Resolved Collisions: %lu",
                  (unsigned long) target->hfsp_collision_count);
    return ISO_SUCCESS;
}

References hfsplus_node::cmp_name, cmp_node(), ecma119_image::hfsp_collision_count, ecma119_image::hfsp_leafs, ecma119_image::hfsp_nleafs, HFSPLUS_DIR_THREAD, HFSPLUS_FILE_THREAD, Iso_Image::id, ecma119_image::image, ISO_HFSP_NO_MANGLE, iso_msg_debug(), ISO_SUCCESS, hfsplus_node::name, Iso_Node::name, hfsplus_node::node, try_mangle(), and hfsplus_node::type.

Referenced by hfsplus_writer_create().

nop_writer_free_data()

static int nop_writer_free_data ( IsoImageWriter *  writer )

static

Definition at line 1129 of file hfsplus.c.

{
    return ISO_SUCCESS;
}

References ISO_SUCCESS.

Referenced by hfsplus_tail_writer_create().

nop_writer_write_vol_desc()

int nop_writer_write_vol_desc

(

IsoImageWriter *

writer

)

Definition at line 554 of file hfsplus.c.

{
  return ISO_SUCCESS;
}

References ISO_SUCCESS.

Referenced by hfsplus_tail_writer_create(), and hfsplus_writer_create().

pad_up_block()

static int pad_up_block ( Ecma119Image *  t )

static

Definition at line 60 of file hfsplus.c.

{
    int ret;
    static char buffer[2048], buf_zeroed = 0;
 
    if (!buf_zeroed) {
        memset(buffer, 0, 2048);
        buf_zeroed = 1;
    }
    if (t->bytes_written % 2048) {
    ret = iso_write(t, buffer, 2048 - (t->bytes_written % 2048));
    if (ret < 0)
        return ret;
    }
    return 1;
}

References ecma119_image::bytes_written, and iso_write().

Referenced by hfsplus_tail_writer_write_data(), and hfsplus_writer_write_data().

px_get_gid()

static uid_t px_get_gid ( Ecma119Image *  t, IsoNode *  n  )

static

Definition at line 570 of file hfsplus.c.

{
    if (t->replace_gid) {
        return t->gid;
    } else {
        return n->gid;
    }
}

References ecma119_image::gid, Iso_Node::gid, and ecma119_image::replace_gid.

Referenced by hfsplus_writer_write_data().

px_get_mode()

static mode_t px_get_mode ( Ecma119Image *  t, IsoNode *  n, int  isdir  )

static

Definition at line 580 of file hfsplus.c.

{
    if (isdir) {
        if (t->replace_dir_mode) {
            return (n->mode & S_IFMT) | t->dir_mode;
        }
    } else {
        if (t->replace_file_mode) {
            return (n->mode & S_IFMT) | t->file_mode;
        }
    }
    return n->mode;
}

References ecma119_image::dir_mode, ecma119_image::file_mode, Iso_Node::mode, ecma119_image::replace_dir_mode, and ecma119_image::replace_file_mode.

Referenced by hfsplus_writer_write_data().

px_get_uid()

static uid_t px_get_uid ( Ecma119Image *  t, IsoNode *  n  )

static

Definition at line 560 of file hfsplus.c.

{
    if (t->replace_uid) {
        return t->uid;
    } else {
        return n->uid;
    }
}

References ecma119_image::replace_uid, ecma119_image::uid, and Iso_Node::uid.

Referenced by hfsplus_writer_write_data().

rotate_hfs_list()

static void rotate_hfs_list ( Ecma119Image *  target, uint32_t  old_idx, uint32_t  new_idx, int  flag  )

static

Definition at line 1171 of file hfsplus.c.

{
    uint32_t i, sz;
    HFSPlusNode tr;
 
    if (old_idx == new_idx)
        return;
    sz = sizeof(HFSPlusNode);
    memcpy(&tr, &target->hfsp_leafs[old_idx], sz);
    if (old_idx > new_idx) {
        for (i = old_idx; i > new_idx; i--)
            memcpy(&target->hfsp_leafs[i], &target->hfsp_leafs[i - 1], sz);
    } else {
        for (i = old_idx; i < new_idx; i++)
            memcpy(&target->hfsp_leafs[i], &target->hfsp_leafs[i + 1], sz);
    }
    memcpy(&target->hfsp_leafs[new_idx], &tr, sz);
}

References ecma119_image::hfsp_leafs.

Referenced by try_mangle().

search_mangled_pos()

static int search_mangled_pos ( Ecma119Image *  target, uint32_t  idx, uint32_t *  new_idx, uint32_t  search_start, uint32_t  search_end, int  flag  )

static

Definition at line 1143 of file hfsplus.c.

{
    uint32_t i;
    int rel;
 
    for (i = search_start; i < search_end; i++) {
        if (target->hfsp_leafs[i].type == HFSPLUS_DIR_THREAD ||
            target->hfsp_leafs[i].type == HFSPLUS_FILE_THREAD)
    continue;
        rel = cmp_node(&(target->hfsp_leafs[idx]), &(target->hfsp_leafs[i]));
        if (rel == 0 && idx != i) {
            *new_idx = i;
            return 0; /* Collision */
        }
        if (rel < 0 && !(flag & 1)) {
            if (i <= idx)
                *new_idx = i;
            else
                *new_idx = i - 1;
            return 1;
        }
    }
    *new_idx = search_end - 1;
    return 1;
}

References cmp_node(), ecma119_image::hfsp_leafs, HFSPLUS_DIR_THREAD, HFSPLUS_FILE_THREAD, and hfsplus_node::type.

Referenced by try_mangle().

set_hfsplus_name()

static int set_hfsplus_name ( Ecma119Image *  t, char *  name, HFSPlusNode *  node  )

static

Definition at line 235 of file hfsplus.c.

{
    int ret;
 
    ret = iso_get_hfsplus_name(t->input_charset, t->image->id, name,
                            &(node->name), &(node->strlen), &(node->cmp_name));
    return ret;
}

References hfsplus_node::cmp_name, Iso_Image::id, ecma119_image::image, ecma119_image::input_charset, iso_get_hfsplus_name(), hfsplus_node::name, and hfsplus_node::strlen.

Referenced by create_tree(), hfsplus_writer_create(), and try_mangle().

subst_symlink_dest_comp()

static int subst_symlink_dest_comp ( Ecma119Image *  target, uint32_t  idx, char **  dest, unsigned int *  dest_len, char **  comp_start, char **  comp_end, char *  new_name, int  flag  )

static

Definition at line 1192 of file hfsplus.c.

{
    int new_len;
    unsigned int new_dest_len;
    char *new_dest, *wpt;
 
    new_len = strlen(new_name);
    new_dest_len =
               *comp_start - *dest + new_len + *dest_len - (*comp_end - *dest);
    new_dest = calloc(1, new_dest_len + 1);
    if (new_dest == NULL)
        return ISO_OUT_OF_MEM;
    wpt = new_dest;
    if (*comp_start - *dest > 0)
        memcpy(wpt, *dest, *comp_start - *dest);
    wpt += *comp_start - *dest;
    memcpy(wpt, new_name, new_len);
    wpt += new_len;
    if ((unsigned int) (*comp_end - *dest) < *dest_len)
        memcpy(wpt, *comp_end, *dest_len - (*comp_end - *dest));
    wpt += *dest_len - (*comp_end - *dest);
    *wpt = 0;
 
    *comp_start = new_dest + (*comp_start - *dest);
    *comp_end = *comp_start + new_len;
    target->hfsp_leafs[idx].symlink_dest = new_dest;
    *dest_len = new_dest_len;
    free(*dest);
    *dest = new_dest;
    return ISO_SUCCESS;
}

References ecma119_image::hfsp_leafs, ISO_OUT_OF_MEM, ISO_SUCCESS, and hfsplus_node::symlink_dest.

Referenced by update_symlink().

try_mangle()

static int try_mangle ( Ecma119Image *  target, uint32_t  idx, uint32_t  prev_idx, uint32_t  search_start, uint32_t  search_end, uint32_t *  new_idx, char *  prefix, int  flag  )

static

Definition at line 1385 of file hfsplus.c.

{
    int i, ret = 0;
    char new_name[LIBISO_HFSPLUS_NAME_MAX + 1], number[9];
    uint16_t *old_name, *old_cmp_name;
    uint32_t old_strlen;
 
    old_name = target->hfsp_leafs[idx].name;
    old_cmp_name = target->hfsp_leafs[idx].cmp_name;
    old_strlen = target->hfsp_leafs[idx].strlen;
 
    for (i = -1; i < 0x7fffffff; i++) {
        if (i == -1)
            number[0] = 0;
        else
            sprintf(number, "%X", (unsigned int) i);
        if (strlen(prefix) + 1 + strlen(number) > LIBISO_HFSPLUS_NAME_MAX) {
            ret = 0;
            goto no_success;
        }
 
        /* "-" would sort lower than capital letters ,
           traditional "_" causes longer rotations
         */
        sprintf(new_name, "%s_%s", prefix, number);
 
        /* The original name is kept until the end of the try */
        if (target->hfsp_leafs[idx].name != old_name)
            free(target->hfsp_leafs[idx].name);
        if (target->hfsp_leafs[idx].cmp_name != old_cmp_name)
            free(target->hfsp_leafs[idx].cmp_name);
 
 
        ret = set_hfsplus_name(target, new_name, &(target->hfsp_leafs[idx]));
        if (ret < 0)
            goto no_success;
 
        ret = search_mangled_pos(target, idx, new_idx, search_start,
                                 search_end, (flag & 1));
        if (ret < 0)
            goto no_success;
        if (ret == 0)
    continue; /* collision */
        if (flag & 1)
            *new_idx = idx;
        else
            rotate_hfs_list(target, idx, *new_idx, 0);
 
        /* >>> Get full ISO-RR paths of colliding nodes */;
        /* >>> iso_tree_get_node_path(node); */
 
        iso_msg_debug(target->image->id,
                  "HFS+ name collision with \"%s\" : \"%s\" renamed to \"%s\"",
                  target->hfsp_leafs[prev_idx].node->name,
                  target->hfsp_leafs[*new_idx].node->name, new_name);
 
    break;    
    }
    target->hfsp_leafs[*new_idx].used_size +=
                        (target->hfsp_leafs[*new_idx].strlen - old_strlen) * 2;
 
    if (!(flag & 1)) {
        ret = update_name_followers(target, *new_idx, new_name,
                                    old_name, old_cmp_name, old_strlen);
        if (ret < 0)
            goto no_success;
    }
 
    free(old_name);
    free(old_cmp_name);
    return 1;
 
no_success:;
    target->hfsp_leafs[idx].name = old_name;
    target->hfsp_leafs[idx].cmp_name = old_cmp_name;
    target->hfsp_leafs[idx].strlen = old_strlen;
    return ret;
}

References hfsplus_node::cmp_name, ecma119_image::hfsp_leafs, Iso_Image::id, ecma119_image::image, iso_msg_debug(), LIBISO_HFSPLUS_NAME_MAX, hfsplus_node::name, Iso_Node::name, hfsplus_node::node, rotate_hfs_list(), search_mangled_pos(), set_hfsplus_name(), hfsplus_node::strlen, update_name_followers(), and hfsplus_node::used_size.

Referenced by mangle_leafs().

update_name_followers()

static int update_name_followers ( Ecma119Image *  target, uint32_t  idx, char *  new_name, uint16_t *  old_name, uint16_t *  old_cmp_name, uint32_t  old_strlen  )

static

Definition at line 1351 of file hfsplus.c.

{
    uint32_t i;
    int ret, link_depth;
 
    for (i = 0; i < target->hfsp_nleafs; i++) {
        if (target->hfsp_leafs[i].unix_type == UNIX_SYMLINK) {
            link_depth = 0;
            ret = update_symlink(target, idx, new_name, i, &link_depth, 0);
            if (ret < 0)
                return ret;
        }
        if (target->hfsp_leafs[i].name != old_name)
    continue;
        target->hfsp_leafs[i].name = target->hfsp_leafs[idx].name;
        target->hfsp_leafs[i].strlen = target->hfsp_leafs[idx].strlen;
        if (target->hfsp_leafs[i].cmp_name == old_cmp_name)
            target->hfsp_leafs[i].cmp_name = target->hfsp_leafs[idx].cmp_name;
        if (target->hfsp_leafs[i].strlen > old_strlen)
            target->hfsp_leafs[i].used_size += (target->hfsp_leafs[i].strlen -
                                                old_strlen) * 2;
        else
            target->hfsp_leafs[i].used_size -= 2 * (old_strlen -
                                                 target->hfsp_leafs[i].strlen);
    }
    return 1;
}

References hfsplus_node::cmp_name, ecma119_image::hfsp_leafs, ecma119_image::hfsp_nleafs, hfsplus_node::name, hfsplus_node::strlen, hfsplus_node::unix_type, update_symlink(), and hfsplus_node::used_size.

Referenced by try_mangle().

update_symlink()

static int update_symlink ( Ecma119Image *  target, uint32_t  changed_idx, char *  new_name, uint32_t  link_idx, int *  depth, int  flag  )

static

Definition at line 1238 of file hfsplus.c.

{
    IsoSymlink *sym;
    IsoDir *cur_dir = NULL;
    IsoNode *n, *resolved_node;
    char *orig_dest, *orig_start, *orig_end;
    char *hfsp_dest, *hfsp_start, *hfsp_end;
    int ret = 0;
    unsigned int comp_len, orig_len, hfsp_len;
 
    if (target->hfsp_leafs[link_idx].node->type != LIBISO_SYMLINK)
        return ISO_SUCCESS;
    sym = (IsoSymlink *) target->hfsp_leafs[link_idx].node;
    orig_dest = sym->dest;
    orig_len = strlen(orig_dest);
    hfsp_dest = target->hfsp_leafs[link_idx].symlink_dest;
    hfsp_len = strlen(hfsp_dest);
 
    if (orig_dest[0] == '/') {
 
        /* >>> ??? How to salvage absolute links without knowing the
                   path of the future mount point ?
               ??? Would it be better to leave them as is ?
           I can only assume that it gets mounted at / during some stage
           of booting.
        */;
 
        cur_dir = target->image->root;
        orig_end = orig_dest;
    } else {
        cur_dir = sym->node.parent;
        if (cur_dir == NULL)
            cur_dir = target->image->root;
        orig_end = orig_dest - 1;
    }
 
    if (hfsp_dest[0] == '/')
        hfsp_end = hfsp_dest;
    else
        hfsp_end = hfsp_dest - 1;
 
    while (orig_end < orig_dest + orig_len) {
        orig_start = orig_end + 1;
        hfsp_start = hfsp_end + 1;
 
        orig_end = strchr(orig_start, '/');
        if (orig_end == NULL)
            orig_end = orig_start + strlen(orig_start);
        comp_len = orig_end - orig_start;
        hfsp_end = strchr(hfsp_start, '/');
        if (hfsp_end == NULL)
            hfsp_end = hfsp_start + strlen(hfsp_start);
 
        if (comp_len == 0 || (comp_len == 1 && orig_start[0] == '.'))
   continue;
        if (comp_len == 2 && orig_start[0] == '.' && orig_start[1] == '.') {
            cur_dir = cur_dir->node.parent;
            if (cur_dir == NULL) /* link shoots over root */
                return ISO_SUCCESS;
   continue;
        }
 
        /* Search node in cur_dir */
        for (n = cur_dir->children; n != NULL; n = n->next)
            if (strncmp(orig_start, n->name, comp_len) == 0 &&
                strlen(n->name) == comp_len)
        break;
        if (n == NULL) /* dead link */
            return ISO_SUCCESS;
 
        if (n == target->hfsp_leafs[changed_idx].node) {
            iso_msg_debug(target->image->id,
                          "     link path '%s' touches RR '%s', HFS+ '%s'",
                          orig_dest, (n->name != NULL ? n->name : ""),
                          new_name);
 
            /* Exchange HFS+ component by new_name */
            ret = subst_symlink_dest_comp(target, link_idx,
                                          &hfsp_dest, &hfsp_len,
                                          &hfsp_start, &hfsp_end, new_name, 0);
            if (ret < 0)
                return ret;
        }
 
        if (n->type == LIBISO_DIR) {
            cur_dir = (IsoDir *) n;
        } else if (n->type == LIBISO_SYMLINK) {
            /* Resolve link and check whether it is a directory */
            if (*depth >= LIBISO_MAX_LINK_DEPTH)
                return ISO_SUCCESS;
            (*depth)++;
            ret = iso_tree_resolve_symlink(target->image, (IsoSymlink *) n,
                                           &resolved_node, depth, 0);
            if (ret == (int) ISO_DEAD_SYMLINK || ret == (int) ISO_DEEP_SYMLINK)
                return ISO_SUCCESS;
            if (ret < 0)
                return ret;
            if (resolved_node->type != LIBISO_DIR)
                return ISO_SUCCESS;
            cur_dir = (IsoDir *) resolved_node;
        } else {
    break;
        }
    }
    return ISO_SUCCESS;
}

References Iso_Dir::children, hfsplus_btheader::depth, Iso_Symlink::dest, ecma119_image::hfsp_leafs, Iso_Image::id, ecma119_image::image, ISO_DEAD_SYMLINK, ISO_DEEP_SYMLINK, iso_msg_debug(), ISO_SUCCESS, iso_tree_resolve_symlink(), LIBISO_DIR, LIBISO_MAX_LINK_DEPTH, LIBISO_SYMLINK, Iso_Node::name, Iso_Node::next, hfsplus_node::node, Iso_Dir::node, Iso_Symlink::node, Iso_Node::parent, Iso_Image::root, subst_symlink_dest_comp(), hfsplus_node::symlink_dest, and Iso_Node::type.

Referenced by update_name_followers().

write_sb()

int write_sb

(

Ecma119Image *

t

)

Definition at line 595 of file hfsplus.c.

{
    struct hfsplus_volheader sb;
    static char buffer[1024];
    int ret;
    int i;
    uint32_t block_size;
 
    iso_msg_debug(t->image->id, "Write HFS+ superblock");
 
    block_size = t->opts->hfsp_block_size;
 
    memset (buffer, 0, sizeof (buffer));
    ret = iso_write(t, buffer, 1024);
    if (ret < 0)
      return ret;
 
    memset (&sb, 0, sizeof (sb));
 
    t->hfsp_allocation_size = (t->hfsp_total_blocks + 7) >> 3;
 
    iso_msb ((uint8_t *) &sb.magic, 0x482b, 2);
    iso_msb ((uint8_t *) &sb.version, 4, 2);
    /* Cleanly unmounted, software locked.  */
    iso_msb ((uint8_t *) &sb.attributes, (1 << 8) | (1 << 15), 4);
    iso_msb ((uint8_t *) &sb.last_mounted_version, 0x6c69736f, 4);
    sb.ctime = mac_time_offset(t->now);
    sb.utime = mac_time_offset(t->now);
    sb.fsck_time = mac_time_offset(t->now);
    iso_msb ((uint8_t *) &sb.file_count, t->hfsp_nfiles, 4);
    iso_msb ((uint8_t *) &sb.folder_count, t->hfsp_ndirs - 1, 4);
    iso_msb ((uint8_t *) &sb.blksize, block_size, 4);
    iso_msb ((uint8_t *) &sb.catalog_node_id, t->hfsp_cat_id, 4);
    iso_msb ((uint8_t *) &sb.rsrc_clumpsize, block_size, 4);
    iso_msb ((uint8_t *) &sb.data_clumpsize, block_size, 4);
    iso_msb ((uint8_t *) &sb.total_blocks, t->hfsp_total_blocks, 4);
    iso_msb ((uint8_t *) &sb.encodings_bitmap + 4, 1, 4);
 
    iso_msb ((uint8_t *) &sb.allocations_file.size + 4, t->hfsp_allocation_size, 4);
    iso_msb ((uint8_t *) &sb.allocations_file.clumpsize, block_size, 4);
    iso_msb ((uint8_t *) &sb.allocations_file.blocks, (t->hfsp_allocation_size + block_size - 1) / block_size, 4);
    iso_msb ((uint8_t *) &sb.allocations_file.extents[0].start, t->hfsp_allocation_file_start - t->hfsp_part_start, 4);
    iso_msb ((uint8_t *) &sb.allocations_file.extents[0].count, (t->hfsp_allocation_size + block_size - 1) / block_size, 4);
 
    iso_msb ((uint8_t *) &sb.extents_file.size + 4, block_size, 4);
    iso_msb ((uint8_t *) &sb.extents_file.clumpsize, block_size, 4);
    iso_msb ((uint8_t *) &sb.extents_file.blocks, 1, 4);
    iso_msb ((uint8_t *) &sb.extents_file.extents[0].start, t->hfsp_extent_file_start - t->hfsp_part_start, 4);
    iso_msb ((uint8_t *) &sb.extents_file.extents[0].count, 1, 4);
    iso_msg_debug(t->image->id, "extent_file_start = %d\n", (int)t->hfsp_extent_file_start);
 
    iso_msb ((uint8_t *) &sb.catalog_file.size + 4, block_size * 2 * t->hfsp_nnodes, 4);
    iso_msb ((uint8_t *) &sb.catalog_file.clumpsize, block_size * 2, 4);
    iso_msb ((uint8_t *) &sb.catalog_file.blocks, 2 * t->hfsp_nnodes, 4);
    iso_msb ((uint8_t *) &sb.catalog_file.extents[0].start, t->hfsp_catalog_file_start - t->hfsp_part_start, 4);
    iso_msb ((uint8_t *) &sb.catalog_file.extents[0].count, 2 * t->hfsp_nnodes, 4);
    iso_msg_debug(t->image->id, "catalog_file_start = %d\n", (int)t->hfsp_catalog_file_start);
 
    for (i = 0; i < ISO_HFSPLUS_BLESS_MAX; i++) {
     iso_msb ((uint8_t *) (&sb.ppc_bootdir + i
               + (i == ISO_HFSPLUS_BLESS_OSX_FOLDER)),
          t->hfsp_bless_id[i], 4);
 
#ifdef Libisofs_ts_debuG
     iso_msg_debug(t->image->id, "hfsplus bless %d written for cat_id %u",
                   i, t->hfsp_bless_id[i]);
#endif /* Libisofs_ts_debuG */
 
    }
 
    memcpy (&sb.num_serial, &t->opts->hfsp_serial_number, 8);
    ret = iso_write(t, &sb, sizeof (sb));
    if (ret < 0)
      return ret;
    return iso_write(t, buffer, 512);
}

References hfsplus_volheader::allocations_file, hfsplus_volheader::attributes, hfsplus_volheader::blksize, hfsplus_forkdata::blocks, hfsplus_volheader::catalog_file, hfsplus_volheader::catalog_node_id, hfsplus_forkdata::clumpsize, hfsplus_extent::count, hfsplus_volheader::ctime, hfsplus_volheader::data_clumpsize, hfsplus_volheader::encodings_bitmap, hfsplus_forkdata::extents, hfsplus_volheader::extents_file, hfsplus_volheader::file_count, hfsplus_volheader::folder_count, hfsplus_volheader::fsck_time, ecma119_image::hfsp_allocation_file_start, ecma119_image::hfsp_allocation_size, ecma119_image::hfsp_bless_id, iso_write_opts::hfsp_block_size, ecma119_image::hfsp_cat_id, ecma119_image::hfsp_catalog_file_start, ecma119_image::hfsp_extent_file_start, ecma119_image::hfsp_ndirs, ecma119_image::hfsp_nfiles, ecma119_image::hfsp_nnodes, ecma119_image::hfsp_part_start, iso_write_opts::hfsp_serial_number, ecma119_image::hfsp_total_blocks, Iso_Image::id, ecma119_image::image, ISO_HFSPLUS_BLESS_MAX, ISO_HFSPLUS_BLESS_OSX_FOLDER, iso_msb(), iso_msg_debug(), iso_write(), hfsplus_volheader::last_mounted_version, mac_time_offset(), hfsplus_volheader::magic, ecma119_image::now, hfsplus_volheader::num_serial, ecma119_image::opts, hfsplus_volheader::ppc_bootdir, hfsplus_volheader::rsrc_clumpsize, hfsplus_forkdata::size, hfsplus_extent::start, hfsplus_volheader::total_blocks, hfsplus_volheader::utime, and hfsplus_volheader::version.

Referenced by hfsplus_tail_writer_write_data(), and hfsplus_writer_write_data().