ciderpress/diskimg/libhfs/low.c

/*
 * libhfs - library for reading and writing Macintosh HFS volumes
 * Copyright (C) 1996-1998 Robert Leslie
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * $Id$
 */

# ifdef HAVE_CONFIG_H
#  include "config.h"
# endif

# include <stdlib.h>
# include <string.h>
# include <errno.h>

# include "libhfs.h"
# include "low.h"
# include "data.h"
# include "block.h"
# include "file.h"

/*
 * NAME:	low->getddr()
 * DESCRIPTION:	read a driver descriptor record
 */
int l_getddr(hfsvol *vol, Block0 *ddr)
{
  block b;
  const byte *ptr = b;
  int i;

  if (b_readpb(vol, 0, &b, 1) == -1)
    goto fail;

  d_fetchsw(&ptr, &ddr->sbSig);
  d_fetchsw(&ptr, &ddr->sbBlkSize);
  d_fetchsl(&ptr, &ddr->sbBlkCount);
  d_fetchsw(&ptr, &ddr->sbDevType);
  d_fetchsw(&ptr, &ddr->sbDevId);
  d_fetchsl(&ptr, &ddr->sbData);
  d_fetchsw(&ptr, &ddr->sbDrvrCount);
  d_fetchsl(&ptr, &ddr->ddBlock);
  d_fetchsw(&ptr, &ddr->ddSize);
  d_fetchsw(&ptr, &ddr->ddType);

  for (i = 0; i < 243; ++i)
    d_fetchsw(&ptr, &ddr->ddPad[i]);

  ASSERT(ptr - b == HFS_BLOCKSZ);

  return 0;

fail:
  return -1;
}

/*
 * NAME:	low->putddr()
 * DESCRIPTION:	write a driver descriptor record
 */
int l_putddr(hfsvol *vol, const Block0 *ddr)
{
  block b;
  byte *ptr = b;
  int i;

  d_storesw(&ptr, ddr->sbSig);
  d_storesw(&ptr, ddr->sbBlkSize);
  d_storesl(&ptr, ddr->sbBlkCount);
  d_storesw(&ptr, ddr->sbDevType);
  d_storesw(&ptr, ddr->sbDevId);
  d_storesl(&ptr, ddr->sbData);
  d_storesw(&ptr, ddr->sbDrvrCount);
  d_storesl(&ptr, ddr->ddBlock);
  d_storesw(&ptr, ddr->ddSize);
  d_storesw(&ptr, ddr->ddType);

  for (i = 0; i < 243; ++i)
    d_storesw(&ptr, ddr->ddPad[i]);

  ASSERT(ptr - b == HFS_BLOCKSZ);

  if (b_writepb(vol, 0, &b, 1) == -1)
    goto fail;

  return 0;

fail:
  return -1;
}

/*
 * NAME:	low->getpmentry()
 * DESCRIPTION:	read a partition map entry
 */
int l_getpmentry(hfsvol *vol, Partition *map, unsigned long bnum)
{
  block b;
  const byte *ptr = b;
  int i;

  if (b_readpb(vol, bnum, &b, 1) == -1)
    goto fail;

  d_fetchsw(&ptr, &map->pmSig);
  d_fetchsw(&ptr, &map->pmSigPad);
  d_fetchsl(&ptr, &map->pmMapBlkCnt);
  d_fetchsl(&ptr, &map->pmPyPartStart);
  d_fetchsl(&ptr, &map->pmPartBlkCnt);

  strncpy((char *) map->pmPartName, (const char *) ptr, 32);
  map->pmPartName[32] = 0;
  ptr += 32;

  strncpy((char *) map->pmParType, (const char *) ptr, 32);
  map->pmParType[32] = 0;
  ptr += 32;

  d_fetchsl(&ptr, &map->pmLgDataStart);
  d_fetchsl(&ptr, &map->pmDataCnt);
  d_fetchsl(&ptr, &map->pmPartStatus);
  d_fetchsl(&ptr, &map->pmLgBootStart);
  d_fetchsl(&ptr, &map->pmBootSize);
  d_fetchsl(&ptr, &map->pmBootAddr);
  d_fetchsl(&ptr, &map->pmBootAddr2);
  d_fetchsl(&ptr, &map->pmBootEntry);
  d_fetchsl(&ptr, &map->pmBootEntry2);
  d_fetchsl(&ptr, &map->pmBootCksum);

  strncpy((char *) map->pmProcessor, (const char *) ptr, 16);
  map->pmProcessor[16] = 0;
  ptr += 16;

  for (i = 0; i < 188; ++i)
    d_fetchsw(&ptr, &map->pmPad[i]);

  ASSERT(ptr - b == HFS_BLOCKSZ);

  return 0;

fail:
  return -1;
}

