/* NON_NULL points to the loaded object */
OBJECT *
ObjectContextLoad(
ANY_OBJECT_BUFFER *object, // IN: pointer to object structure in saved
// context
TPMI_DH_OBJECT *handle // OUT: object handle
)
{
OBJECT *newObject = ObjectAllocateSlot(handle);
// Try to allocate a slot for new object
if(newObject != NULL)
{
// Copy the first part of the object
MemoryCopy(newObject, object, offsetof(HASH_OBJECT, state));
// See if this is a sequence object
if(ObjectIsSequence(newObject))
{
// If this is a sequence object, import the data
SequenceDataImport((HASH_OBJECT *)newObject,
(HASH_OBJECT_BUFFER *)object);
}
else
{
// Copy input object data to internal structure
MemoryCopy(newObject, object, sizeof(OBJECT));
}
}
return newObject;
}
void BURGER_API Burger::OkAlertMessage(const char *pMessage,const char *pTitle)
{
Word8 *TitleStr; /* Pointer to the window title */
DialogPtr MyDialog; /* My dialog pointer */
Handle ItemList; /* Handle to the item list */
Rect DialogRect; /* Rect of the dialog window */
Word TitleLen; /* Length of the title */
Word MessLen; /* Length of the caption */
short ItemHit; /* Junk */
Rect WorkRect;
GrafPtr MyPort; /* My grafport */
//Word Foo;
//Foo = InputSetState(FALSE);
GetPort(&MyPort); /* Save the current port */
/* Center my dialog to the screen */
#if ACCESSOR_CALLS_ARE_FUNCTIONS
GetPortBounds(MyPort,&WorkRect);
#else
WorkRect = MyPort->portRect;
#endif
DialogRect.top = static_cast<short>((((WorkRect.bottom-WorkRect.top)-190)/2)+WorkRect.top);
DialogRect.left = static_cast<short>((((WorkRect.right-WorkRect.left)-350)/2)+WorkRect.left);
DialogRect.bottom = static_cast<short>(DialogRect.top+190);
DialogRect.right = static_cast<short>(DialogRect.left+350);
TitleLen = 0; /* Assume no length */
if (pTitle) {
TitleLen = Burger::StringLength(pTitle); /* Get the length of the title string */
}
TitleStr = (Word8 *)Burger::Alloc(TitleLen+1); /* Get memory of pascal string */
if (TitleStr) { /* Did I get the memory? */
MemoryCopy(TitleStr+1,pTitle,TitleLen);
TitleStr[0] = static_cast<Word8>(TitleLen); /* Set the pascal length */
MessLen = Burger::StringLength(pMessage); /* Size of the message */
ItemList = NewHandle(static_cast<Size>(sizeof(Template)+MessLen));
if (ItemList) { /* Ok? */
Template[sizeof(Template)-1]=static_cast<Word8>(MessLen); /* Save the message length */
MemoryCopy(ItemList[0],Template,sizeof(Template)); /* Copy the template */
MemoryCopy((ItemList[0])+sizeof(Template),pMessage,MessLen); /* Copy the message */
MyDialog = NewDialog(0,&DialogRect,(Word8 *)TitleStr,TRUE,5,(WindowPtr)-1,FALSE,0,ItemList);
if (MyDialog) {
SetDialogDefaultItem(MyDialog,1); /* Default for OK button */
ModalDialog(0,&ItemHit); /* Handle the event */
DisposeDialog(MyDialog); /* Kill the dialog */
} else {
DisposeHandle(ItemList); /* I must kill this myself! */
}
}
Burger::Free(TitleStr); /* Kill the title */
}
SetPort(MyPort); /* Restore my grafport */
//InputSetState(Foo);
}
void Pxf::ReplaceString(char *str, const char *find, const char *replace)
{
int len_find = StringLength(find);
int len_replace = StringLength(replace);
const char *p, *s;
char *t;
if (len_find - len_replace < 0) return;
p = StringFind(str, find);
if (!p) return;
s = t = (char*)p;
while(*s)
{
MemoryCopy(t, replace, len_replace);
p += len_find;
t += len_replace;
s = StringFind(p, find);
if(!s) s = p + StringLength(p);
MemoryMove(t, p, (unsigned)(s-p));
t += s-p;
p = s;
}
*t = 0;
}
static FSTATUS recv_mad(MADT_HANDLE umadtHandle, MAD* mad, int timeout)
{
FSTATUS status;
MadtStruct *Mad;
MadWorkCompletion *Wc;
status = iba_umadt_wait_any_compl(umadtHandle, RECV_COMPLETION, timeout);
if (status == FTIMEOUT) {
DBGPRINT("Timeout waiting for MAD Recv. timeout= %d ms\n", timeout);
return status;
}
// cleanup any send completions while here
do {
status = iba_umadt_poll_send_compl(umadtHandle, &Mad, &Wc);
if (status == FSUCCESS) {
(void)iba_umadt_release_sendmad(umadtHandle, Mad);
}
} while (status == FSUCCESS);
// get next recv from the Q
status = iba_umadt_poll_recv_compl(umadtHandle, &Mad, &Wc);
if (status != FSUCCESS) {
DBGPRINT("Poll Recv failed: %s\n", iba_fstatus_msg(status));
return status;
}
MemoryCopy(mad, &Mad->IBMad, sizeof(*mad)); // caller must byte swap
// for now ignore Work completion, only handling responses
DBGPRINT("Received a MAD\n");
status = iba_umadt_release_recvmad(umadtHandle, Mad);
if (status != FSUCCESS) {
fprintf(stderr, "%s: ReleaseRecvMad: (status=0x%x): %s\n",
g_Top_cmdname, status, FSTATUS_MSG(status));
}
return status;
}
Burger::String16::String16(const Burger::String16 &rInput,WordPtr uStart,WordPtr uEnd)
{
WordPtr uInputLength = rInput.m_uLength; // Get the source length
if (uEnd>uInputLength) { // Clamp the end of the string
uEnd = uInputLength; // Make sure it fits
}
const Word16 *pInput = rInput.m_pData;
if (uStart>=uEnd) { // Valid range?
uInputLength = 0; // The result will be empty
} else {
uInputLength = uEnd-uStart; // Length of the new string
pInput += uStart;
}
Word16 *pWork = m_Raw;
if (uInputLength>=BUFFERSIZE) { // Buffer big enough?
pWork = static_cast<Word16 *>(Alloc((uInputLength+1)*sizeof(Word16)));
if (!pWork) { // Oh oh...
pWork = m_Raw;
uInputLength = 0; // Don't copy anything
}
}
// Since I can't assume the string being created ends with a zero, I'll
// manually place one in the new string
pWork[uInputLength] = 0;
m_uLength = uInputLength; // Save the new length
m_pData = pWork; // Set the pointer
MemoryCopy(pWork,pInput,uInputLength*sizeof(Word16)); // Copy the string
}
Burger::Decompress::eError Burger::DecompressUnsigned8BitAudio::Process(void *pOutput,WordPtr uOutputChunkLength,const void *pInput,WordPtr uInputChunkLength)
{
// Which is smaller? Input or output?
WordPtr uCount = Min(uInputChunkLength,uOutputChunkLength);
// Copy the data
MemoryCopy(pOutput,pInput,uCount);
// Store the amount of data that was processed
m_uInputLength = uCount;
m_uOutputLength = uCount;
// Add the decompressed data to the totals
m_uTotalInput += uCount;
m_uTotalOutput += uCount;
// Output buffer not big enough?
if (uOutputChunkLength!=uCount) {
return DECOMPRESS_OUTPUTUNDERRUN;
}
// Input data remaining?
if (uInputChunkLength!=uCount) {
return DECOMPRESS_OUTPUTOVERRUN;
}
// Decompression is complete
return DECOMPRESS_OKAY;
}
DataBuffer::DataBuffer(const void * data, YETI_Size size, bool copy)
: m_buffer_is_local_(copy)
, m_buffer_(copy ? (size ? new YETI_Byte[size] : NULL) : reinterpret_cast<YETI_Byte *>(const_cast<void *>(data)))
, m_buffer_size_(size)
, m_data_size_(size)
{
if (copy && size) MemoryCopy(m_buffer_, data, size);
}
DataBuffer::DataBuffer(const DataBuffer & other)
: m_buffer_is_local_(true)
, m_buffer_(NULL)
, m_buffer_size_(other.m_data_size_)
{
if (m_buffer_size_) {
m_buffer_ = new YETI_Byte[m_buffer_size_];
MemoryCopy(m_buffer_, other.m_buffer_, m_buffer_size_);
}
}
void AirMemory::AddBackupMemory(DWORD Address, void *Memory, DWORD Size) {
BackupMemory *p = (BackupMemory *)malloc(sizeof(BackupMemory));
p->Address = Address;
p->Size = Size;
p->Memory = malloc(Size);
MemoryCopy((DWORD)p->Memory, (void *)p->Address, p->Size);//Backup Memory
if (Memory) {
MemoryCopy(p->Address, Memory, p->Size);//Write Memory
}
if (!MemoryList.Next) {
p->Next = NULL;
MemoryList.Next = p;
}
else {
p->Next = MemoryList.Next;
MemoryList.Next = p;
}
}
/* This function is used to update a value in the PERSISTENT_DATA structure and commits the value to
NV. */
void
NvUpdatePersistent(
UINT32 offset, // IN: location in PERMANENT_DATA to be updated
UINT32 size, // IN: size of the value
void *buffer // IN: the new data
)
{
pAssert(offset + size <= sizeof(gp));
MemoryCopy(&gp + offset, buffer, size);
NvWrite(offset, size, buffer);
}
static void AddCh(CJcScanner* scanner){
char *newBuf;
if (scanner->tlen >= scanner->tvalLength){
scanner->tvalLength *= 2;
newBuf = (char*)g_oInterface.Malloc(scanner->tvalLength);
MemoryCopy(newBuf, scanner->tval, scanner->tlen*sizeof(char));
g_oInterface.Free(scanner->tval);
scanner->tval = newBuf;
}
scanner->tval[scanner->tlen++] = scanner->ch;
NextCh(scanner);
}
int GetMACAddress(unsigned char Buffer[6])
{
PropertyTagMACAddress MACAddress;
if (!PropertyTagsGetTag(PROPTAG_GET_MAC_ADDRESS, &MACAddress, sizeof(MACAddress), 0))
{
return 0;
}
MemoryCopy(MACAddress.Address, Buffer, 6);
return 1;
}
char *Pxf::StringPadRight(char *dest, const char *src, int width, char pad_char)
{
int len = StringLength(src);
int dst_off = width-len;
int src_off = len-width;
src_off = (src_off < 0) ? 0 : src_off;
dst_off = (dst_off < 0) ? 0 : dst_off;
MemorySet(dest, pad_char, width);
MemoryCopy(dest + dst_off, src + src_off, Min(len, width));
/*dest[width] = 0x0; */
return dest;
}
char *Pxf::DuplicateReplaceString(const char *str, const char *find, const char *replace)
{
int len_find = StringLength(find);
int len_replace = StringLength(replace);
int count = 0, newlen = 0;
/*char *src = (char*)str; */
char *ret, *q;
const char *p = str;
p = StringFind(str, find);
if (!p)
return strdup(str);
/* count occurrences of find */
do { count++; } while ((p = StringFind(p+len_find, find)));
newlen = (StringLength(str) + count * (len_replace - len_find) + 1) * sizeof(char);
ret = (char*)MemoryAllocate( newlen );
if (!ret) return 0;
p = (char*)str;
q = ret;
while(1)
{
const char *tmp = StringFind(p, find);
if (!tmp)
{
StringCopy(q, p, StringLength(str)-(unsigned)(p-str)+1);
ret[newlen-1] = 0;
return ret;
}
MemoryCopy(q, p, (unsigned)(tmp-p));
q += tmp-p;
MemoryCopy(q, replace, len_replace);
q += len_replace;
p = tmp+len_find;
}
return 0;
}
internal_function dod_tag*
DODGetDODTag(char* line) {
char* tag = (char*)calloc(DOD_TAG_SIZE, sizeof(char));
char* value = (char*)calloc(DOD_VALUE_SIZE, sizeof(char));
char* tagAddress = tag;
char* valueAddress = value;
bool foundEqual = false;
while(*line != '#') {
if(!foundEqual && *line == '=') {
foundEqual = true;
line++;
continue;
}
if(foundEqual) {
*value = *line;
value++;
}
else {
*tag = *line;
tag++;
}
line++;
}
dod_tag* result = DODAllocateDODTag();
MemoryCopy(result->tag, tagAddress, DOD_TAG_SIZE);
MemoryCopy(result->value, valueAddress, DOD_VALUE_SIZE);
free(tagAddress);
free(valueAddress);
return(result);
}
YETI_Result DataBuffer::set_data(const YETI_Byte * data, YETI_Size data_size)
{
if (data_size > m_buffer_size_) {
if (m_buffer_is_local_) {
YETI_CHECK(_reallocate_buffer(data_size));
} else {
return YETI_ERROR_NOT_SUPPORTED;
}
}
if (data) MemoryCopy(m_buffer_, data, data_size);
m_data_size_ = data_size;
return YETI_SUCCESS;
}
YETI_Result DataBuffer::_reallocate_buffer(YETI_Size size)
{
if (m_data_size_ > size) return YETI_ERROR_INVALID_PARAMETERS;
YETI_Byte * new_buffer = new YETI_Byte[size];
if (m_buffer_ && m_data_size_) {
MemoryCopy(new_buffer, m_buffer_, m_data_size_);
}
delete[] m_buffer_;
m_buffer_ = new_buffer;
m_buffer_size_ = size;
return YETI_SUCCESS;
}
bool AirMemory::DeleteBackupMemory(DWORD Address) {
BackupMemory *p, *d, *pp;
pp = &MemoryList;
for (p = MemoryList.Next; p; p = p->Next) {
if (p->Address == Address) {
d = p;
MemoryCopy(d->Address, d->Memory, d->Size);//Restore Memory
pp->Next = p->Next;
free(d->Memory);
free(d);
return true;
}
pp = p;
}
return false;
}
DataBuffer & DataBuffer::operator =(const DataBuffer & copy)
{
if (this != ©) {
clear();
m_buffer_is_local_ = true;
m_buffer_size_ = copy.m_buffer_size_;
m_data_size_ = copy.m_data_size_;
if (m_buffer_size_) {
m_buffer_ = new YETI_Byte[m_buffer_size_];
MemoryCopy(m_buffer_, copy.m_buffer_, m_buffer_size_);
}
}
return *this;
}
Burger::String16::String16(const Burger::String16 &rInput)
{
WordPtr uInputLength = rInput.m_uLength; // Get the source length
Word16 *pWork = m_Raw;
const Word16 *pInput = rInput.m_pData;
if (uInputLength>=BUFFERSIZE) { // Buffer big enough?
pWork = static_cast<Word16 *>(Alloc((uInputLength+1)*sizeof(Word16)));
if (!pWork) { // Oh oh...
pWork = m_Raw;
pInput = g_EmptyString16;
uInputLength = 0;
}
}
m_uLength = uInputLength; // Save the new length
m_pData = pWork; // Set the pointer
MemoryCopy(pWork,pInput,(uInputLength+1)*sizeof(Word16)); // Copy the string and the ending NULL
}
char*
ToString(char* text, ...) {
va_list ap;
char* buffer = (char*)calloc(256, sizeof(char));
va_start(ap, text);
vsprintf_s(buffer, 256, text, ap);
va_end(ap);
int resultSize = CharPointerLength(buffer);
char* result = (char*)calloc(resultSize, sizeof(char));
MemoryCopy(result, buffer, resultSize);
free(buffer);
return(result);
}
Burger::String16::String16(const Word16 *pInput)
{
if (!pInput) {
pInput = g_EmptyString16;
}
WordPtr uInputLength = StringLength(pInput);
Word16 *pWork = m_Raw;
if (uInputLength>=BUFFERSIZE) { // Buffer big enough?
pWork = static_cast<Word16 *>(Alloc((uInputLength+1)*sizeof(Word16)));
if (!pWork) { // Oh oh...
pWork = m_Raw;
pInput = g_EmptyString16;
uInputLength = 0; // Don't copy anything
}
}
m_uLength = uInputLength; // Save the new length
m_pData = pWork; // Set the pointer
MemoryCopy(pWork,pInput,(uInputLength+1)*sizeof(Word16)); // Copy the string
}
internal_function char*
DODSearchThroughNextTags(dod_tag* dodTag, char* tag, char* value, char* subTag = 0, char* subValue = 0) {
if(subTag && subValue) {
dod_tag* nextDODTag = dodTag;
while(nextDODTag) {
if(CompareCharPointers(nextDODTag->tag, tag)) {
if(CompareCharPointers(nextDODTag->value, value)) {
char* result = DODSearchThroughNextTags(nextDODTag->subTag, subTag, subValue);
if(result) {
return(result);
}
}
}
nextDODTag = nextDODTag->nextTag;
}
}
while(dodTag) {
if(CompareCharPointers(dodTag->tag, tag)) {
if(CompareCharPointers(dodTag->value, value)) {
if(dodTag->content) {
//NOTE: Getting the contentSize by subtracting 2, we lose the \n and final \0
int randomIndex = RandomNumberInRange(0, dodTag->amountOfContent - 1);
int contentSize = CharPointerLength(dodTag->content[randomIndex]) - 2;
//NOTE: Copying the content with 1 less of size removes the #.
char* result = (char*)calloc(contentSize, sizeof(char));
MemoryCopy(result, dodTag->content[randomIndex], contentSize - 1);
return(result);
}
}
}
dodTag = dodTag->nextTag;
}
return("");
}
static FSTATUS send_mad(MADT_HANDLE umadtHandle, IB_PATH_RECORD *pathp,
uint32 qpn, uint32 qkey, MAD* mad)
{
FSTATUS status;
MadtStruct *Mad;
MadAddrStruct Addr;
uint32 count = 1;
MadWorkCompletion *Wc;
DBGPRINT("getting buffer to send Mad\n");
status = iba_umadt_get_sendmad(umadtHandle, &count, &Mad);
if (status != FSUCCESS) {
return status;
}
DBGPRINT("sending Mad\n");
Mad->Context = 0; // TBD - for async in future
MemoryClear(&Mad->Grh, sizeof(Mad->Grh)); /* only in recv */
MemoryCopy(&Mad->IBMad, mad, sizeof(*mad));
GetGsiAddrFromPath(pathp, qpn, qkey, &Addr);
status = iba_umadt_post_send(umadtHandle, Mad, &Addr);
if (status != FSUCCESS) {
fprintf(stderr, "%s: Failed to send mad: (status=0x%x): %s\n",
g_Top_cmdname, status, FSTATUS_MSG(status));
(void)iba_umadt_release_sendmad(umadtHandle, Mad);
return status;
}
status = iba_umadt_wait_any_compl(umadtHandle, SEND_COMPLETION, SEND_WAIT_TIME);
if (status == FSUCCESS) {
status = iba_umadt_poll_send_compl(umadtHandle, &Mad, &Wc);
if (status == FSUCCESS) {
DBGPRINT("MAD Sent\n");
(void)iba_umadt_release_sendmad(umadtHandle, Mad);
}
}
return status;
}
void BURGER_API Burger::String16::SetBufferSize(WordPtr uSize)
{
if (uSize!=m_uLength) {
// If no space is requested, clear the buffer
if (!uSize) {
Clear();
} else {
// Hold the old buffer
Word16 *pWork = m_pData;
// Get the new buffer
Word16 *pDest = m_Raw;
// Allocate a new buffer if needed
if (uSize>=BUFFERSIZE) { // Buffer big enough?
pDest = static_cast<Word16 *>(Alloc((uSize+1)*2));
if (!pDest) { // Oh oh...
pDest = m_Raw;
uSize = 0; // Don't copy anything
}
}
// Get the size of the string
WordPtr uDestSize = m_uLength;
if (uDestSize>=uSize) {
// Truncate the string
uDestSize = uSize;
}
MemoryCopy(pDest,pWork,uDestSize*2);
pDest[uDestSize] = 0; // Ensure the buffer is zero terminated
if (pWork!=m_Raw) { // Discard previous memory
Free(pWork);
}
m_pData = pDest; // Set the pointer
m_uLength = uSize; // Save the new length
pDest[uSize] = 0; // Ensure the terminating zero is present
}
}
}
Burger::Decompress::eError Burger::Decompress32BitBEAudio::Process(void *pOutput,WordPtr uOutputChunkLength,const void *pInput,WordPtr uInputChunkLength)
{
#if defined(BURGER_BIGENDIAN)
// Which is smaller? Input or output?
WordPtr uCount = Min(uInputChunkLength,uOutputChunkLength);
//
// If there is no conversion, just upload the data as is.
//
MemoryCopy(pOutput,pInput,uCount);
WordPtr uInputConsumed = uCount;
WordPtr uOutputConsumed = uCount;
#else
//
// Handle data "decompression"
//
// Save the pointers to determine consumption
void *pOldOutput = pOutput;
const void *pOldInput = pInput;
//
// Process based on state
//
eState uState = m_eState;
Word bAbort = FALSE;
do {
switch (uState) {
//
// Cache has not been used, just copy
//
case STATE_INIT:
{
// Copy the data while converting the endian
WordPtr uCount = Min(uInputChunkLength,uOutputChunkLength);
WordPtr uLength = uCount&(~(3));
if (uLength) {
uInputChunkLength -= uLength;
uOutputChunkLength -= uLength;
// Is it aligned?
if (!((reinterpret_cast<WordPtr>(pInput)|reinterpret_cast<WordPtr>(pOutput))&3)) {
ConvertEndian(static_cast<Word32 *>(pOutput),static_cast<const Word32 *>(pInput),uLength>>2U);
pInput = static_cast<const Word32 *>(pInput)+uLength;
pOutput = static_cast<Word32 *>(pOutput)+uLength;
} else {
// You monster.
uLength = uLength>>2U;
do {
// Convert to endian with unaligned data
static_cast<Word8 *>(pOutput)[0] = static_cast<const Word8 *>(pInput)[3];
static_cast<Word8 *>(pOutput)[1] = static_cast<const Word8 *>(pInput)[2];
static_cast<Word8 *>(pOutput)[2] = static_cast<const Word8 *>(pInput)[1];
static_cast<Word8 *>(pOutput)[3] = static_cast<const Word8 *>(pInput)[0];
pInput = static_cast<const Word32 *>(pInput)+1;
pOutput = static_cast<Word32 *>(pOutput)+1;
} while (--uLength);
}
}
//
// All done with the input?
//
if (!uInputChunkLength) {
bAbort = TRUE;
} else {
m_uCacheCount = 0;
uState = STATE_FILLINGCACHE;
}
}
break;
//
// Fill up the cache
//
case STATE_FILLINGCACHE:
bAbort = TRUE; // Assume data starved
if (uInputChunkLength) {
// Get the number of bytes already obtained
WordPtr uCacheSize = m_uCacheCount;
// How many is needed to fill
WordPtr uRemaining = sizeof(m_Cache)-uCacheSize;
// Number of bytes to process
WordPtr uChunk = Min(uRemaining,uInputChunkLength);
// Fill in the cache
MemoryCopy(&m_Cache[uCacheSize],pInput,uChunk);
// Consume the input bytes
pInput = static_cast<const Word8 *>(pInput)+uChunk;
uInputChunkLength-=uChunk;
// Did the cache fill up?
uCacheSize += uChunk;
m_uCacheCount = static_cast<Word>(uCacheSize);
if (uCacheSize==sizeof(m_Cache)) {
// Perform the endian swap on the cache
SwapEndian::Fixup(static_cast<Word32 *>(static_cast<void *>(m_Cache)));
// Cache is full, send to processing
bAbort = FALSE;
uState = STATE_CACHEFULL;
}
}
break;
//
// Cache is full, output the data
//
case STATE_CACHEFULL:
bAbort = TRUE; // Assume output buffer is full
if (uOutputChunkLength) {
// Output data from the cache
WordPtr uCacheCount = m_uCacheCount;
WordPtr uSteps = Min(uOutputChunkLength,static_cast<WordPtr>(uCacheCount));
// Mark the byte(s) as consumed
uOutputChunkLength -= uSteps;
// Start copying where it left off
const Word8 *pInputChunk = &m_Cache[sizeof(m_Cache)-uCacheCount];
// Update the cache size
uCacheCount = static_cast<Word>(uCacheCount-uSteps);
//
// Copy out the cache data
//
do {
static_cast<Word8 *>(pOutput)[0] = pInputChunk[0];
++pInputChunk;
pOutput = static_cast<Word8 *>(pOutput)+1;
} while (--uSteps);
// Data still in the cache?
if (uCacheCount) {
// Update and exit
m_uCacheCount = static_cast<Word>(uCacheCount);
} else {
// Cache is empty, so switch to the next state
uState = STATE_INIT;
bAbort = FALSE;
}
}
break;
}
Burger::Decompress::eError Burger::Decompress16BitLEAudio::Process(void *pOutput,WordPtr uOutputChunkLength,const void *pInput,WordPtr uInputChunkLength)
{
#if !defined(BURGER_BIGENDIAN)
// Which is smaller? Input or output?
WordPtr uCount = Min(uInputChunkLength,uOutputChunkLength);
//
// If there is no conversion, just upload the data as is.
//
MemoryCopy(pOutput,pInput,uCount);
WordPtr uInputConsumed = uCount;
WordPtr uOutputConsumed = uCount;
#else
//
// Handle data "decompression"
//
// Save the pointers to determine consumption
void *pOldOutput = pOutput;
const void *pOldInput = pInput;
//
// Process based on state
//
eState uState = m_eState;
Word bAbort = FALSE;
do {
switch (uState) {
//
// Cache has not been used, just copy
//
case STATE_INIT:
{
// Copy the data while converting the endian
WordPtr uCount = Min(uInputChunkLength,uOutputChunkLength);
uInputChunkLength -= uCount;
uOutputChunkLength -= uCount&(~static_cast<WordPtr>(1));
WordPtr uLength = uCount>>1;
if (uLength) {
// Is it aligned?
if (!((reinterpret_cast<WordPtr>(pInput)|reinterpret_cast<WordPtr>(pOutput))&1)) {
// Convert to native endian quickly
ConvertEndian(static_cast<Word16 *>(pOutput),static_cast<const Word16 *>(pInput),uLength);
pInput = static_cast<const Word16 *>(pInput)+uLength;
pOutput = static_cast<Word16 *>(pOutput)+uLength;
} else {
// You monster.
do {
// Convert to endian with unaligned data
static_cast<Word8 *>(pOutput)[0] = static_cast<const Word8 *>(pInput)[1];
static_cast<Word8 *>(pOutput)[1] = static_cast<const Word8 *>(pInput)[0];
pInput = static_cast<const Word16 *>(pInput)+1;
pOutput = static_cast<Word16 *>(pOutput)+1;
} while (--uLength);
}
}
//
// One extra byte?
//
if (uCount&1) {
// Put it in the cache and go into cache mode
m_Cache[1] = static_cast<const Word8 *>(pInput)[0];
pInput = static_cast<const Word8 *>(pInput)+1;
uState = STATE_FILLINGCACHE;
}
}
bAbort = TRUE;
break;
//
// Cache is full, output the data
//
case STATE_CACHEFULL:
if (uOutputChunkLength) {
// Output 1 or 2 bytes
WordPtr uCacheSize = m_uCacheSize;
WordPtr uSteps = Min(uOutputChunkLength,static_cast<WordPtr>(uCacheSize));
// Mark the byte(s) as consumed
uOutputChunkLength -= uSteps;
// Start copying where it left off
const Word8 *pSrc = &m_Cache[sizeof(m_Cache)-uCacheSize];
// Update the cache size
uCacheSize = static_cast<Word>(uCacheSize-uSteps);
if (uCacheSize) {
// Number of bytes remaining in cache
m_uCacheSize = static_cast<Word>(uCacheSize);
} else {
// Cache will be empty, so switch to normal mode
uState = STATE_INIT;
}
//
// Copy out the cache data
//
do {
static_cast<Word8 *>(pOutput)[0] = pSrc[0];
++pSrc;
pOutput = static_cast<Word8 *>(pOutput)+1;
} while (--uSteps);
} else {
bAbort = TRUE;
}
break;
//
// Fill up the cache
//
case STATE_FILLINGCACHE:
if (uInputChunkLength) {
// Fill in the missing byte (Endian swapped)
m_Cache[0] = static_cast<const Word8 *>(pInput)[0];
// Consume the input byte
pInput = static_cast<const Word8 *>(pInput)+1;
--uInputChunkLength;
// Change the state to empty the cache
uState = STATE_CACHEFULL;
m_uCacheSize = 2;
} else {
bAbort = TRUE;
}
break;
}
} while (!bAbort);
// Save the state
m_eState = uState;
// Return the number of bytes actually consumed
WordPtr uInputConsumed = static_cast<WordPtr>(static_cast<const Word8 *>(pInput)-static_cast<const Word8 *>(pOldInput));
WordPtr uOutputConsumed = static_cast<WordPtr>(static_cast<const Word8 *>(pOutput)-static_cast<const Word8 *>(pOldOutput));
#endif
// Store the amount of data that was processed
m_uInputLength = uInputConsumed;
m_uOutputLength = uOutputConsumed;
// Add the decompressed data to the totals
m_uTotalInput += uInputConsumed;
m_uTotalOutput += uOutputConsumed;
// Output buffer not big enough?
if (uOutputChunkLength!=uOutputConsumed) {
return DECOMPRESS_OUTPUTUNDERRUN;
}
// Input data remaining?
if (uInputChunkLength!=uInputConsumed) {
return DECOMPRESS_OUTPUTOVERRUN;
}
// Decompression is complete
return DECOMPRESS_OKAY;
}
Result HcdSumbitControlMessage(struct UsbDevice *device,
struct UsbPipeAddress pipe, void* buffer, u32 bufferLength,
struct UsbDeviceRequest *request) {
Result result;
struct UsbPipeAddress tempPipe;
if (pipe.Device == RootHubDeviceNumber) {
return HcdProcessRootHubMessage(device, pipe, buffer, bufferLength, request);
}
device->Error = Processing;
device->LastTransfer = 0;
// Setup
tempPipe.Speed = pipe.Speed;
tempPipe.Device = pipe.Device;
tempPipe.EndPoint = pipe.EndPoint;
tempPipe.MaxSize = pipe.MaxSize;
tempPipe.Type = Control;
tempPipe.Direction = Out;
if ((result = HcdChannelSendWait(device, &tempPipe, 0, request, 8, request, Setup)) != OK) {
LOGF("HCD: Could not send SETUP to %s.\n", UsbGetDescription(device));
return OK;
}
// Data
if (buffer != NULL) {
if (pipe.Direction == Out) {
MemoryCopy(databuffer, buffer, bufferLength);
}
tempPipe.Speed = pipe.Speed;
tempPipe.Device = pipe.Device;
tempPipe.EndPoint = pipe.EndPoint;
tempPipe.MaxSize = pipe.MaxSize;
tempPipe.Type = Control;
tempPipe.Direction = pipe.Direction;
if ((result = HcdChannelSendWait(device, &tempPipe, 0, databuffer, bufferLength, request, Data1)) != OK) {
LOGF("HCD: Could not send DATA to %s.\n", UsbGetDescription(device));
return OK;
}
ReadBackReg(&Host->Channel[0].TransferSize);
if (pipe.Direction == In) {
if (Host->Channel[0].TransferSize.TransferSize <= bufferLength)
device->LastTransfer = bufferLength - Host->Channel[0].TransferSize.TransferSize;
else{
LOG_DEBUGF("HCD: Weird transfer.. %d/%d bytes received.\n", Host->Channel[0].TransferSize.TransferSize, bufferLength);
LOG_DEBUGF("HCD: Message %02x%02x%02x%02x %02x%02x%02x%02x %02x%02x%02x%02x %02x%02x%02x%02x ...\n",
((u8*)databuffer)[0x0],((u8*)databuffer)[0x1],((u8*)databuffer)[0x2],((u8*)databuffer)[0x3],
((u8*)databuffer)[0x4],((u8*)databuffer)[0x5],((u8*)databuffer)[0x6],((u8*)databuffer)[0x7],
((u8*)databuffer)[0x8],((u8*)databuffer)[0x9],((u8*)databuffer)[0xa],((u8*)databuffer)[0xb],
((u8*)databuffer)[0xc],((u8*)databuffer)[0xd],((u8*)databuffer)[0xe],((u8*)databuffer)[0xf]);
device->LastTransfer = bufferLength;
}
MemoryCopy(buffer, databuffer, device->LastTransfer);
}
else {
device->LastTransfer = bufferLength;
}
}
// Status
tempPipe.Speed = pipe.Speed;
tempPipe.Device = pipe.Device;
tempPipe.EndPoint = pipe.EndPoint;
tempPipe.MaxSize = pipe.MaxSize;
tempPipe.Type = Control;
tempPipe.Direction = ((bufferLength == 0) || pipe.Direction == Out) ? In : Out;
if ((result = HcdChannelSendWait(device, &tempPipe, 0, databuffer, 0, request, Data1)) != OK) {
LOGF("HCD: Could not send STATUS to %s.\n", UsbGetDescription(device));
return OK;
}
ReadBackReg(&Host->Channel[0].TransferSize);
if (Host->Channel[0].TransferSize.TransferSize != 0)
LOG_DEBUGF("HCD: Warning non zero status transfer! %d.\n", Host->Channel[0].TransferSize.TransferSize);
device->Error = NoError;
return OK;
}
uint32
iba_gsi_coalesce_dgrm2(
IN IBT_DGRM_ELEMENT *DgrmElement,
IN uint8 **ppBuffer,
IN uint32 ClassHeaderSize,
IN uint32 MemAllocFlags
)
{
uint32 messageSize = 0;
uint32 byteCount, totalBytesToCopy;
IBT_ELEMENT *pElement;
IBT_BUFFER *pBufferHdr;
uint8 *pBuffer;
MAD_RMPP *pMadRmpp;
#ifdef TEST_DUMP
static int counter;
#endif
_DBG_ENTER_LVL(_DBG_LVL_POOL, iba_gsi_coalesce_dgrm);
pElement = &DgrmElement->Element;
pBufferHdr = pElement->pBufferList;
pMadRmpp = (MAD_RMPP*)pBufferHdr->pNextBuffer->pData;// 2nd buffer is MAD
// Calculate total bytes to copy.
// Each buffer has a GRH+Mad Common Header+RMPP Header+ClassHeader+RMPP Data
//
// We copy only one copy of the headers and coalesce the data
messageSize = totalBytesToCopy = iba_gsi_dgrm_len(DgrmElement, ClassHeaderSize);
if (! messageSize)
goto fail;
_DBG_PRINT(_DBG_LVL_POOL,("Total bytes to copy: %d\n", totalBytesToCopy));
if (*ppBuffer == NULL)
{
*ppBuffer = (uint8*)MemoryAllocate2(totalBytesToCopy, MemAllocFlags, GSA_MEM_TAG);
if (*ppBuffer == NULL)
goto fail;
}
pBuffer = *ppBuffer;
// Copy GRH
if (pBufferHdr->ByteCount != sizeof(IB_GRH)) {
_DBG_ERROR(("Bad buffer header size: %u expected %u\n", pBufferHdr->ByteCount, (unsigned)sizeof(IB_GRH)));
messageSize = 0; // indicate invalid packets
goto fail;
}
byteCount = pBufferHdr->ByteCount;
MemoryCopy( pBuffer, pBufferHdr->pData, byteCount );
pBuffer += byteCount;
totalBytesToCopy -= byteCount; // keep count
pBufferHdr = pBufferHdr->pNextBuffer;
// Copy Mad Common + RMPP Header + class header + first data area
byteCount = (totalBytesToCopy > pBufferHdr->ByteCount) ? \
pBufferHdr->ByteCount:totalBytesToCopy;
MemoryCopy( pBuffer, pBufferHdr->pData, byteCount );
pBuffer += byteCount;
totalBytesToCopy -= byteCount; // keep count
// Walk all elements of RMPP list
while ( totalBytesToCopy )
{
pElement = pElement->pNextElement;
if ( NULL == pElement )
{
_DBG_ERROR(("LIST ERROR DgrmElement %p ClassHeaderSize %d messageSize %d BytesLeft %d\n",
_DBG_PTR(DgrmElement), ClassHeaderSize, messageSize, totalBytesToCopy));
DumpDgrmElement(DgrmElement);
messageSize = 0; // indicate invalid packets/buffers
goto fail;
}
else
{
#ifdef TEST_DUMP
if ((++counter%50) == 0)
{
_DBG_ERROR(("LIST ERROR DgrmElement %p ClassHeaderSize %d messageSize %d BytesLeft %d\n",
_DBG_PTR(DgrmElement), ClassHeaderSize, messageSize, totalBytesToCopy));
DumpDgrmElement(DgrmElement);
messageSize = 0; // indicate invalid packets/buffers
goto fail;
}
#endif
}
// skip GRH
pBufferHdr = pElement->pBufferList->pNextBuffer;
pMadRmpp = (MAD_RMPP *)pBufferHdr->pData;
// copy as much class data as is left in packet
// subtract common headers, if packet too small, don't copy anything
byteCount = (sizeof(MAD_COMMON) + sizeof(RMPP_HEADER) + ClassHeaderSize);
byteCount = (byteCount > pBufferHdr->ByteCount)? \
0:(pBufferHdr->ByteCount - byteCount);
byteCount = (totalBytesToCopy > byteCount)?byteCount:totalBytesToCopy;
if (byteCount)
{
MemoryCopy( pBuffer, &pMadRmpp->Data[ClassHeaderSize], byteCount);
pBuffer += byteCount;
totalBytesToCopy -= byteCount; // keep count
}
}
_DBG_LEAVE_LVL(_DBG_LVL_POOL);
return messageSize;
fail:
if (*ppBuffer)
{
MemoryDeallocate(*ppBuffer);
*ppBuffer = NULL;
}
_DBG_LEAVE_LVL(_DBG_LVL_POOL);
return messageSize;
}
static uint32_t
TpmUtilWriteBootPolicy(
TPM2B_MAX_NV_BUFFER* policy,
TPM2B_PUBLIC* platformAuthority,
TPMT_SIGNATURE* authorizationSignature
)
{
DEFINE_CALL_BUFFERS;
UINT32 result = TPM_RC_SUCCESS;
union
{
LoadExternal_In loadExternal;
NV_ReadPublic_In nv_ReadPublic;
NV_UndefineSpace_In nv_UndefineSpace;
PolicyAuthorize_In policyAuthorize;
PolicyCpHash_In policyCpHash;
NV_DefineSpace_In nv_DefineSpace;
StartAuthSession_In startAuthSession;
VerifySignature_In verifySignature;
NV_Write_In nv_Write;
PolicyGetDigest_In policyGetDigest;
} in;
union
{
LoadExternal_Out loadExternal;
NV_ReadPublic_Out nv_ReadPublic;
NV_UndefineSpace_Out nv_UndefineSpace;
PolicyAuthorize_Out policyAuthorize;
PolicyCpHash_Out policyCpHash;
NV_DefineSpace_Out nv_DefineSpace;
StartAuthSession_Out startAuthSession;
VerifySignature_Out verifySignature;
NV_Write_Out nv_Write;
PolicyGetDigest_Out policyGetDigest;
} out;
ANY_OBJECT platformAuthorityKey = {0};
ANY_OBJECT nvIndex = {0};
TPM2B_DIGEST authPolicy = {0};
TPM2B_DIGEST cpHash = {0};
TPM2B_DIGEST approvedPolicy = {0};
TPM2B_DIGEST authorization = {0};
HASH_STATE hash = {0};
SESSION policySession = {0};
TPMT_TK_VERIFIED ticket = {0};
const TPM_CC commandCode = TPM_CC_NV_Write;
const UINT16 offset = 0;
// First we want to see if we have already a policyAuthority installed and
// if yes if this is the same one
INITIALIZE_CALL_BUFFERS(TPM2_LoadExternal, &in.loadExternal, &out.loadExternal);
in.loadExternal.inPublic = *platformAuthority;
in.loadExternal.hierarchy = TPM_RH_PLATFORM;
EXECUTE_TPM_CALL(FALSE, TPM2_LoadExternal);
platformAuthorityKey = parms.objectTableOut[TPM2_LoadExternal_HdlOut_ObjectHandle];
if((persistedData.platformAuthorityName.t.size != 0) &&
(!Memory2BEqual((TPM2B*)&persistedData.platformAuthorityName, (TPM2B*)&platformAuthorityKey.obj.name)))
{
result = TPM_RC_FAILURE;
goto Cleanup;
}
// Next we want to see if there is already a policy in NV and remove it if yes
INITIALIZE_CALL_BUFFERS(TPM2_NV_ReadPublic, &in.nv_ReadPublic, &out.nv_ReadPublic);
parms.objectTableIn[TPM2_NV_ReadPublic_HdlIn_NvIndex].nv.handle = TPM_PLATFORM_LOCKDOWN_POLICY_NV_INDEX;
TRY_TPM_CALL(FALSE, TPM2_NV_ReadPublic);
if(result == TPM_RC_SUCCESS)
{
// Get the old NV index object
nvIndex = parms.objectTableIn[TPM2_NV_ReadPublic_HdlIn_NvIndex];
INITIALIZE_CALL_BUFFERS(TPM2_NV_UndefineSpace, &in.nv_UndefineSpace, &out.nv_UndefineSpace);
parms.objectTableIn[TPM2_NV_UndefineSpace_HdlIn_AuthHandle].entity.handle = TPM_RH_PLATFORM;
parms.objectTableIn[TPM2_NV_UndefineSpace_HdlIn_NvIndex] = nvIndex;
EXECUTE_TPM_CALL(FALSE, TPM2_NV_UndefineSpace);
}
// Lets start by building the index policy digest from the policy authority key above
// Calculate the authPolicy for the index
MemorySet(&in.policyAuthorize, 0x00, sizeof(in.policyAuthorize));
in.policyAuthorize.approvedPolicy.t.size = SHA256_DIGEST_SIZE;
in.policyAuthorize.policyRef.t.size = SHA256_DIGEST_SIZE;
MemoryCopy(in.policyAuthorize.policyRef.t.buffer, &persistedData.ekName.t.name[sizeof(UINT16)], in.policyAuthorize.policyRef.t.size, sizeof(in.policyAuthorize.policyRef.t.buffer));
in.policyAuthorize.keySign = platformAuthorityKey.obj.name;
in.policyAuthorize.checkTicket.tag = TPM_ST_VERIFIED;
in.policyAuthorize.checkTicket.hierarchy = TPM_RH_NULL;
authPolicy.t.size = SHA256_DIGEST_SIZE;
TPM2_PolicyAuthorize_CalculateUpdate(TPM_ALG_SHA256, &authPolicy, &in.policyAuthorize);
// Now we create the Index in the TPM
INITIALIZE_CALL_BUFFERS(TPM2_NV_DefineSpace, &in.nv_DefineSpace, &out.nv_DefineSpace);
parms.objectTableIn[TPM2_NV_DefineSpace_HdlIn_AuthHandle].entity.handle = TPM_RH_PLATFORM;
in.nv_DefineSpace.publicInfo.t.nvPublic.dataSize = policy->t.size;
in.nv_DefineSpace.publicInfo.t.nvPublic.nameAlg = TPM_ALG_SHA256;
in.nv_DefineSpace.publicInfo.t.nvPublic.nvIndex = TPM_PLATFORM_LOCKDOWN_POLICY_NV_INDEX;
in.nv_DefineSpace.publicInfo.t.nvPublic.attributes.TPMA_NV_AUTHREAD = SET;
in.nv_DefineSpace.publicInfo.t.nvPublic.attributes.TPMA_NV_OWNERREAD = SET;
in.nv_DefineSpace.publicInfo.t.nvPublic.attributes.TPMA_NV_NO_DA = SET;
in.nv_DefineSpace.publicInfo.t.nvPublic.attributes.TPMA_NV_PLATFORMCREATE = SET;
in.nv_DefineSpace.publicInfo.t.nvPublic.attributes.TPMA_NV_POLICYWRITE = SET;
in.nv_DefineSpace.publicInfo.t.nvPublic.authPolicy = authPolicy;
EXECUTE_TPM_CALL(FALSE, TPM2_NV_DefineSpace);
// Read the name from the new index back
INITIALIZE_CALL_BUFFERS(TPM2_NV_ReadPublic, &in.nv_ReadPublic, &out.nv_ReadPublic);
parms.objectTableIn[TPM2_NV_ReadPublic_HdlIn_NvIndex].nv.handle = TPM_PLATFORM_LOCKDOWN_POLICY_NV_INDEX;
EXECUTE_TPM_CALL(FALSE, TPM2_NV_ReadPublic);
nvIndex = parms.objectTableIn[TPM2_NV_ReadPublic_HdlIn_NvIndex]; // Careful this name will change after writing
// Start a policy session in preparation of the initial write
INITIALIZE_CALL_BUFFERS(TPM2_StartAuthSession, &in.startAuthSession, &out.startAuthSession);
parms.objectTableIn[TPM2_StartAuthSession_HdlIn_TpmKey].obj.handle = TPM_RH_NULL;
parms.objectTableIn[TPM2_StartAuthSession_HdlIn_Bind].obj.handle = TPM_RH_NULL;
in.startAuthSession.nonceCaller.t.size = CryptGenerateRandom(SHA256_DIGEST_SIZE, in.startAuthSession.nonceCaller.t.buffer);
in.startAuthSession.sessionType = TPM_SE_POLICY;
in.startAuthSession.symmetric.algorithm = TPM_ALG_NULL;
in.startAuthSession.authHash = TPM_ALG_SHA256;
EXECUTE_TPM_CALL(FALSE, TPM2_StartAuthSession);
policySession = parms.objectTableOut[TPM2_StartAuthSession_HdlOut_SessionHandle].session;
// Next we are calculating cpHash for the write command that we want to execute later
cpHash.t.size = CryptStartHash(TPM_ALG_SHA256, &hash);
CryptUpdateDigestInt(&hash, sizeof(commandCode), (void*)&commandCode);
CryptUpdateDigest2B(&hash, &nvIndex.nv.name.b);
CryptUpdateDigest2B(&hash, &nvIndex.nv.name.b);
CryptUpdateDigestInt(&hash, sizeof(UINT16), &policy->t.size);
CryptUpdateDigest2B(&hash, (TPM2B*)policy);
CryptUpdateDigestInt(&hash, sizeof(UINT16), (void*)&offset);
CryptCompleteHash2B(&hash, &cpHash.b);
// We execute PolicyCpHash(cpHash) on the policy session to prepare the session for the
// NV_Write() command. No other command can be executed through this session after that
INITIALIZE_CALL_BUFFERS(TPM2_PolicyCpHash, &in.policyCpHash, &out.policyCpHash);
parms.objectTableIn[TPM2_PolicyCpHash_HdlIn_PolicySession].session = policySession;
in.policyCpHash.cpHashA = cpHash;
EXECUTE_TPM_CALL(FALSE, TPM2_PolicyCpHash);
// Now we read back the current policy digest. We are assuming everything is correct.
// If not things will start to blow up later.
INITIALIZE_CALL_BUFFERS(TPM2_PolicyGetDigest, &in.policyGetDigest, &out.policyGetDigest);
parms.objectTableIn[TPM2_PolicyGetDigest_HdlIn_PolicySession].session = policySession;
EXECUTE_TPM_CALL(FALSE, TPM2_PolicyGetDigest);
approvedPolicy = out.policyGetDigest.policyDigest;
// Calculate the authorization with the policy digest. If this authorization does not match
// what was signed by the platform authority the signature verification is going to fail
authorization.t.size = CryptStartHash(TPM_ALG_SHA256, &hash);
CryptUpdateDigest2B(&hash, (TPM2B*)&approvedPolicy);
CryptUpdateDigest(&hash, SHA256_DIGEST_SIZE, &persistedData.ekName.t.name[sizeof(UINT16)]);
CryptCompleteHash2B(&hash, &authorization.b);
// Verify the signature with the authorization - Moment of truth!
INITIALIZE_CALL_BUFFERS(TPM2_VerifySignature, &in.verifySignature, &out.verifySignature);
parms.objectTableIn[TPM2_VerifySignature_HdlIn_KeyHandle] = platformAuthorityKey;
in.verifySignature.digest = authorization;
in.verifySignature.signature = *authorizationSignature;
EXECUTE_TPM_CALL(FALSE, TPM2_VerifySignature);
ticket = out.verifySignature.validation;
// Now authorize the current write specific policy digest by executing policyAuthorize().
// If this matches the policy session will have the generic policy digest in it afterwards
INITIALIZE_CALL_BUFFERS(TPM2_PolicyAuthorize, &in.policyAuthorize, &out.policyAuthorize);
parms.objectTableIn[TPM2_PolicyCpHash_HdlIn_PolicySession].session = policySession;
in.policyAuthorize.checkTicket = ticket;
in.policyAuthorize.keySign = platformAuthorityKey.obj.name;
in.policyAuthorize.policyRef.t.size = SHA256_DIGEST_SIZE;
MemoryCopy(in.policyAuthorize.policyRef.t.buffer, &persistedData.ekName.t.name[sizeof(UINT16)], in.policyAuthorize.policyRef.t.size, sizeof(in.policyAuthorize.policyRef.t.buffer));
in.policyAuthorize.approvedPolicy = approvedPolicy;
EXECUTE_TPM_CALL(FALSE, TPM2_PolicyAuthorize);
// The policy session is now primed for the NV_Write() command and nothing else
// Because the session in the TPM has the cpHash for the pending command, while the
// policy digest in the session has the generic policy digest that the NV Index requires
policySession.attributes.continueSession = NO; // Kill the policy session with this command
sessionTable[0] = policySession;
INITIALIZE_CALL_BUFFERS(TPM2_NV_Write, &in.nv_Write, &out.nv_Write);
parms.objectTableIn[TPM2_NV_Write_HdlIn_AuthHandle] = nvIndex;
parms.objectTableIn[TPM2_NV_Write_HdlIn_NvIndex] = nvIndex;
in.nv_Write.data = *policy;
in.nv_Write.offset = 0;
EXECUTE_TPM_CALL(FALSE, TPM2_NV_Write);
if(persistedData.platformAuthorityName.t.size == 0)
{
// Finally if we wrote a policy make sure that we remember the policy
// authority in the MCU if it was not set already
persistedData.platformAuthorityName = platformAuthorityKey.obj.name;
}
Cleanup:
if(platformAuthorityKey.obj.handle != 0)
{
FlushContext(&platformAuthorityKey);
}
return result;
}
