mirror of
https://github.com/rvtr/TwlIPL.git
synced 2025-10-31 06:01:12 -04:00
9d06eb337b
git-svn-id: file:///Users/lillianskinner/Downloads/platinum/twl/TwlIPL/trunk@320 b08762b0-b915-fc4b-9d8c-17b2551a87ff
296 lines
8.1 KiB
C
296 lines
8.1 KiB
C
/*---------------------------------------------------------------------------*
|
|
Project: TwlSDK - tools - makerom.TWL
|
|
File: ber_isk.c
|
|
|
|
Copyright 2007 Nintendo. All rights reserved.
|
|
|
|
These coded instructions, statements, and computer programs contain
|
|
proprietary information of Nintendo of America Inc. and/or Nintendo
|
|
Company Ltd., and are protected by Federal copyright law. They may
|
|
not be disclosed to third parties or copied or duplicated in any form,
|
|
in whole or in part, without the prior written consent of Nintendo.
|
|
|
|
$Date:: $
|
|
$Rev$
|
|
$Author$
|
|
*---------------------------------------------------------------------------*/
|
|
/* $Id$ */
|
|
/*
|
|
* Copyright (C) 1998-2002 RSA Security Inc. All rights reserved.
|
|
*
|
|
* This work contains proprietary information of RSA Security.
|
|
* Distribution is limited to authorized licensees of RSA
|
|
* Security. Any unauthorized reproduction, distribution or
|
|
* modification of this work is strictly prohibited.
|
|
*
|
|
*/
|
|
|
|
#include "ber_lcl.h"
|
|
|
|
#if !(defined(NO_SPLIT) && defined(SPLIT_FILE))
|
|
|
|
#ifdef NO_SPLIT
|
|
#define SPLIT_BER_ITEMS_SK_INIT
|
|
#define SPLIT_BER_ITEMS_SK_GET
|
|
#define SPLIT_BER_ITEMS_APPEND
|
|
#define SPLIT_BER_ITEMS_UNDER
|
|
#define SPLIT_BER_ITEMS_SK_GROW
|
|
#define SPLIT_BER_ITEMS_SK_FREE
|
|
#endif /* NO_SPLIT */
|
|
|
|
/* BER_ITEMS_SK_EXPAND_COUNT - number of items to expand to given that
|
|
* there are "X" items currently.
|
|
*
|
|
* note: each item typically costs 28 bytes so 20 is around .5k which
|
|
* is a reasonable growth size
|
|
*/
|
|
#define BER_ITEMS_SK_EXPAND_COUNT(X) ((X)+20)
|
|
|
|
#ifdef SPLIT_BER_ITEMS_SK_INIT
|
|
/**
|
|
* Initialises the stack of BER items. The array of items, the current number
|
|
* of items and the maximum number of items allocated may be set.
|
|
*
|
|
* @param sk [In] A stack of BER items.
|
|
* @param items [In] An array of BER items.
|
|
* @param num [In] The number of BER items in the array.
|
|
* @param max [In] The number of BER items allocated in the array.
|
|
*/
|
|
void BER_ITEMS_SK_init(BER_ITEMS_SK *sk, BER_ITEMS *items, unsigned int num,
|
|
unsigned int max)
|
|
{
|
|
sk->num=num;
|
|
sk->max=max;
|
|
if (items == NULL)
|
|
{
|
|
sk->flags=BER_FLAG_DYNAMIC_ITEMS;
|
|
}
|
|
else
|
|
{
|
|
sk->flags=0;
|
|
}
|
|
sk->items=items;
|
|
|
|
#ifndef NO_STREAM
|
|
sk->state=BER_STATE_READ_NEXT_ITEM;
|
|
sk->inf=0;
|
|
sk->pinf=0;
|
|
sk->con=0;
|
|
sk->down=1;
|
|
sk->this_idx=-1;
|
|
sk->next=NULL;
|
|
#endif /* !NO_STREAM */
|
|
}
|
|
#endif /* SPLIT_BER_ITEMS_SK_INIT */
|
|
|
|
#ifdef SPLIT_BER_ITEMS_SK_GET
|
|
/**
|
|
* Obtains the next available BER item in the stack.
|
|
*
|
|
* @param sk [In] Stack of BER items.
|
|
* @param index [Out] Index into array of new item.
|
|
* @return Indication of successful completion of function.
|
|
* Values are:
|
|
* <li>0 indicates the function succeeded.</li>
|
|
* <li>>0 indicates the function failed.</li>
|
|
*
|
|
* @note If there is no item available in the array then the array is grown.
|
|
* This means that an existing external pointer to an item may not be
|
|
* valid after a call to this function.
|
|
*/
|
|
int BER_ITEMS_SK_get(BER_ITEMS_SK *sk, int *index)
|
|
{
|
|
int ret; /* return value */
|
|
BER_ITEMS *it; /* next item */
|
|
|
|
/* Ensure there are enough spare items. */
|
|
if (sk->num >= sk->max)
|
|
{
|
|
/* Reallocate the array. */
|
|
ret = BER_ITEMS_SK_grow(sk, BER_ITEMS_SK_EXPAND_COUNT(sk->num));
|
|
if (ret != 0)
|
|
{
|
|
return(ret);
|
|
}
|
|
}
|
|
|
|
/* Set the new item index for return. */
|
|
*index = (int)sk->num;
|
|
|
|
/* Initialize the new item. */
|
|
it = &(sk->items[sk->num++]);
|
|
Memset((char *)it, 0, sizeof(BER_ITEMS));
|
|
|
|
/* return success */
|
|
return(0);
|
|
}
|
|
|
|
#endif /* SPLIT_BER_ITEMS_SK_GET */
|
|
|
|
#ifdef SPLIT_BER_ITEMS_APPEND
|
|
/**
|
|
* Places the BER item <i>b</i> next to the BER item <i>a</i> in the tree
|
|
* structure.
|
|
*
|
|
* @param a [In] A BER item.
|
|
* @param b [In] A BER item.
|
|
*/
|
|
void BER_ITEMS_append(a,b)
|
|
BER_ITEMS *a,*b;
|
|
{
|
|
b->parent=a->parent;
|
|
if (b->parent != NULL)
|
|
{
|
|
b->parent->item.flags|=BER_FLAG_INVALID_LENGTH;
|
|
}
|
|
b->next=a->next;
|
|
a->next=b;
|
|
}
|
|
#endif /* SPLIT_BER_ITEMS_APPEND */
|
|
|
|
#ifdef SPLIT_BER_ITEMS_UNDER
|
|
/**
|
|
* Places the BER item <i>b</i> below the BER item <i>a</i> in the tree
|
|
* structure.
|
|
*
|
|
* @param a [In] A BER item.
|
|
* @param b [In] A BER item.
|
|
*
|
|
* @return An indication of success:<br>
|
|
* <li>0 indicates success</li>
|
|
* <li>>0 indicates failure</li>
|
|
*/
|
|
int BER_ITEMS_under(BER_ITEMS *a, BER_ITEMS *b)
|
|
{
|
|
if (!(BER_constructed(&a->item) || BER_hide_contents(&a->item)))
|
|
{
|
|
return(BER_ERR_NOT_CONSTRUCTED);
|
|
}
|
|
b->parent=a;
|
|
b->next=a->down;
|
|
a->down=b;
|
|
|
|
a->item.flags|=BER_FLAG_INVALID_LENGTH;
|
|
return(0);
|
|
}
|
|
#endif /* SPLIT_BER_ITEMS_UNDER */
|
|
|
|
#ifdef SPLIT_BER_ITEMS_SK_GROW
|
|
/**
|
|
* Grows the number of allocated BER items.
|
|
*
|
|
* @param sk [In] A stack of BER items.
|
|
* @param num [In] The number of BER items to allocate.
|
|
*
|
|
* @return An indication of success:<br>
|
|
* <li>0 indicates success</li>
|
|
* <li>>0 indicates failure</li>
|
|
*/
|
|
int BER_ITEMS_SK_grow(BER_ITEMS_SK *sk, unsigned int num)
|
|
{
|
|
int ptr_fix;
|
|
unsigned int i;
|
|
unsigned int j;
|
|
BER_ITEMS *nai;
|
|
BER_ITEMS *oai;
|
|
BER_ITEMS *oend;
|
|
|
|
if (num <= sk->num)
|
|
{
|
|
return(0);
|
|
}
|
|
|
|
if (sk->flags & BER_FLAG_DYNAMIC_ITEMS)
|
|
{
|
|
if (sk->items == NULL)
|
|
{
|
|
ptr_fix=0;
|
|
nai=(BER_ITEMS *)Malloc(sizeof(BER_ITEMS)*num);
|
|
if (nai == NULL)
|
|
{
|
|
return(BER_ERR_OUT_OF_MEMORY);
|
|
}
|
|
Memset(nai,0,sizeof(BER_ITEMS)*num);
|
|
}
|
|
else
|
|
{
|
|
ptr_fix=1;
|
|
nai=(BER_ITEMS *)Realloc(sk->items, sizeof(BER_ITEMS)*num,
|
|
sizeof(BER_ITEMS)*sk->max);
|
|
if (nai == NULL)
|
|
{
|
|
return(BER_ERR_OUT_OF_MEMORY);
|
|
}
|
|
Memset(&(nai[sk->max]),0, sizeof(BER_ITEMS)*(num-sk->max));
|
|
}
|
|
if (nai == NULL)
|
|
{
|
|
return(BER_ERR_OUT_OF_MEMORY);
|
|
}
|
|
|
|
/* If we have realloced, and the Memory has moved, we
|
|
* need to fix the pointers */
|
|
if ((sk->items != nai) && ptr_fix)
|
|
{
|
|
oai=sk->items;
|
|
oend= &(sk->items[sk->num]);
|
|
for (i=0; i<sk->num; i++)
|
|
{
|
|
if ((nai[i].parent >= oai) &&
|
|
(nai[i].parent <= oend))
|
|
{
|
|
j=(unsigned int)( nai[i].parent-oai );
|
|
nai[i].parent= &(nai[j]);
|
|
}
|
|
if ((nai[i].next >= oai) &&
|
|
(nai[i].next <= oend))
|
|
{
|
|
j=(unsigned int)( nai[i].next-oai );
|
|
nai[i].next= &(nai[j]);
|
|
}
|
|
if ((nai[i].down >= oai) &&
|
|
(nai[i].down <= oend))
|
|
{
|
|
j=(unsigned int)( nai[i].down-oai );
|
|
nai[i].down= &(nai[j]);
|
|
}
|
|
}
|
|
}
|
|
|
|
sk->max=num;
|
|
sk->items=nai;
|
|
return(0);
|
|
}
|
|
|
|
return(BER_ERR_OUT_OF_ITEMS_STORAGE);
|
|
}
|
|
#endif /* SPLIT_BER_ITEMS_SK_GROW */
|
|
|
|
#ifdef SPLIT_BER_ITEMS_SK_FREE
|
|
void BER_ITEMS_SK_free(sk)
|
|
BER_ITEMS_SK *sk;
|
|
{
|
|
unsigned int i;
|
|
|
|
for (i=0; i<sk->max; i++)
|
|
{
|
|
if ((sk->items[i].item.data.bytes != NULL) &&
|
|
(sk->items[i].item.flags & BER_FLAG_DYNAMIC))
|
|
{
|
|
Free(sk->items[i].item.data.bytes);
|
|
sk->items[i].item.data.bytes=NULL;
|
|
}
|
|
}
|
|
if ((sk->flags & BER_FLAG_DYNAMIC_ITEMS) && (sk->items != NULL))
|
|
{
|
|
Free(sk->items);
|
|
sk->items=NULL;
|
|
}
|
|
sk->num=0;
|
|
if (sk->flags & BER_FLAG_DYNAMIC)
|
|
Free(sk);
|
|
}
|
|
#endif /* SPLIT_BER_ITEMS_SK_FREE */
|
|
|
|
#endif /* !(defined(NO_SPLIT) && defined(SPLIT_FILE)) */
|