/*
 * NAME:	low->putpmentry()
 * DESCRIPTION:	write a partition map entry
 */
int l_putpmentry(hfsvol *vol, const Partition *map, unsigned long bnum)
{
  block b;
  byte *ptr = b;
  int i;

  d_storesw(&ptr, map->pmSig);
  d_storesw(&ptr, map->pmSigPad);
  d_storesl(&ptr, map->pmMapBlkCnt);
  d_storesl(&ptr, map->pmPyPartStart);
  d_storesl(&ptr, map->pmPartBlkCnt);

  memset(ptr, 0, 32);
  strncpy((char *) ptr, (const char *) map->pmPartName, 32);
  ptr += 32;

  memset(ptr, 0, 32);
  strncpy((char *) ptr, (const char *) map->pmParType, 32);
  ptr += 32;

  d_storesl(&ptr, map->pmLgDataStart);
  d_storesl(&ptr, map->pmDataCnt);
  d_storesl(&ptr, map->pmPartStatus);
  d_storesl(&ptr, map->pmLgBootStart);
  d_storesl(&ptr, map->pmBootSize);
  d_storesl(&ptr, map->pmBootAddr);
  d_storesl(&ptr, map->pmBootAddr2);
  d_storesl(&ptr, map->pmBootEntry);
  d_storesl(&ptr, map->pmBootEntry2);
  d_storesl(&ptr, map->pmBootCksum);

  memset(ptr, 0, 16);
  strncpy((char *) ptr, (const char *) map->pmProcessor, 16);
  ptr += 16;

  for (i = 0; i < 188; ++i)
    d_storesw(&ptr, map->pmPad[i]);

  ASSERT(ptr - b == HFS_BLOCKSZ);

  if (b_writepb(vol, bnum, &b, 1) == -1)
    goto fail;

  return 0;

fail:
  return -1;
}

/*
 * NAME:	low->getbb()
 * DESCRIPTION:	read a volume's boot blocks
 */
int l_getbb(hfsvol *vol, BootBlkHdr *bb, byte *bootcode)
{
  block b;
  const byte *ptr = b;

  if (b_readlb(vol, 0, &b) == -1)
    goto fail;

  d_fetchsw(&ptr, &bb->bbID);
  d_fetchsl(&ptr, &bb->bbEntry);
  d_fetchsw(&ptr, &bb->bbVersion);
  d_fetchsw(&ptr, &bb->bbPageFlags);

  d_fetchstr(&ptr, bb->bbSysName,    sizeof(bb->bbSysName));
  d_fetchstr(&ptr, bb->bbShellName,  sizeof(bb->bbShellName));
  d_fetchstr(&ptr, bb->bbDbg1Name,   sizeof(bb->bbDbg1Name));
  d_fetchstr(&ptr, bb->bbDbg2Name,   sizeof(bb->bbDbg2Name));
  d_fetchstr(&ptr, bb->bbScreenName, sizeof(bb->bbScreenName));
  d_fetchstr(&ptr, bb->bbHelloName,  sizeof(bb->bbHelloName));
  d_fetchstr(&ptr, bb->bbScrapName,  sizeof(bb->bbScrapName));

  d_fetchsw(&ptr, &bb->bbCntFCBs);
  d_fetchsw(&ptr, &bb->bbCntEvts);
  d_fetchsl(&ptr, &bb->bb128KSHeap);
  d_fetchsl(&ptr, &bb->bb256KSHeap);
  d_fetchsl(&ptr, &bb->bbSysHeapSize);
  d_fetchsw(&ptr, &bb->filler);
  d_fetchsl(&ptr, &bb->bbSysHeapExtra);
  d_fetchsl(&ptr, &bb->bbSysHeapFract);

  ASSERT(ptr - b == 148);

  if (bootcode)
    {
      memcpy(bootcode, ptr, HFS_BOOTCODE1LEN);

      if (b_readlb(vol, 1, &b) == -1)
	goto fail;

      memcpy(bootcode + HFS_BOOTCODE1LEN, b, HFS_BOOTCODE2LEN);
    }

  return 0;

fail:
  return -1;
}

