1266 lines
38 KiB
C
1266 lines
38 KiB
C
/*
|
|
(C) Copyright Digital Instrumentation Technology, Inc., 1990 - 1993
|
|
All Rights Reserved
|
|
*/
|
|
|
|
/* DIT TransferPro macPack.c */
|
|
/* functions to populate structures from buffers read from disk */
|
|
/* and to populate buffers to be written to disk from structures */
|
|
|
|
|
|
#include <malloc.h>
|
|
#include "macSG.h"
|
|
#include "dm.h"
|
|
|
|
static char *Module = "macPack";
|
|
|
|
static void pack(void *, char **, int);
|
|
static void unpack(void *, char **, int);
|
|
|
|
/* -------------------------------------------------------------------------*/
|
|
/* Node UnPack functions: unpack contents of a node buffer into node pointer */
|
|
/* -------------------------------------------------------------------------*/
|
|
|
|
/*--- macUnPackHeaderNode ---------------------
|
|
*
|
|
*/
|
|
|
|
int macUnPackHeaderNode( nptr, nodeBuffer )
|
|
struct header_node *nptr;
|
|
char *nodeBuffer;
|
|
{
|
|
int retval = E_NONE,
|
|
recNum = 0;
|
|
short recOffset = 0;
|
|
char *funcname = "macUnPackHeaderNode";
|
|
|
|
macUnpackNodeDescriptor(&nptr->hnDesc, nodeBuffer);
|
|
|
|
if ( (recOffset = getRecordOffset(recNum++,(short *)nodeBuffer)) < 0 ||
|
|
recOffset > NODE_SIZE )
|
|
{
|
|
retval = set_error( E_RANGE, Module, funcname,
|
|
"Bad data in header node" );
|
|
}
|
|
else
|
|
{
|
|
macUnpackHeaderRec (&nptr->hnHdrRec, nodeBuffer + recOffset);
|
|
|
|
if ( (recOffset = getRecordOffset(recNum++,(short *)nodeBuffer)) < 0 ||
|
|
recOffset > NODE_SIZE )
|
|
{
|
|
retval = set_error( E_RANGE, Module, funcname,
|
|
"Bad data in header node" );
|
|
}
|
|
else
|
|
/* get reserved record (for now we assume it is always the same
|
|
length, and do not attempt to analyze its structure */
|
|
{
|
|
memcpy( nptr->hnResRec, nodeBuffer+recOffset,
|
|
TREE_RESREC_SIZE );
|
|
}
|
|
}
|
|
if ( retval == E_NONE )
|
|
{
|
|
/* get offset for bitmap record */
|
|
if ( (recOffset = getRecordOffset(recNum++,(short *)nodeBuffer)) < 0 ||
|
|
recOffset > NODE_SIZE )
|
|
{
|
|
retval = set_error( E_RANGE, Module, funcname,
|
|
"Bad data in header node" );
|
|
}
|
|
else
|
|
{
|
|
/* get bitmap record contents */
|
|
memcpy((char *)&nptr->hnBitMap, nodeBuffer + recOffset,
|
|
sizeof(struct bitmap_record));
|
|
}
|
|
}
|
|
|
|
return(retval);
|
|
}
|
|
|
|
/*--- macUnPackIndexNode ---------------------
|
|
*
|
|
*/
|
|
int macUnPackIndexNode( treeType, nptr, nodeBuffer )
|
|
int treeType;
|
|
struct index_node *nptr;
|
|
char *nodeBuffer;
|
|
{
|
|
int retval = E_NONE,
|
|
done = 0,
|
|
recNum = 0,
|
|
keySize;
|
|
short recOffset = 0;
|
|
char *recPtr;
|
|
int i;
|
|
|
|
for ( i = 0; i < MAXRECORDS; i++ )
|
|
{
|
|
nptr->inRecList[i] = 0;
|
|
}
|
|
|
|
/* get index node descriptor */
|
|
macUnpackNodeDescriptor(&nptr->inDesc, nodeBuffer);
|
|
|
|
while( !done && retval == E_NONE && (unsigned short)recNum < nptr->inDesc.ndRecs )
|
|
{
|
|
recOffset = getRecordOffset(recNum, (short *)nodeBuffer);
|
|
|
|
if( *(nodeBuffer + recOffset) == 0)
|
|
{
|
|
done = 1;
|
|
}
|
|
else
|
|
{
|
|
recPtr = nodeBuffer+recOffset;
|
|
keySize= (*recPtr % 2)? (int)(*recPtr+1) : (int)(*recPtr+2);
|
|
|
|
if ( (nptr->inRecList[recNum] = (struct pointer_record *)
|
|
malloc(sizeof (struct pointer_record)) ) ==
|
|
(struct pointer_record *)0)
|
|
{
|
|
retval = set_error (E_MEMORY, Module, "macUnPackIndexNode",
|
|
"Insufficient memory.");
|
|
}
|
|
else
|
|
{
|
|
if ( treeType == EXTENTS_TREE )
|
|
{
|
|
macUnpackExtRecordKey ((struct xkrKey *)
|
|
nptr->inRecList[recNum], recPtr);
|
|
}
|
|
else
|
|
{
|
|
macUnpackRecordKey ((struct ckrKey *)
|
|
nptr->inRecList[recNum], recPtr);
|
|
}
|
|
memcpy((char *) &nptr->inRecList[recNum]->ptrPointer,
|
|
recPtr+keySize, 4);
|
|
recNum++;
|
|
}
|
|
}
|
|
}
|
|
|
|
return(retval);
|
|
}
|
|
|
|
/*--- macUnPackLeafNode ---------------------
|
|
*
|
|
*/
|
|
int macUnPackLeafNode( treeType, nptr, nodeBuffer )
|
|
int treeType;
|
|
struct leaf_node *nptr;
|
|
char *nodeBuffer;
|
|
{
|
|
int retval = E_NONE,
|
|
done = 0,
|
|
keySize = 0,
|
|
recNum = 0;
|
|
short recOffset = 0;
|
|
char *bufptr = nodeBuffer,
|
|
*recPtr;
|
|
int i;
|
|
|
|
for ( i = 0; i < MAXRECORDS; i++ )
|
|
{
|
|
nptr->lnRecList[i] = 0;
|
|
}
|
|
|
|
/* get leaf node descriptor */
|
|
macUnpackNodeDescriptor(&nptr->lnDesc, bufptr);
|
|
|
|
/* unpack records from leaf node */
|
|
bufptr += sizeof(struct node_descriptor);
|
|
|
|
while( !done && retval == E_NONE && (unsigned short)recNum < nptr->lnDesc.ndRecs )
|
|
{
|
|
recOffset = getRecordOffset(recNum, (short *)nodeBuffer);
|
|
|
|
/* check if record is null (no more records in node) */
|
|
if( *(nodeBuffer + recOffset) == 0)
|
|
{
|
|
done = 1;
|
|
}
|
|
|
|
/* check if this node is extents leaf node */
|
|
else if( treeType == EXTENT_NODE )
|
|
{
|
|
if ( (nptr->lnRecList[recNum] = (struct extent_record *)
|
|
malloc(sizeof (struct extent_record)) ) ==
|
|
(struct extent_record *)0)
|
|
{
|
|
retval = set_error (E_MEMORY, Module, "macUnPackLeafNode",
|
|
"Insufficient memory.");
|
|
}
|
|
else
|
|
{
|
|
recPtr = nodeBuffer+recOffset;
|
|
macUnpackExtRecordKey (nptr->lnRecList[recNum], recPtr);
|
|
memcpy((char *)
|
|
((struct extent_record *)nptr->lnRecList[recNum])->xkrExtents,
|
|
recPtr+X_KEY_SIZE, sizeof(struct extent_descriptor)*3);
|
|
recNum++;
|
|
}
|
|
}
|
|
else /* deal with particular record lengths individually */
|
|
{
|
|
recPtr = nodeBuffer+recOffset;
|
|
keySize= (*recPtr % 2)? (int)(*recPtr+1) : (int)(*recPtr+2);
|
|
switch( *(recPtr+keySize) )
|
|
{
|
|
/* record is directory record: */
|
|
case DIRECTORY_REC:
|
|
if ( (nptr->lnRecList[recNum] = (struct dir_record *)
|
|
malloc(sizeof (struct dir_record)) ) ==
|
|
(struct dir_record *)0)
|
|
{
|
|
retval = set_error (E_MEMORY, Module,
|
|
"macUnPackLeafNode", "Insufficient memory.");
|
|
}
|
|
else
|
|
{
|
|
macUnpackRecordKey (nptr->lnRecList[recNum],recPtr);
|
|
macUnpackDirRecord ((struct dir_record *)
|
|
nptr->lnRecList[recNum], recPtr+keySize);
|
|
}
|
|
break;
|
|
|
|
/* record is file record: */
|
|
case FILE_REC:
|
|
if ( (nptr->lnRecList[recNum] = (struct file_record *)
|
|
malloc(sizeof (struct file_record)) ) ==
|
|
(struct file_record *)0)
|
|
{
|
|
retval = set_error (E_MEMORY, Module,
|
|
"macUnPackLeafNode", "Insufficient memory.");
|
|
}
|
|
else
|
|
{
|
|
macUnpackRecordKey (nptr->lnRecList[recNum],recPtr);
|
|
macUnpackFileRec ((struct file_record *)
|
|
nptr->lnRecList[recNum], recPtr+keySize);
|
|
}
|
|
break;
|
|
|
|
/* record is thread record: */
|
|
case THREAD_REC:
|
|
if ( (nptr->lnRecList[recNum] = (struct thread_record *)
|
|
malloc(sizeof (struct thread_record)) ) ==
|
|
(struct thread_record *)0)
|
|
{
|
|
retval = set_error (E_MEMORY, Module,
|
|
"macUnPackLeafNode", "Insufficient memory.");
|
|
}
|
|
else
|
|
{
|
|
macUnpackRecordKey (nptr->lnRecList[recNum],recPtr);
|
|
macUnpackThreadRec ((struct thread_record *)
|
|
nptr->lnRecList[recNum], recPtr+keySize);
|
|
}
|
|
break;
|
|
|
|
/* record is alias record: */
|
|
case ALIAS_REC:
|
|
if ( (nptr->lnRecList[recNum] = (struct alias_record *)
|
|
malloc(sizeof (struct alias_record)) ) ==
|
|
(struct alias_record *)0)
|
|
{
|
|
retval = set_error (E_MEMORY, Module,
|
|
"macUnPackLeafNode", "Insufficient memory.");
|
|
}
|
|
else
|
|
{
|
|
macUnpackRecordKey (nptr->lnRecList[recNum],recPtr);
|
|
macUnpackAliasRec ((struct alias_record *)
|
|
nptr->lnRecList[recNum], recPtr+keySize);
|
|
}
|
|
break;
|
|
|
|
/* unknown record type -- bail out! */
|
|
default:
|
|
retval = set_error (E_SYNTAX, Module,
|
|
"macUnpackLeafNode", "Unrecognized record type.");
|
|
break;
|
|
}
|
|
recNum++;
|
|
}
|
|
}
|
|
|
|
return(retval);
|
|
}
|
|
|
|
/*--- macUnPackMapNode ---------------------
|
|
*
|
|
*/
|
|
void macUnPackMapNode( nptr, nodeBuffer )
|
|
struct map_node *nptr;
|
|
char *nodeBuffer;
|
|
{
|
|
|
|
macUnpackNodeDescriptor ((struct node_descriptor *)nptr, nodeBuffer);
|
|
memcpy((char *)&nptr->mnRecList, nodeBuffer + NODE_DESC_SIZE,
|
|
sizeof(struct bitmap_record));
|
|
|
|
}
|
|
|
|
|
|
/* ----------------------------------------------------------------0*/
|
|
/* Node Pack functions: pack a buffer with contents of node pointer */
|
|
/* ----------------------------------------------------------------0*/
|
|
|
|
/*--- macPackTree ---------------------
|
|
*
|
|
*/
|
|
int macPackTree (tree, treeType, vib, buffer)
|
|
struct BtreeNode **tree;
|
|
int treeType;
|
|
struct m_VIB *vib;
|
|
char *buffer;
|
|
{
|
|
int retval = E_NONE,
|
|
nodeCount,
|
|
treeSize = ((treeType == CATALOG_TREE) ?
|
|
vib->drCTFlSize : vib->drXTFlSize)/NODE_SIZE;
|
|
char *funcname="macPackTree";
|
|
|
|
for( nodeCount = 0;
|
|
retval == E_NONE && nodeCount < treeSize;
|
|
nodeCount++, buffer += NODE_SIZE )
|
|
{
|
|
if( !tree[nodeCount] )
|
|
{
|
|
; /* pass over unused nodes */
|
|
}
|
|
else
|
|
{
|
|
switch( tree[nodeCount]->BtNodes.nodeBytes[NODE_TYPE_OFFSET] )
|
|
{
|
|
case HEADER_NODE:
|
|
macPackHeaderNode(buffer,
|
|
(struct header_node *)tree[nodeCount]);
|
|
break;
|
|
case INDEX_NODE:
|
|
macPackIndexNode(treeType, buffer,
|
|
(struct index_node *)tree[nodeCount]);
|
|
break;
|
|
case LEAF_NODE:
|
|
retval = macPackLeafNode(treeType, buffer,
|
|
(struct leaf_node *)tree[nodeCount]);
|
|
break;
|
|
case BITMAP_NODE:
|
|
macPackMapNode(buffer, (struct map_node *)tree[nodeCount]);
|
|
break;
|
|
default:
|
|
retval = set_error(E_RANGE,Module,funcname,
|
|
"Unrecognized node type in catalog or extents tree" );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return(retval);
|
|
}
|
|
|
|
/*--- macPackHeaderNode ---------------------
|
|
*
|
|
*/
|
|
void macPackHeaderNode( nodeBuffer, nptr )
|
|
char *nodeBuffer;
|
|
struct header_node *nptr;
|
|
{
|
|
int recNum = 0,
|
|
count,
|
|
recLen = 0,
|
|
recOffset = 0;
|
|
|
|
for( count=0; count < NODE_SIZE; count++)
|
|
{
|
|
*(nodeBuffer+count) = '\0';
|
|
}
|
|
|
|
macPackNodeDescriptor(nodeBuffer, &nptr->hnDesc);
|
|
|
|
recOffset = 0x0e;
|
|
putRecordOffset((short *)nodeBuffer, recNum++, recOffset);
|
|
|
|
recLen = macPackHeaderRec (&nptr->hnHdrRec, nodeBuffer+recOffset);
|
|
|
|
recOffset += recLen;
|
|
putRecordOffset((short *)nodeBuffer, recNum++, recOffset);
|
|
|
|
/* no write necessary for Reserved Record */
|
|
memcpy( nodeBuffer+recOffset, nptr->hnResRec, TREE_RESREC_SIZE );
|
|
|
|
recOffset += TREE_RESREC_SIZE;
|
|
putRecordOffset((short *)nodeBuffer, recNum++, recOffset);
|
|
|
|
memcpy( nodeBuffer+recOffset, &nptr->hnBitMap,
|
|
sizeof(struct bitmap_record));
|
|
|
|
/* write freespace offset */
|
|
recOffset += sizeof(struct bitmap_record);
|
|
putRecordOffset((short *)nodeBuffer, recNum, recOffset);
|
|
|
|
}
|
|
|
|
/*--- macPackIndexNode ---------------------
|
|
*
|
|
*/
|
|
void macPackIndexNode( treeType, nodeBuffer, nptr )
|
|
int treeType;
|
|
char *nodeBuffer;
|
|
struct index_node *nptr;
|
|
{
|
|
int recNum = 0,
|
|
count,
|
|
recOffset = 0,
|
|
keylen;
|
|
|
|
for( count=0; count < NODE_SIZE; count++)
|
|
{
|
|
*(nodeBuffer+count) = '\0';
|
|
}
|
|
|
|
macPackNodeDescriptor(nodeBuffer, &nptr->inDesc);
|
|
|
|
recOffset = 0x0e;
|
|
putRecordOffset((short *)nodeBuffer, recNum, recOffset);
|
|
|
|
while( (unsigned short)recNum < nptr->inDesc.ndRecs )
|
|
{
|
|
if ( treeType == EXTENTS_TREE )
|
|
{
|
|
keylen = macPackExtRecordKey(nodeBuffer+recOffset,
|
|
(struct xkrKey *)nptr->inRecList[recNum]);
|
|
}
|
|
else
|
|
{
|
|
keylen = macPackRecordKey( nodeBuffer+recOffset,
|
|
(struct ckrKey *)nptr->inRecList[recNum] );
|
|
}
|
|
memcpy( nodeBuffer+recOffset+keylen,
|
|
&nptr->inRecList[recNum]->ptrPointer,
|
|
sizeof(unsigned int) );
|
|
recOffset += keylen + sizeof( unsigned int );
|
|
recNum++;
|
|
putRecordOffset((short *)nodeBuffer, recNum, recOffset);
|
|
}
|
|
|
|
if ( nptr->inDesc.ndRecs == 0 )
|
|
{
|
|
/* write free space offset */
|
|
putRecordOffset( (short *)nodeBuffer, recNum, recOffset );
|
|
}
|
|
|
|
}
|
|
|
|
/*--- macPackLeafNode ---------------------
|
|
*
|
|
*/
|
|
int macPackLeafNode( treeType, nodeBuffer, nptr )
|
|
int treeType;
|
|
char *nodeBuffer;
|
|
struct leaf_node *nptr;
|
|
{
|
|
int retval = E_NONE,
|
|
recNum = 0,
|
|
count,
|
|
recOffset = 0,
|
|
keylen,
|
|
datalen;
|
|
char *funcname="macPackLeafNode";
|
|
|
|
for ( count=0; count < NODE_SIZE; count++)
|
|
{
|
|
*(nodeBuffer+count) = '\0';
|
|
}
|
|
|
|
macPackNodeDescriptor(nodeBuffer,&nptr->lnDesc);
|
|
recOffset = 0x0e;
|
|
putRecordOffset((short *)nodeBuffer, recNum, recOffset);
|
|
|
|
while( retval == E_NONE && (unsigned short)recNum < nptr->lnDesc.ndRecs )
|
|
{
|
|
if( treeType == EXTENTS_TREE )
|
|
{
|
|
keylen = macPackExtRecordKey(nodeBuffer+recOffset,
|
|
(struct xkrKey *)nptr->lnRecList[recNum]);
|
|
datalen = 3*sizeof(struct extent_descriptor);
|
|
|
|
memcpy( nodeBuffer+recOffset+keylen,
|
|
(char *)(((struct extent_record *)
|
|
nptr->lnRecList[recNum])->xkrExtents), datalen );
|
|
}
|
|
else
|
|
{
|
|
keylen = macPackRecordKey( nodeBuffer+recOffset,
|
|
nptr->lnRecList[recNum] );
|
|
|
|
switch ( *((char *)nptr->lnRecList[recNum] +
|
|
sizeof(struct record_key)) )
|
|
{
|
|
case FILE_REC:
|
|
datalen = macPackFileRec ((struct file_record *)
|
|
nptr->lnRecList[recNum], nodeBuffer + recOffset + keylen);
|
|
break;
|
|
case DIRECTORY_REC:
|
|
datalen = macPackDirRecord ((struct dir_record *)
|
|
nptr->lnRecList[recNum], nodeBuffer + recOffset + keylen);
|
|
break;
|
|
case THREAD_REC:
|
|
datalen = macPackThreadRec ((struct thread_record *)
|
|
nptr->lnRecList[recNum], nodeBuffer + recOffset + keylen);
|
|
break;
|
|
case ALIAS_REC:
|
|
datalen = macPackAliasRec ((struct alias_record *)
|
|
nptr->lnRecList[recNum], nodeBuffer + recOffset + keylen);
|
|
break;
|
|
default:
|
|
retval = set_error( E_RANGE, Module, funcname,
|
|
"Unrecognized record in leaf node");
|
|
break;
|
|
}
|
|
}
|
|
datalen = datalen % 2 ? datalen + 1 : datalen;
|
|
recOffset += keylen + datalen;
|
|
recNum++;
|
|
putRecordOffset((short *)nodeBuffer, recNum, recOffset);
|
|
}
|
|
if ( nptr->lnDesc.ndRecs == 0 )
|
|
{
|
|
/* write free space offset */
|
|
putRecordOffset((short *)nodeBuffer, recNum, recOffset);
|
|
}
|
|
|
|
return( retval );
|
|
}
|
|
|
|
/*--- macPackMapNode ---------------------
|
|
*
|
|
*/
|
|
void macPackMapNode( nodeBuffer, nptr )
|
|
char *nodeBuffer;
|
|
struct map_node *nptr;
|
|
{
|
|
int count,
|
|
recOffset = 0;
|
|
|
|
for ( count=0; count < NODE_SIZE; count++)
|
|
{
|
|
*(nodeBuffer+count) = '\0';
|
|
}
|
|
|
|
macPackNodeDescriptor(nodeBuffer,&nptr->mnDesc);
|
|
recOffset = 0x0e;
|
|
|
|
putRecordOffset((short *)nodeBuffer, 0, recOffset);
|
|
|
|
memcpy( nodeBuffer+recOffset, &nptr->mnRecList,
|
|
sizeof(struct bitmap_record) );
|
|
recOffset += sizeof(struct bitmap_record);
|
|
|
|
/* write freespace offset */
|
|
putRecordOffset((short *)nodeBuffer, 1, recOffset);
|
|
|
|
}
|
|
|
|
/*-- macPackVIB -----------------------------------------*/
|
|
|
|
void macPackVIB (vib, buffer)
|
|
struct m_VIB *vib;
|
|
char *buffer;
|
|
{
|
|
|
|
char *bufptr = buffer;
|
|
|
|
pack (&vib->drSigWord, &bufptr, 2);
|
|
pack (&vib->drCrDate, &bufptr, 4);
|
|
pack (&vib->drLsMod, &bufptr, 4);
|
|
pack (&vib->drAtrb, &bufptr, 2);
|
|
pack (&vib->drNmFls, &bufptr, 2);
|
|
pack (&vib->drVBMSt, &bufptr, 2);
|
|
pack (&vib->drAllocPtr, &bufptr, 2);
|
|
pack (&vib->drNmAlblks, &bufptr, 2);
|
|
pack (&vib->drAlBlkSiz, &bufptr, 4);
|
|
pack (&vib->drClpSiz, &bufptr, 4);
|
|
pack (&vib->drAlBlSt, &bufptr, 2);
|
|
pack (&vib->drNxtCNID, &bufptr, 4);
|
|
pack (&vib->drFreeBks, &bufptr, 2);
|
|
pack (&vib->drVolNameLen, &bufptr, 1);
|
|
pack (vib->drVolName, &bufptr, MAX_MAC_VOL_NAME);
|
|
pack (&vib->drVolBkUp, &bufptr, 4);
|
|
pack (&vib->drVSeqNum, &bufptr, 2);
|
|
pack (&vib->drWrCnt, &bufptr, 4);
|
|
pack (&vib->drXTClpSiz, &bufptr, 4);
|
|
pack (&vib->drCTClpSiz, &bufptr, 4);
|
|
pack (&vib->drNmRtDirs, &bufptr, 2);
|
|
pack (&vib->drFilCnt, &bufptr, 4);
|
|
pack (&vib->drDirCnt, &bufptr, 4);
|
|
pack (vib->drFndrInfo, &bufptr, MAX_FNDRINFO_SIZE);
|
|
pack (&vib->drVCSiz, &bufptr, 2);
|
|
pack (&vib->drVBMSiz, &bufptr, 2);
|
|
pack (&vib->drCtlCSiz, &bufptr, 2);
|
|
pack (&vib->drXTFlSize, &bufptr, 4);
|
|
pack (vib->drXTExtRec, &bufptr, sizeof (struct extent_descriptor) * 3);
|
|
pack (&vib->drCTFlSize, &bufptr, 4);
|
|
pack (vib->drCTExtRec, &bufptr, sizeof (struct extent_descriptor) * 3);
|
|
pack (vib->drUnused, &bufptr, 350);
|
|
}
|
|
|
|
/*-- macUnpackVIB -----------------------------------------*/
|
|
|
|
void macUnpackVIB (vib, buffer)
|
|
struct m_VIB *vib;
|
|
char *buffer;
|
|
{
|
|
|
|
char *bufptr = buffer;
|
|
|
|
unpack (&vib->drSigWord, &bufptr, 2);
|
|
unpack (&vib->drCrDate, &bufptr, 4);
|
|
unpack (&vib->drLsMod, &bufptr, 4);
|
|
unpack (&vib->drAtrb, &bufptr, 2);
|
|
unpack (&vib->drNmFls, &bufptr, 2);
|
|
unpack (&vib->drVBMSt, &bufptr, 2);
|
|
unpack (&vib->drAllocPtr, &bufptr, 2);
|
|
unpack (&vib->drNmAlblks, &bufptr, 2);
|
|
unpack (&vib->drAlBlkSiz, &bufptr, 4);
|
|
unpack (&vib->drClpSiz, &bufptr, 4);
|
|
unpack (&vib->drAlBlSt, &bufptr, 2);
|
|
unpack (&vib->drNxtCNID, &bufptr, 4);
|
|
unpack (&vib->drFreeBks, &bufptr, 2);
|
|
unpack (&vib->drVolNameLen, &bufptr, 1);
|
|
unpack (vib->drVolName, &bufptr, MAX_MAC_VOL_NAME);
|
|
unpack (&vib->drVolBkUp, &bufptr, 4);
|
|
unpack (&vib->drVSeqNum, &bufptr, 2);
|
|
unpack (&vib->drWrCnt, &bufptr, 4);
|
|
unpack (&vib->drXTClpSiz, &bufptr, 4);
|
|
unpack (&vib->drCTClpSiz, &bufptr, 4);
|
|
unpack (&vib->drNmRtDirs, &bufptr, 2);
|
|
unpack (&vib->drFilCnt, &bufptr, 4);
|
|
unpack (&vib->drDirCnt, &bufptr, 4);
|
|
unpack (vib->drFndrInfo, &bufptr, MAX_FNDRINFO_SIZE);
|
|
unpack (&vib->drVCSiz, &bufptr, 2);
|
|
unpack (&vib->drVBMSiz, &bufptr, 2);
|
|
unpack (&vib->drCtlCSiz, &bufptr, 2);
|
|
unpack (&vib->drXTFlSize, &bufptr, 4);
|
|
unpack (vib->drXTExtRec, &bufptr, sizeof (struct extent_descriptor) * 3);
|
|
unpack (&vib->drCTFlSize, &bufptr, 4);
|
|
unpack (vib->drCTExtRec, &bufptr, sizeof (struct extent_descriptor) * 3);
|
|
}
|
|
|
|
/*-- UTILITY FUNCTIONS FOR USE BY MACPACK AND OTHERS ------
|
|
*
|
|
*---------------------------------------------------------*/
|
|
|
|
/*-- pack ----------------------*/
|
|
|
|
static void pack ( val, bufptr, size)
|
|
void *val;
|
|
char **bufptr;
|
|
int size;
|
|
{
|
|
memcpy (*bufptr, (char *)val, size);
|
|
*bufptr += size;
|
|
}
|
|
|
|
/*-- unpack ----------------------*/
|
|
|
|
static void unpack (val, bufptr, size)
|
|
void *val;
|
|
char **bufptr;
|
|
int size;
|
|
{
|
|
memcpy (val, *bufptr, size);
|
|
*bufptr += size;
|
|
}
|
|
|
|
/*-- macUnpackOldPartitionMap ---
|
|
*
|
|
*/
|
|
void macUnpackOldPartitionMap( mapRec, buffer )
|
|
struct m_OldPartitionMap *mapRec;
|
|
char *buffer;
|
|
{
|
|
char *bufptr = buffer;
|
|
|
|
unpack (&mapRec->pdSig, &bufptr, 2);
|
|
unpack (&mapRec->pdPartition->pdStart, &bufptr, 4);
|
|
unpack (&mapRec->pdPartition->pdSize, &bufptr, 4);
|
|
unpack (mapRec->pdPartition->pdFSID, &bufptr, 4);
|
|
unpack (mapRec->pdUnused, &bufptr, 6);
|
|
|
|
}
|
|
|
|
/*-- macPackOldPartitionMap --
|
|
*
|
|
*/
|
|
int macPackOldPartitionMap ( mapRec, buffer )
|
|
struct m_OldPartitionMap *mapRec;
|
|
char *buffer;
|
|
{
|
|
char *bufptr = buffer;
|
|
int retval = E_NONE;
|
|
|
|
pack (&mapRec->pdSig, &bufptr, 2);
|
|
pack (&mapRec->pdPartition->pdStart, &bufptr, 4);
|
|
pack (&mapRec->pdPartition->pdSize, &bufptr, 4);
|
|
pack (mapRec->pdPartition->pdFSID, &bufptr, 4);
|
|
pack (mapRec->pdUnused, &bufptr, 6);
|
|
|
|
|
|
retval = bufptr - buffer;
|
|
return( retval );
|
|
}
|
|
|
|
/*-- macPackDriverMap --
|
|
*
|
|
*/
|
|
int macPackDriverMap ( mapRec, buffer )
|
|
struct m_DriverMap *mapRec;
|
|
char *buffer;
|
|
{
|
|
char *bufptr = buffer;
|
|
int retval = E_NONE;
|
|
|
|
pack (&mapRec->sbSig, &bufptr, 2);
|
|
pack (&mapRec->sbBlockSize, &bufptr, 2);
|
|
pack (&mapRec->sbBlkCount, &bufptr, 4);
|
|
pack (&mapRec->sbDevType, &bufptr, 2);
|
|
pack (&mapRec->sbDevID, &bufptr, 2);
|
|
pack (&mapRec->sbData, &bufptr, 4);
|
|
pack (&mapRec->sbDrvrCount, &bufptr, 2);
|
|
retval = bufptr - buffer;
|
|
return (retval);
|
|
}
|
|
|
|
/*-- macUnpackDriverMap --
|
|
*
|
|
*/
|
|
void macUnpackDriverMap ( mapRec, buffer )
|
|
struct m_DriverMap *mapRec;
|
|
char *buffer;
|
|
{
|
|
char *bufptr = buffer;
|
|
|
|
unpack (&mapRec->sbSig, &bufptr, 2);
|
|
unpack (&mapRec->sbBlockSize, &bufptr, 2);
|
|
unpack (&mapRec->sbBlkCount, &bufptr, 4);
|
|
unpack (&mapRec->sbDevType, &bufptr, 2);
|
|
unpack (&mapRec->sbDevID, &bufptr, 2);
|
|
unpack (&mapRec->sbData, &bufptr, 4);
|
|
unpack (&mapRec->sbDrvrCount, &bufptr, 2);
|
|
}
|
|
|
|
/*-- macUnpackPartitionMap --
|
|
*
|
|
*/
|
|
void macUnpackPartitionMap ( mapRec, buffer )
|
|
struct m_PartitionMap *mapRec;
|
|
char *buffer;
|
|
{
|
|
char *bufptr = buffer;
|
|
|
|
unpack (&mapRec->pmSig, &bufptr, 2);
|
|
unpack (&mapRec->pmSigPad, &bufptr, 2);
|
|
unpack (&mapRec->pmMapBlkCnt, &bufptr, 4);
|
|
unpack (&mapRec->pmPyPartStart, &bufptr, 4);
|
|
unpack (&mapRec->pmPartBlkCnt, &bufptr, 4);
|
|
unpack (mapRec->pmPartName, &bufptr, 32);
|
|
unpack (mapRec->pmPartType, &bufptr, 32);
|
|
unpack (&mapRec->pmLgDataStart, &bufptr, 4);
|
|
unpack (&mapRec->pmDataCnt, &bufptr, 4);
|
|
unpack (&mapRec->pmPartStatus, &bufptr, 4);
|
|
unpack (&mapRec->pmLgBootStart, &bufptr, 4);
|
|
unpack (&mapRec->pmBootSize, &bufptr, 4);
|
|
unpack (&mapRec->pmBootLoad, &bufptr, 4);
|
|
unpack (&mapRec->pmBootLoad2, &bufptr, 4);
|
|
unpack (&mapRec->pmBootEntry, &bufptr, 4);
|
|
unpack (&mapRec->pmBootEntry2, &bufptr, 4);
|
|
unpack (&mapRec->pmBootCksum, &bufptr, 4);
|
|
unpack (mapRec->pmProcessor, &bufptr, 16);
|
|
unpack (mapRec->pmBootBytes, &bufptr, 128);
|
|
unpack (mapRec->pmUnused, &bufptr, 248);
|
|
}
|
|
|
|
/*-- macPackPartitionMap --------
|
|
*
|
|
*/
|
|
|
|
int macPackPartitionMap( mapRec, buffer )
|
|
struct m_PartitionMap *mapRec;
|
|
char *buffer;
|
|
{
|
|
int retval = E_NONE;
|
|
char *bufptr = buffer;
|
|
|
|
pack (&mapRec->pmSig, &bufptr, 2);
|
|
pack (&mapRec->pmSigPad, &bufptr, 2);
|
|
pack (&mapRec->pmMapBlkCnt, &bufptr, 4);
|
|
pack (&mapRec->pmPyPartStart, &bufptr, 4);
|
|
pack (&mapRec->pmPartBlkCnt, &bufptr, 4);
|
|
pack (mapRec->pmPartName, &bufptr, 32);
|
|
pack (mapRec->pmPartType, &bufptr, 32);
|
|
pack (&mapRec->pmLgDataStart, &bufptr, 4);
|
|
pack (&mapRec->pmDataCnt, &bufptr, 4);
|
|
pack (&mapRec->pmPartStatus, &bufptr, 4);
|
|
pack (&mapRec->pmLgBootStart, &bufptr, 4);
|
|
pack (&mapRec->pmBootSize, &bufptr, 4);
|
|
pack (&mapRec->pmBootLoad, &bufptr, 4);
|
|
pack (&mapRec->pmBootLoad2, &bufptr, 4);
|
|
pack (&mapRec->pmBootEntry, &bufptr, 4);
|
|
pack (&mapRec->pmBootEntry2, &bufptr, 4);
|
|
pack (&mapRec->pmBootCksum, &bufptr, 4);
|
|
pack (mapRec->pmProcessor, &bufptr, 16);
|
|
pack (mapRec->pmBootBytes, &bufptr, 128);
|
|
pack (mapRec->pmUnused, &bufptr, 248);
|
|
|
|
|
|
retval = bufptr - buffer;
|
|
return( retval );
|
|
}
|
|
|
|
/*-- macPackDirRecord -----------
|
|
*
|
|
*/
|
|
|
|
int macPackDirRecord( dirRec, buffer )
|
|
struct dir_record *dirRec;
|
|
char *buffer;
|
|
{
|
|
int retval = 0;
|
|
char *bufptr = buffer;
|
|
|
|
pack (&dirRec->dirType, &bufptr, 1);
|
|
pack (&dirRec->dirReserv2, &bufptr, 1);
|
|
pack (&dirRec->dirFlags, &bufptr, 2);
|
|
pack (&dirRec->dirVal, &bufptr, 2);
|
|
pack (&dirRec->dirDirID, &bufptr, 4);
|
|
pack (&dirRec->dirCrDat, &bufptr, 4);
|
|
pack (&dirRec->dirMdDat, &bufptr, 4);
|
|
pack (&dirRec->dirBkDat, &bufptr, 4);
|
|
pack (&dirRec->dirUsrInfo.frRect.top, &bufptr, 2);
|
|
pack (&dirRec->dirUsrInfo.frRect.left, &bufptr, 2);
|
|
pack (&dirRec->dirUsrInfo.frRect.bottom, &bufptr, 2);
|
|
pack (&dirRec->dirUsrInfo.frRect.right, &bufptr, 2);
|
|
pack (&dirRec->dirUsrInfo.frFlags, &bufptr, 2);
|
|
pack (&dirRec->dirUsrInfo.frLocation.v, &bufptr, 2);
|
|
pack (&dirRec->dirUsrInfo.frLocation.h, &bufptr, 2);
|
|
pack (&dirRec->dirUsrInfo.frView, &bufptr, 2);
|
|
pack (&dirRec->dirFndrInfo.frScroll.v, &bufptr, 2);
|
|
pack (&dirRec->dirFndrInfo.frScroll.h, &bufptr, 2);
|
|
pack (&dirRec->dirFndrInfo.frOpenChain, &bufptr, 4);
|
|
pack (&dirRec->dirFndrInfo.frScript, &bufptr, 1);
|
|
pack (&dirRec->dirFndrInfo.frXFlags, &bufptr, 1);
|
|
pack (&dirRec->dirFndrInfo.frComment, &bufptr, 2);
|
|
pack (&dirRec->dirFndrInfo.frPutAway, &bufptr, 4);
|
|
pack (dirRec->dirReserv, &bufptr, TYP_FNDR_SIZE);
|
|
|
|
retval = bufptr - buffer;
|
|
return( retval );
|
|
}
|
|
|
|
/*-- macUnpackDirRecord -----------
|
|
*
|
|
*/
|
|
|
|
void macUnpackDirRecord( dirRec, buffer )
|
|
struct dir_record *dirRec;
|
|
char *buffer;
|
|
{
|
|
char *bufptr = buffer;
|
|
|
|
unpack (&dirRec->dirType, &bufptr, 1);
|
|
unpack (&dirRec->dirReserv2, &bufptr, 1);
|
|
unpack (&dirRec->dirFlags, &bufptr, 2);
|
|
unpack (&dirRec->dirVal, &bufptr, 2);
|
|
unpack (&dirRec->dirDirID, &bufptr, 4);
|
|
unpack (&dirRec->dirCrDat, &bufptr, 4);
|
|
unpack (&dirRec->dirMdDat, &bufptr, 4);
|
|
unpack (&dirRec->dirBkDat, &bufptr, 4);
|
|
unpack (&dirRec->dirUsrInfo.frRect.top, &bufptr, 2);
|
|
unpack (&dirRec->dirUsrInfo.frRect.left, &bufptr, 2);
|
|
unpack (&dirRec->dirUsrInfo.frRect.bottom, &bufptr, 2);
|
|
unpack (&dirRec->dirUsrInfo.frRect.right, &bufptr, 2);
|
|
unpack (&dirRec->dirUsrInfo.frFlags, &bufptr, 2);
|
|
unpack (&dirRec->dirUsrInfo.frLocation.v, &bufptr, 2);
|
|
unpack (&dirRec->dirUsrInfo.frLocation.h, &bufptr, 2);
|
|
unpack (&dirRec->dirUsrInfo.frView, &bufptr, 2);
|
|
unpack (&dirRec->dirFndrInfo.frScroll.v, &bufptr, 2);
|
|
unpack (&dirRec->dirFndrInfo.frScroll.h, &bufptr, 2);
|
|
unpack (&dirRec->dirFndrInfo.frOpenChain, &bufptr, 4);
|
|
unpack (&dirRec->dirFndrInfo.frScript, &bufptr, 1);
|
|
unpack (&dirRec->dirFndrInfo.frXFlags, &bufptr, 1);
|
|
unpack (&dirRec->dirFndrInfo.frComment, &bufptr, 2);
|
|
unpack (&dirRec->dirFndrInfo.frPutAway, &bufptr, 4);
|
|
unpack (dirRec->dirReserv, &bufptr, TYP_FNDR_SIZE);
|
|
|
|
}
|
|
|
|
/*-- macPackFileRec -----------
|
|
*
|
|
*/
|
|
|
|
int macPackFileRec( fileRec, buffer )
|
|
struct file_record *fileRec;
|
|
char *buffer;
|
|
{
|
|
int retval = E_NONE;
|
|
char *bufptr = buffer;
|
|
|
|
pack (&fileRec->cdrType, &bufptr, 1);
|
|
pack (&fileRec->cdrReserv2, &bufptr, 1);
|
|
pack (&fileRec->filFlags, &bufptr, 1);
|
|
pack (&fileRec->filType, &bufptr, 1);
|
|
pack (fileRec->filUsrWds.fdType, &bufptr, 4);
|
|
pack (fileRec->filUsrWds.fdCreator, &bufptr, 4);
|
|
pack (&fileRec->filUsrWds.fdFlags, &bufptr, 2);
|
|
pack (&fileRec->filUsrWds.fdLocation.v, &bufptr, 2);
|
|
pack (&fileRec->filUsrWds.fdLocation.h, &bufptr, 2);
|
|
pack (&fileRec->filUsrWds.fdFldr, &bufptr, 2);
|
|
pack (&fileRec->filFlNum, &bufptr, 4);
|
|
pack (&fileRec->filStBlk, &bufptr, 2);
|
|
pack (&fileRec->filLgLen, &bufptr, 4);
|
|
pack (&fileRec->filPyLen, &bufptr, 4);
|
|
pack (&fileRec->filRStBlk, &bufptr, 2);
|
|
pack (&fileRec->filRLgLen, &bufptr, 4);
|
|
pack (&fileRec->filRPyLen, &bufptr, 4);
|
|
pack (&fileRec->filCrDat, &bufptr, 4);
|
|
pack (&fileRec->filMdDat, &bufptr, 4);
|
|
pack (&fileRec->filBkDat, &bufptr, 4);
|
|
pack (&fileRec->filFndrInfo.fdIconID, &bufptr, 2);
|
|
pack (fileRec->filFndrInfo.fdUnused, &bufptr, 6);
|
|
pack (&fileRec->filFndrInfo.fdScript, &bufptr, 1);
|
|
pack (&fileRec->filFndrInfo.fdXFlags, &bufptr, 1);
|
|
pack (&fileRec->filFndrInfo.fdComment, &bufptr, 2);
|
|
pack (&fileRec->filFndrInfo.fdPutAway, &bufptr, 4);
|
|
pack (&fileRec->filClpSize, &bufptr, 2);
|
|
pack (fileRec->filExtRec, &bufptr, sizeof(struct extent_descriptor)*3);
|
|
pack (fileRec->filRExtRec, &bufptr, sizeof(struct extent_descriptor)*3);
|
|
pack (&fileRec->filReserv, &bufptr, 4);
|
|
|
|
retval = bufptr - buffer;
|
|
return (retval);
|
|
}
|
|
|
|
/*-- macUnpackFileRec -----------
|
|
*
|
|
*/
|
|
|
|
void macUnpackFileRec( fileRec, buffer )
|
|
struct file_record *fileRec;
|
|
char *buffer;
|
|
{
|
|
char *bufptr = buffer;
|
|
|
|
unpack (&fileRec->cdrType, &bufptr, 1);
|
|
unpack (&fileRec->cdrReserv2, &bufptr, 1);
|
|
unpack (&fileRec->filFlags, &bufptr, 1);
|
|
unpack (&fileRec->filType, &bufptr, 1);
|
|
unpack (fileRec->filUsrWds.fdType, &bufptr, 4);
|
|
unpack (fileRec->filUsrWds.fdCreator, &bufptr, 4);
|
|
unpack (&fileRec->filUsrWds.fdFlags, &bufptr, 2);
|
|
unpack (&fileRec->filUsrWds.fdLocation.v, &bufptr, 2);
|
|
unpack (&fileRec->filUsrWds.fdLocation.h, &bufptr, 2);
|
|
unpack (&fileRec->filUsrWds.fdFldr, &bufptr, 2);
|
|
unpack (&fileRec->filFlNum, &bufptr, 4);
|
|
unpack (&fileRec->filStBlk, &bufptr, 2);
|
|
unpack (&fileRec->filLgLen, &bufptr, 4);
|
|
unpack (&fileRec->filPyLen, &bufptr, 4);
|
|
unpack (&fileRec->filRStBlk, &bufptr, 2);
|
|
unpack (&fileRec->filRLgLen, &bufptr, 4);
|
|
unpack (&fileRec->filRPyLen, &bufptr, 4);
|
|
unpack (&fileRec->filCrDat, &bufptr, 4);
|
|
unpack (&fileRec->filMdDat, &bufptr, 4);
|
|
unpack (&fileRec->filBkDat, &bufptr, 4);
|
|
unpack (&fileRec->filFndrInfo.fdIconID, &bufptr, 2);
|
|
unpack (fileRec->filFndrInfo.fdUnused, &bufptr, 6);
|
|
unpack (&fileRec->filFndrInfo.fdScript, &bufptr, 1);
|
|
unpack (&fileRec->filFndrInfo.fdXFlags, &bufptr, 1);
|
|
unpack (&fileRec->filFndrInfo.fdComment, &bufptr, 2);
|
|
unpack (&fileRec->filFndrInfo.fdPutAway, &bufptr, 4);
|
|
unpack (&fileRec->filClpSize, &bufptr, 2);
|
|
unpack (fileRec->filExtRec, &bufptr, sizeof(struct extent_descriptor)*3);
|
|
unpack (fileRec->filRExtRec, &bufptr, sizeof(struct extent_descriptor)*3);
|
|
unpack (&fileRec->filReserv, &bufptr, 4);
|
|
|
|
}
|
|
|
|
/*-- macPackThreadRec -----------
|
|
*
|
|
*/
|
|
|
|
int macPackThreadRec( thdRec, buffer )
|
|
struct thread_record *thdRec;
|
|
char *buffer;
|
|
{
|
|
int retval = E_NONE;
|
|
char *bufptr = buffer;
|
|
|
|
pack (&thdRec->thdType, &bufptr, 1);
|
|
pack (&thdRec->thdReserv2, &bufptr, 1);
|
|
pack (thdRec->thdReserv, &bufptr, 8);
|
|
pack (&thdRec->thdParID, &bufptr, 4);
|
|
pack (&thdRec->thdCNameLen, &bufptr, 1);
|
|
pack (thdRec->thdCName, &bufptr, MAXMACNAME);
|
|
|
|
retval = bufptr - buffer;
|
|
return (retval);
|
|
}
|
|
|
|
/*-- macUnpackThreadRec -----------
|
|
*
|
|
*/
|
|
|
|
void macUnpackThreadRec( thdRec, buffer )
|
|
struct thread_record *thdRec;
|
|
char *buffer;
|
|
{
|
|
char *bufptr = buffer;
|
|
|
|
unpack (&thdRec->thdType, &bufptr, 1);
|
|
unpack (&thdRec->thdReserv2, &bufptr, 1);
|
|
unpack (thdRec->thdReserv, &bufptr, 8);
|
|
unpack (&thdRec->thdParID, &bufptr, 4);
|
|
unpack (&thdRec->thdCNameLen, &bufptr, 1);
|
|
unpack (thdRec->thdCName, &bufptr, MAXMACNAME);
|
|
|
|
}
|
|
|
|
/*-- macPackAliasRec --------------
|
|
*
|
|
*/
|
|
|
|
int macPackAliasRec (alsRec, buffer )
|
|
struct alias_record *alsRec;
|
|
char *buffer;
|
|
{
|
|
int retval = E_NONE;
|
|
char *bufptr = buffer;
|
|
|
|
pack (&alsRec->cdrType, &bufptr, 1);
|
|
pack (&alsRec->cdrReserv2, &bufptr, 1);
|
|
pack (alsRec->alsFlags, &bufptr, 12);
|
|
pack (&alsRec->alsNameLen, &bufptr, 1);
|
|
pack (alsRec->alsName, &bufptr, MAXMACNAME);
|
|
|
|
retval = bufptr - buffer;
|
|
return (retval);
|
|
}
|
|
|
|
/*-- macUnpackAliasRec ---------------
|
|
*
|
|
*/
|
|
|
|
void macUnpackAliasRec (alsRec, buffer )
|
|
struct alias_record *alsRec;
|
|
char *buffer;
|
|
{
|
|
char *bufptr = buffer;
|
|
|
|
unpack (&alsRec->cdrType, &bufptr, 1);
|
|
unpack (&alsRec->cdrReserv2, &bufptr, 1);
|
|
unpack (alsRec->alsFlags, &bufptr, 12);
|
|
unpack (&alsRec->alsNameLen, &bufptr, 1);
|
|
unpack (alsRec->alsName, &bufptr, MAXMACNAME);
|
|
}
|
|
|
|
|
|
/*-- macUnpackRecordKey -----------
|
|
*
|
|
*/
|
|
|
|
void macUnpackRecordKey( keyptr, buffer )
|
|
struct ckrKey *keyptr;
|
|
char *buffer;
|
|
{
|
|
char *bufptr = buffer;
|
|
|
|
unpack (&keyptr->ckrKeyLen, &bufptr, 1);
|
|
unpack (&keyptr->ckrResrvl, &bufptr, 1);
|
|
unpack (&keyptr->ckrParID, &bufptr, 4);
|
|
unpack (&keyptr->ckrNameLen, &bufptr, 1);
|
|
unpack (keyptr->ckrCName, &bufptr, keyptr->ckrNameLen);
|
|
keyptr->ckrCName[keyptr->ckrNameLen] = '\0';
|
|
|
|
}
|
|
|
|
/*-- macPackRecordKey -----------
|
|
*
|
|
* Returns length taken by key (including length of key and any padding)
|
|
*
|
|
*/
|
|
|
|
int macPackRecordKey( buffer, keyptr )
|
|
char *buffer;
|
|
struct ckrKey *keyptr;
|
|
{
|
|
int retval;
|
|
char *bufptr = buffer;
|
|
|
|
keyptr->ckrKeyLen += (keyptr->ckrKeyLen % 2)? 0 : 1;
|
|
retval = keyptr->ckrKeyLen + 1;
|
|
|
|
pack (&keyptr->ckrKeyLen, &bufptr, 1);
|
|
pack (&keyptr->ckrResrvl, &bufptr, 1);
|
|
pack (&keyptr->ckrParID, &bufptr, 4);
|
|
pack (&keyptr->ckrNameLen, &bufptr, 1);
|
|
pack (keyptr->ckrCName, &bufptr, keyptr->ckrNameLen);
|
|
|
|
return( retval );
|
|
}
|
|
|
|
/*-- macPackExtRecordKey -----------
|
|
*
|
|
*
|
|
*/
|
|
|
|
int macPackExtRecordKey( buffer, keyptr )
|
|
char *buffer;
|
|
struct xkrKey *keyptr;
|
|
{
|
|
int retval;
|
|
char *bufptr = buffer;
|
|
|
|
pack (&keyptr->xkrKeyLen, &bufptr, 1);
|
|
pack (&keyptr->xkrFkType, &bufptr, 1);
|
|
pack (&keyptr->xkrFNum, &bufptr, 4);
|
|
pack (&keyptr->xkrFABN, &bufptr, 2);
|
|
|
|
retval = bufptr - buffer;
|
|
return( retval );
|
|
}
|
|
|
|
/*-- macUnpackExtRecordKey -----------
|
|
*
|
|
*
|
|
*/
|
|
|
|
void macUnpackExtRecordKey( keyptr, buffer )
|
|
struct xkrKey *keyptr;
|
|
char *buffer;
|
|
{
|
|
char *bufptr = buffer;
|
|
|
|
unpack (&keyptr->xkrKeyLen, &bufptr, 1);
|
|
unpack (&keyptr->xkrFkType, &bufptr, 1);
|
|
unpack (&keyptr->xkrFNum, &bufptr, 4);
|
|
unpack (&keyptr->xkrFABN, &bufptr, 2);
|
|
|
|
}
|
|
|
|
/*--- macPackHeaderRec ---------------------
|
|
*
|
|
*/
|
|
|
|
int macPackHeaderRec( hdrRec, buffer )
|
|
struct header_record *hdrRec;
|
|
char *buffer;
|
|
{
|
|
char *bufptr = buffer;
|
|
|
|
pack (&hdrRec->hrDepthCount, &bufptr, 2);
|
|
pack (&hdrRec->hrRootNode, &bufptr, 4);
|
|
pack (&hdrRec->hrTotalRecs, &bufptr, 4);
|
|
pack (&hdrRec->hrFirstLeaf, &bufptr, 4);
|
|
pack (&hdrRec->hrLastLeaf, &bufptr, 4);
|
|
pack (&hdrRec->hrNodeSize, &bufptr, 2);
|
|
pack (&hdrRec->hrKeyLen, &bufptr, 2);
|
|
pack (&hdrRec->hrTotalNodes, &bufptr, 4);
|
|
pack (&hdrRec->hrFreeNodes, &bufptr, 4);
|
|
pack (hdrRec->hrUnused, &bufptr, 76);
|
|
|
|
return(bufptr - buffer);
|
|
}
|
|
|
|
/*--- macUnpackHeaderRec ---------------------
|
|
*
|
|
*/
|
|
|
|
void macUnpackHeaderRec( hdrRec, buffer )
|
|
struct header_record *hdrRec;
|
|
char *buffer;
|
|
{
|
|
char *bufptr = buffer;
|
|
|
|
unpack (&hdrRec->hrDepthCount, &bufptr, 2);
|
|
unpack (&hdrRec->hrRootNode, &bufptr, 4);
|
|
unpack (&hdrRec->hrTotalRecs, &bufptr, 4);
|
|
unpack (&hdrRec->hrFirstLeaf, &bufptr, 4);
|
|
unpack (&hdrRec->hrLastLeaf, &bufptr, 4);
|
|
unpack (&hdrRec->hrNodeSize, &bufptr, 2);
|
|
unpack (&hdrRec->hrKeyLen, &bufptr, 2);
|
|
unpack (&hdrRec->hrTotalNodes, &bufptr, 4);
|
|
unpack (&hdrRec->hrFreeNodes, &bufptr, 4);
|
|
unpack (hdrRec->hrUnused, &bufptr, 76);
|
|
|
|
}
|
|
|
|
/*--- macUnpackNodeDescriptor ---------------------
|
|
*
|
|
*/
|
|
|
|
void macUnpackNodeDescriptor( nodeDesc, buffer )
|
|
struct node_descriptor *nodeDesc;
|
|
char *buffer;
|
|
{
|
|
char *bufptr = buffer;
|
|
|
|
unpack (&nodeDesc->ndFLink, &bufptr, 4);
|
|
unpack (&nodeDesc->ndBLink, &bufptr, 4);
|
|
unpack (&nodeDesc->ndType, &bufptr, 1);
|
|
unpack (&nodeDesc->ndLevel, &bufptr, 1);
|
|
unpack (&nodeDesc->ndRecs, &bufptr, 2);
|
|
unpack (&nodeDesc->ndReserved, &bufptr, 2);
|
|
|
|
}
|
|
|
|
/*--- macPackNodeDescriptor ---------------------
|
|
*
|
|
*/
|
|
|
|
int macPackNodeDescriptor(nodeBuffer, nodeDesc)
|
|
char *nodeBuffer;
|
|
struct node_descriptor *nodeDesc;
|
|
{
|
|
char *bufptr = nodeBuffer;
|
|
|
|
pack (&nodeDesc->ndFLink, &bufptr, 4);
|
|
pack (&nodeDesc->ndBLink, &bufptr, 4);
|
|
pack (&nodeDesc->ndType, &bufptr, 1);
|
|
pack (&nodeDesc->ndLevel, &bufptr, 1);
|
|
pack (&nodeDesc->ndRecs, &bufptr, 2);
|
|
pack (&nodeDesc->ndReserved, &bufptr, 2);
|
|
|
|
return( bufptr - nodeBuffer);
|
|
}
|
|
|
|
|
|
/*--- getRecordOffset ---------------------
|
|
*
|
|
*/
|
|
|
|
int getRecordOffset(targetRecNum, nodeBuffer)
|
|
int targetRecNum;
|
|
short *nodeBuffer;
|
|
{
|
|
return( (short)*(nodeBuffer+((NODE_SIZE/sizeof(short))-targetRecNum)-1) );
|
|
}
|
|
|
|
/*-- putRecordOffset ---------
|
|
*
|
|
*/
|
|
|
|
void putRecordOffset( nodeBuffer, recNum, offset )
|
|
short *nodeBuffer;
|
|
int recNum;
|
|
int offset;
|
|
{
|
|
|
|
*(nodeBuffer+((NODE_SIZE/sizeof(short))-recNum)-1) = offset;
|
|
|
|
}
|
|
|