/*
 * NAME:	low->putbb()
 * DESCRIPTION:	write a volume's boot blocks
 */
int l_putbb(hfsvol *vol, const BootBlkHdr *bb, const byte *bootcode)
{
  block b;
  byte *ptr = b;

  d_storesw(&ptr, bb->bbID);
  d_storesl(&ptr, bb->bbEntry);
  d_storesw(&ptr, bb->bbVersion);
  d_storesw(&ptr, bb->bbPageFlags);

  d_storestr(&ptr, bb->bbSysName,    sizeof(bb->bbSysName));
  d_storestr(&ptr, bb->bbShellName,  sizeof(bb->bbShellName));
  d_storestr(&ptr, bb->bbDbg1Name,   sizeof(bb->bbDbg1Name));
  d_storestr(&ptr, bb->bbDbg2Name,   sizeof(bb->bbDbg2Name));
  d_storestr(&ptr, bb->bbScreenName, sizeof(bb->bbScreenName));
  d_storestr(&ptr, bb->bbHelloName,  sizeof(bb->bbHelloName));
  d_storestr(&ptr, bb->bbScrapName,  sizeof(bb->bbScrapName));

  d_storesw(&ptr, bb->bbCntFCBs);
  d_storesw(&ptr, bb->bbCntEvts);
  d_storesl(&ptr, bb->bb128KSHeap);
  d_storesl(&ptr, bb->bb256KSHeap);
  d_storesl(&ptr, bb->bbSysHeapSize);
  d_storesw(&ptr, bb->filler);
  d_storesl(&ptr, bb->bbSysHeapExtra);
  d_storesl(&ptr, bb->bbSysHeapFract);

  ASSERT(ptr - b == 148);

  if (bootcode)
    memcpy(ptr, bootcode, HFS_BOOTCODE1LEN);
  else
    memset(ptr, 0, HFS_BOOTCODE1LEN);

  if (b_writelb(vol, 0, &b) == -1)
    goto fail;

  if (bootcode)
    memcpy(&b, bootcode + HFS_BOOTCODE1LEN, HFS_BOOTCODE2LEN);
  else
    memset(&b, 0, HFS_BOOTCODE2LEN);

  if (b_writelb(vol, 1, &b) == -1)
    goto fail;

  return 0;

fail:
  return -1;
}

/*
 * NAME:	low->getmdb()
 * DESCRIPTION:	read a master directory block
 */
int l_getmdb(hfsvol *vol, MDB *mdb, int backup)
{
  block b;
  const byte *ptr = b;
  int i;

  if (b_readlb(vol, backup ? vol->vlen - 2 : 2, &b) == -1)
    goto fail;

  d_fetchsw(&ptr, &mdb->drSigWord);
  d_fetchsl(&ptr, &mdb->drCrDate);
  d_fetchsl(&ptr, &mdb->drLsMod);
  d_fetchsw(&ptr, &mdb->drAtrb);
  d_fetchuw(&ptr, &mdb->drNmFls);
  d_fetchuw(&ptr, &mdb->drVBMSt);
  d_fetchuw(&ptr, &mdb->drAllocPtr);
  d_fetchuw(&ptr, &mdb->drNmAlBlks);
  d_fetchul(&ptr, &mdb->drAlBlkSiz);
  d_fetchul(&ptr, &mdb->drClpSiz);
  d_fetchuw(&ptr, &mdb->drAlBlSt);
  d_fetchsl(&ptr, &mdb->drNxtCNID);
  d_fetchuw(&ptr, &mdb->drFreeBks);

  d_fetchstr(&ptr, mdb->drVN, sizeof(mdb->drVN));

  ASSERT(ptr - b == 64);

  d_fetchsl(&ptr, &mdb->drVolBkUp);
  d_fetchsw(&ptr, &mdb->drVSeqNum);
  d_fetchul(&ptr, &mdb->drWrCnt);
  d_fetchul(&ptr, &mdb->drXTClpSiz);
  d_fetchul(&ptr, &mdb->drCTClpSiz);
  d_fetchuw(&ptr, &mdb->drNmRtDirs);
  d_fetchul(&ptr, &mdb->drFilCnt);
  d_fetchul(&ptr, &mdb->drDirCnt);

  for (i = 0; i < 8; ++i)
    d_fetchsl(&ptr, &mdb->drFndrInfo[i]);

  ASSERT(ptr - b == 124);

  d_fetchuw(&ptr, &mdb->drEmbedSigWord);
  d_fetchuw(&ptr, &mdb->drEmbedExtent.xdrStABN);
  d_fetchuw(&ptr, &mdb->drEmbedExtent.xdrNumABlks);

  d_fetchul(&ptr, &mdb->drXTFlSize);

  for (i = 0; i < 3; ++i)
    {
      d_fetchuw(&ptr, &mdb->drXTExtRec[i].xdrStABN);
      d_fetchuw(&ptr, &mdb->drXTExtRec[i].xdrNumABlks);
    }

  ASSERT(ptr - b == 146);

  d_fetchul(&ptr, &mdb->drCTFlSize);

  for (i = 0; i < 3; ++i)
    {
      d_fetchuw(&ptr, &mdb->drCTExtRec[i].xdrStABN);
      d_fetchuw(&ptr, &mdb->drCTExtRec[i].xdrNumABlks);
    }

  ASSERT(ptr - b == 162);

  return 0;

fail:
  return -1;
}

/*
 * NAME:	low->putmdb()
 * DESCRIPTION:	write master directory block(s)
 */
int l_putmdb(hfsvol *vol, const MDB *mdb, int backup)
{
  block b;
  byte *ptr = b;
  int i;

  d_storesw(&ptr, mdb->drSigWord);
  d_storesl(&ptr, mdb->drCrDate);
  d_storesl(&ptr, mdb->drLsMod);
  d_storesw(&ptr, mdb->drAtrb);
  d_storeuw(&ptr, mdb->drNmFls);
  d_storeuw(&ptr, mdb->drVBMSt);
  d_storeuw(&ptr, mdb->drAllocPtr);
  d_storeuw(&ptr, mdb->drNmAlBlks);
  d_storeul(&ptr, mdb->drAlBlkSiz);
  d_storeul(&ptr, mdb->drClpSiz);
  d_storeuw(&ptr, mdb->drAlBlSt);
  d_storesl(&ptr, mdb->drNxtCNID);
  d_storeuw(&ptr, mdb->drFreeBks);

  d_storestr(&ptr, mdb->drVN, sizeof(mdb->drVN));

  ASSERT(ptr - b == 64);

  d_storesl(&ptr, mdb->drVolBkUp);
  d_storesw(&ptr, mdb->drVSeqNum);
  d_storeul(&ptr, mdb->drWrCnt);
  d_storeul(&ptr, mdb->drXTClpSiz);
  d_storeul(&ptr, mdb->drCTClpSiz);
  d_storeuw(&ptr, mdb->drNmRtDirs);
  d_storeul(&ptr, mdb->drFilCnt);
  d_storeul(&ptr, mdb->drDirCnt);

  for (i = 0; i < 8; ++i)
    d_storesl(&ptr, mdb->drFndrInfo[i]);

  ASSERT(ptr - b == 124);

  d_storeuw(&ptr, mdb->drEmbedSigWord);
  d_storeuw(&ptr, mdb->drEmbedExtent.xdrStABN);
  d_storeuw(&ptr, mdb->drEmbedExtent.xdrNumABlks);

  d_storeul(&ptr, mdb->drXTFlSize);

  for (i = 0; i < 3; ++i)
    {
      d_storeuw(&ptr, mdb->drXTExtRec[i].xdrStABN);
      d_storeuw(&ptr, mdb->drXTExtRec[i].xdrNumABlks);
    }

  ASSERT(ptr - b == 146);

  d_storeul(&ptr, mdb->drCTFlSize);

  for (i = 0; i < 3; ++i)
    {
      d_storeuw(&ptr, mdb->drCTExtRec[i].xdrStABN);
      d_storeuw(&ptr, mdb->drCTExtRec[i].xdrNumABlks);
    }

  ASSERT(ptr - b == 162);

  memset(ptr, 0, HFS_BLOCKSZ - (ptr - b));

  if (b_writelb(vol, 2, &b) == -1 ||
      (backup && b_writelb(vol, vol->vlen - 2, &b) == -1))
    goto fail;

  return 0;

fail:
  return -1;
}