int router_set_dup_flow(void * message,void * policy)
{
int ret;
MSG_HEAD * msg_head;
DISPATCH_POLICY * msg_policy=(DISPATCH_POLICY *)policy;
ROUTE_RULE * rule;
char * target;
if(policy==NULL)
return -EINVAL;
if(message==NULL)
return -EINVAL;
msg_head=message_get_head(message);
Memset(msg_head->route,0,DIGEST_SIZE);
if(msg_policy->newname!=NULL)
Strncpy(msg_head->route,msg_policy->newname,DIGEST_SIZE);
msg_head->ljump=1;
msg_head->rjump=0;
msg_head->flow=MSG_FLOW_DELIVER;
// msg_head->flag=msg_policy->flag;
Memset(msg_head->receiver_uuid,0,DIGEST_SIZE);
message_set_policy(message,policy);
return 1;
}
/*
int match_message_record(void * match_rule,void * message)
{
int ret;
MSG_HEAD * msg_head=get_message_head(message);
if(msg_head==NULL)
return -EINVAL;
void * record_template = load_record_template(msg_head->record_type);
if(record_template==NULL)
return -EINVAL;
MATCH_RULE * rule=(MATCH_RULE *)match_rule;
char buffer[1024];
void * record;
ret=message_comp_elem_text(message,rule->seg,0,rule->value);
return ret;
}
*/
int router_set_aspect_flow(void * message,void * policy)
{
int ret;
MSG_HEAD * msg_head;
DISPATCH_POLICY * msg_policy=(DISPATCH_POLICY *)policy;
ROUTE_RULE * rule;
char * target;
if(policy==NULL)
return -EINVAL;
if(message==NULL)
return -EINVAL;
msg_head=message_get_head(message);
if(!(msg_head->flow&MSG_FLOW_ASPECT))
{
Memset(msg_head->route,0,DIGEST_SIZE);
Strncpy(msg_head->route,msg_policy->newname,DIGEST_SIZE);
msg_head->ljump=1;
msg_head->rjump=1;
msg_head->flow=msg_policy->type;
}
Memset(msg_head->receiver_uuid,0,DIGEST_SIZE);
message_set_policy(message,policy);
return 1;
}
int alloc_init()
{
Memset(&tempmem_struct,0,sizeof(tempmem_struct));
Memset(&static_struct,0,sizeof(static_struct));
Memset(cache_struct,0,sizeof(cache_struct));
Memset(&dynamic_struct,0,sizeof(dynamic_struct));
return 0;
}
//-----------------------------------------------------------------------------
// Initialize
//-----------------------------------------------------------------------------
void CConsole::Initialize( void )
{
m_nCurrCommand = 0;
m_nCurrPos = 0;
Memset( m_Commands, 0, sizeof( m_Commands ) );
Memset( m_szCurrCommand, 0, sizeof( m_szCurrCommand ) );
}
/* Reset mock data (for use before each test) */
static void ResetMocks(void)
{
Memset(&cparams, 0, sizeof(cparams));
cparams.shared_data_size = sizeof(shared_data);
cparams.shared_data_blob = shared_data;
cparams.gbb_data = &gbb;
Memset(&gbb, 0, sizeof(gbb));
gbb.major_version = GBB_MAJOR_VER;
gbb.minor_version = GBB_MINOR_VER;
gbb.flags = 0;
/*
* Only the outermost vboot_api_kernel call sets vboot_api_kernel's
* vnc. So clear it here too.
*/
Memset(VbApiKernelGetVnc(), 0, sizeof(VbNvContext));
VbNvSetup(VbApiKernelGetVnc());
VbNvTeardown(VbApiKernelGetVnc()); /* So CRC gets generated */
Memset(&shared_data, 0, sizeof(shared_data));
VbSharedDataInit(shared, sizeof(shared_data));
trust_ec = 0;
mock_in_rw = 0;
ec_ro_protected = 0;
ec_rw_protected = 0;
ec_run_image = 0; /* 0 = RO, 1 = RW */
ec_ro_updated = 0;
ec_rw_updated = 0;
in_rw_retval = VBERROR_SUCCESS;
protect_retval = VBERROR_SUCCESS;
update_retval = VBERROR_SUCCESS;
run_retval = VBERROR_SUCCESS;
get_expected_retval = VBERROR_SUCCESS;
shutdown_request_calls_left = -1;
Memset(mock_ec_ro_hash, 0, sizeof(mock_ec_ro_hash));
mock_ec_ro_hash[0] = 42;
mock_ec_ro_hash_size = sizeof(mock_ec_ro_hash);
Memset(mock_ec_rw_hash, 0, sizeof(mock_ec_rw_hash));
mock_ec_rw_hash[0] = 42;
mock_ec_rw_hash_size = sizeof(mock_ec_rw_hash);
Memset(want_ec_hash, 0, sizeof(want_ec_hash));
want_ec_hash[0] = 42;
want_ec_hash_size = sizeof(want_ec_hash);
update_hash = 42;
Memset(mock_sha, 0, sizeof(want_ec_hash));
mock_sha[0] = 42;
// TODO: ensure these are actually needed
Memset(screens_displayed, 0, sizeof(screens_displayed));
screens_count = 0;
}
/* Reset mock data (for use before each test) */
static void ResetMocks(void)
{
int gbb_used;
Memset(gbb_data, 0, sizeof(gbb_data));
gbb->major_version = GBB_MAJOR_VER;
gbb->minor_version = GBB_MINOR_VER;
gbb->flags = 0;
gbb_used = sizeof(GoogleBinaryBlockHeader);
gbb->hwid_offset = gbb_used;
strcpy(gbb_data + gbb->hwid_offset, "Test HWID");
gbb->hwid_size = strlen(gbb_data + gbb->hwid_offset) + 1;
gbb_used = (gbb_used + gbb->hwid_size + 7) & ~7;
gbb->bmpfv_offset = gbb_used;
bhdr = (BmpBlockHeader *)(gbb_data + gbb->bmpfv_offset);
gbb->bmpfv_size = sizeof(BmpBlockHeader);
gbb_used = (gbb_used + gbb->bmpfv_size + 7) & ~7;
memcpy(bhdr->signature, BMPBLOCK_SIGNATURE, BMPBLOCK_SIGNATURE_SIZE);
bhdr->major_version = BMPBLOCK_MAJOR_VERSION;
bhdr->minor_version = BMPBLOCK_MINOR_VERSION;
bhdr->number_of_localizations = 3;
Memset(&cparams, 0, sizeof(cparams));
cparams.shared_data_size = sizeof(shared_data);
cparams.shared_data_blob = shared_data;
cparams.gbb_data = gbb;
cparams.gbb_size = sizeof(gbb_data);
/*
* Note, VbApiKernelFree() expects this to be allocated by
* VbExMalloc(), so we cannot just assign it staticly.
*/
cparams.gbb = VbExMalloc(sizeof(*gbb));
gbb->header_size = sizeof(*gbb);
gbb->rootkey_offset = gbb_used;
gbb->rootkey_size = 64;
gbb_used += 64;
gbb->recovery_key_offset = gbb_used;
gbb->recovery_key_size = 64;
gbb_used += 64;
memcpy(cparams.gbb, gbb, sizeof(*gbb));
Memset(&vnc, 0, sizeof(vnc));
VbNvSetup(&vnc);
VbNvTeardown(&vnc); /* So CRC gets generated */
Memset(&shared_data, 0, sizeof(shared_data));
VbSharedDataInit(shared, sizeof(shared_data));
*debug_info = 0;
}
/**
* Reset mock data (for use before each test)
*/
static void ResetMocks(int i)
{
Memset(&lkparams, 0, sizeof(lkparams));
Memset(&mock_disks, 0, sizeof(mock_disks));
load_kernel_calls = 0;
got_recovery_request_val = VBNV_RECOVERY_NOT_REQUESTED;
got_find_disk = 0;
got_load_disk = 0;
got_return_val = 0xdeadbeef;
t = test + i;
}
int main() {
UUID_HEAD * test_uuid;
UUID_HEAD * test_uuid1;
BYTE digest[DIGEST_SIZE];
int ret;
// static unsigned char alloc_buffer[4096*(1+1+4+1+16+1+256)];
void * hash_head;
// alloc_init(alloc_buffer);
test_uuid=Calloc(sizeof(UUID_HEAD));
Memset(test_uuid->uuid,'A',DIGEST_SIZE);
hash_head=init_hash_list(8,0,0);
ret=hashlist_add_elem(hash_head,test_uuid);
Memset(digest,'A',DIGEST_SIZE);
test_uuid1=hashlist_find_elem(hash_head,digest);
test_uuid=hashlist_get_first(hash_head);
test_uuid1=hashlist_get_next(hash_head);
test_uuid=hashlist_remove_elem(hash_head,digest);
test_uuid1=hashlist_find_elem(hash_head,digest);
// void * list_queue;
// list_queue=init_list_queue();
// list_queue_put(list_queue,test_uuid);
// list_queue_put(list_queue,test_uuid1);
// void * temp;
// ret=list_queue_get(list_queue,&temp);
// ret=list_queue_get(list_queue,&temp);
// ret=list_queue_get(list_queue,&temp);
// free_list_queue(list_queue);
Free(test_uuid);
return 0;
}
int SV_AddTestClient() {
char buffer[1024];
int botport = 1;
int protocolVersion = ((int(*)())&ParseAddr(0x28FE40))(); //GetProtocolVersion
int checksum = ((int(*)())&ParseAddr(0x2093C))(); //BG_NetDataChecksum
int PersistentDataDefVersion = ((int(*)())&ParseAddr(0x1EA710))(); //LiveStorage_GetPersistentDataDefVersion
unsigned int PersistentDataDefVersionChecksum = ((int(*)())&ParseAddr(0x1EA740))(); //LiveStorage_GetPersistentDataDefFormatChecksum
//0x236084 - client->dropReason, causing issue, source: unknown. (SV_SendMessageToClient)
uint32_t patchData[] = { 0x38800005 };
write_process(0x22E55C, &patchData, 4);
Sprintf(buffer, "connect bot%d \"\\cg_predictItems\\1\\cl_anonymous\\0\\color\\4\\head\\default\\model\\multi\\snaps\\20\\rate\\5000\\name\\bot%d\\protocol\\%d\\checksum\\%d\\statver\\%d %u\\qport\\%d\"", botport, botport, protocolVersion, checksum, PersistentDataDefVersion, PersistentDataDefVersionChecksum, botport);
Memset((void*)ThreadStorage_a, 0, sizeof(netadr_s));
netadr_s* newConnection = (netadr_s*)(ThreadStorage_a);
newConnection->port = botport;
((void(*)(const char*))&ParseAddr(0x1DBA20))(buffer); //SV_CmdTokenizeString(const char* string)
((void(*)(netadr_s*))&ParseAddr(0x226074))(newConnection); //SV_DirectConnect(netadr_s* connectionInfo)
((void(*)())&ParseAddr(0x1DB524))(); //SV_CmdEndTokenizeString()
*(short*)(getClient_t(botport) + 0x352EA) = 0x3FF; //Set Stat Flags
*(short*)(getClient_t(botport) + 0x30) = botport; //botPort
((void(*)(int client))&ParseAddr(0x2284F8))(getClient_t(botport)); //SV_SendClientGameState(client_t* client)
((void(*)(int client, int usercmd))&ParseAddr(0x2272DC))(getClient_t(botport), ThreadStorage_a); //SV_ClientEnterWorld(client_t* client, usercmd_s* lastUserCmd)
}
static void
kbinitmap(VOID)
{
(void)Memset((void*)&keymap[0],(int)KEYBOARD_UNKNOWN,sizeof(keymap));
keymap[(unsigned)'b'] = KEYBOARD_PGUP;
keymap[(unsigned)'B'] = KEYBOARD_PGUP;
keymap[(unsigned)META('V')] = KEYBOARD_PGUP; /* Emacs scroll-down */
keymap[(unsigned)'\r'] = KEYBOARD_DOWN; /* the less and more pagers bind */
keymap[(unsigned)'\n'] = KEYBOARD_DOWN; /* these keys to KEYBOARD_DOWN */
keymap[(unsigned)'d'] = KEYBOARD_DOWN;
keymap[(unsigned)'D'] = KEYBOARD_DOWN;
keymap[(unsigned)CTL('N')] = KEYBOARD_DOWN; /* Emacs next-line*/
keymap[(unsigned)'e'] = KEYBOARD_END;
keymap[(unsigned)'E'] = KEYBOARD_END;
keymap[(unsigned)META('>')] = KEYBOARD_END; /* Emacs end-of-buffer */
keymap[(unsigned)'>'] = KEYBOARD_END;
keymap[(unsigned)'f'] = KEYBOARD_PGDN;
keymap[(unsigned)'F'] = KEYBOARD_PGDN;
keymap[(unsigned)' '] = KEYBOARD_PGDN;
keymap[(unsigned)CTL('V')] = KEYBOARD_PGDN; /* Emacs scroll-up */
keymap[(unsigned)'h'] = KEYBOARD_HELP;
keymap[(unsigned)'H'] = KEYBOARD_HELP;
keymap[(unsigned)'?'] = KEYBOARD_HELP;
keymap[(unsigned)CH_BACKSPACE] = KEYBOARD_HELP; /* Emacs help */
keymap[(unsigned)CH_ESCAPE] = KEYBOARD_QUIT; /* ESCape gets out */
keymap[(unsigned)'q'] = KEYBOARD_QUIT;
keymap[(unsigned)'Q'] = KEYBOARD_QUIT;
keymap[(unsigned)'.'] = KEYBOARD_AGAIN;
keymap[(unsigned)'r'] = KEYBOARD_AGAIN;
keymap[(unsigned)'R'] = KEYBOARD_AGAIN;
keymap[(unsigned)CTL('L')] = KEYBOARD_AGAIN; /* Emacs recenter */
keymap[(unsigned)'t'] = KEYBOARD_HOME;
keymap[(unsigned)'T'] = KEYBOARD_HOME;
keymap[(unsigned)META('<')] = KEYBOARD_HOME; /* Emacs beginning-of-buffer */
keymap[(unsigned)'<'] = KEYBOARD_HOME;
keymap[(unsigned)CTL('R')] = KEYBOARD_SEARCH_BACKWARD; /* Emacs */
keymap[(unsigned)'\\'] = KEYBOARD_SEARCH_BACKWARD;
keymap[(unsigned)CTL('S')] = KEYBOARD_SEARCH_FORWARD; /* Emacs */
keymap[(unsigned)'/'] = KEYBOARD_SEARCH_FORWARD;
keymap[(unsigned)'u'] = KEYBOARD_UP;
keymap[(unsigned)'U'] = KEYBOARD_UP;
keymap[(unsigned)CTL('P')] = KEYBOARD_UP; /* Emacs previous-line */
keymap[(unsigned)'['] = KEYBOARD_UP_PARAGRAPH;
keymap[(unsigned)']'] = KEYBOARD_DOWN_PARAGRAPH;
keymap[(unsigned)'{'] = KEYBOARD_UP_PARAGRAPH;
keymap[(unsigned)'}'] = KEYBOARD_DOWN_PARAGRAPH;
}
void * Palloc0(int size,void * base)
{
void * mem=Palloc(size,base);
if(mem!=NULL)
Memset(mem,0,size);
return mem;
}
int VbSharedDataInit(VbSharedDataHeader *header, uint64_t size)
{
VBDEBUG(("VbSharedDataInit, %d bytes, header %d bytes\n", (int)size,
(int)sizeof(VbSharedDataHeader)));
if (size < sizeof(VbSharedDataHeader)) {
VBDEBUG(("Not enough data for header.\n"));
return VBOOT_SHARED_DATA_INVALID;
}
if (size < VB_SHARED_DATA_MIN_SIZE) {
VBDEBUG(("Shared data buffer too small.\n"));
return VBOOT_SHARED_DATA_INVALID;
}
if (!header)
return VBOOT_SHARED_DATA_INVALID;
/* Zero the header */
Memset(header, 0, sizeof(VbSharedDataHeader));
/* Initialize fields */
header->magic = VB_SHARED_DATA_MAGIC;
header->struct_version = VB_SHARED_DATA_VERSION;
header->struct_size = sizeof(VbSharedDataHeader);
header->data_size = size;
header->data_used = sizeof(VbSharedDataHeader);
header->firmware_index = 0xFF;
/* Success */
return VBOOT_SUCCESS;
}
void * Calloc0(int size)
{
void * mem=Calloc(size);
if(mem!=NULL)
Memset(mem,0,size);
return mem;
}
/**
* @UART uart wfi deepsleep wakeup demo
* @param none
* @return none
*/
void UartWFIDeepSleepWuDemo(void)
{
UINT8 i,recbuf[3];
Memset(recbuf,0x0,3);
IomUARTRXWuEn();
IomUARTRXWuLevHi();
ModuleIrqRegister(Uart_Exception, UartIrqService);
printf("Uart WFI deep sleep enter!!!\r\n");
SCB->SCR |= 0x04;
__WFI();
UartReceive(recbuf, 1);
printf("\r\n");
if(SCU->WKSR0 &0x40)
{
ScuWkSrcUartClr();
printf("Uart WFI Deep sleep Wakeup!\r\n");
}
for(i = 0; i < 1; i++)
{
printf("recbuf[%d]=0x%x\r\n",i,recbuf[i]);
}
}
/**
* @UART uart wfe deepsleep wakeup demo
* @param none
* @return none
*/
void UartWFEDeepSleepWuDemo(void)
{
UINT8 i, recbuf[3];
Memset(recbuf,0x0,3);
IomUARTRXWuEn();
IomUARTRXWuLevHi();
printf("Uart WFE deep sleep enter!!!\r\n");
ScuWakeCoreEvent();
__SEV();
SCB->SCR |= 0x04;
__WFE();
__WFE();
UartReceive(recbuf, 1);
printf("\r\n");
if(SCU->WKSR0 &0x40)
{
ScuWkSrcUartClr();
printf("Uart WFE Deep sleep Wakeup!\r\n");
}
for(i = 0; i < 1; i++)
{
printf("recbuf[%d]=0x%x\r\n",i,recbuf[i]);
}
}
MongodbClientInternalData()
{
connection = new mongo();
DVASSERT(connection);
Memset(connection, 0, sizeof(mongo));
mongo_init(connection);
}
void * general_alloc0( int type, int flag,struct alloc_struct * mem_struct,int size)
{
void * pointer=general_alloc(type,flag,mem_struct,size);
if(pointer!=NULL)
{
Memset(pointer,0,size);
}
return pointer;
}
VbKeyBlockHeader* KeyBlockCreate(const VbPublicKey* data_key,
const VbPrivateKey* signing_key,
uint64_t flags) {
VbKeyBlockHeader* h;
uint64_t signed_size = sizeof(VbKeyBlockHeader) + data_key->key_size;
uint64_t block_size = (signed_size + SHA512_DIGEST_SIZE +
(signing_key ?
siglen_map[signing_key->algorithm] : 0));
uint8_t* data_key_dest;
uint8_t* block_sig_dest;
uint8_t* block_chk_dest;
VbSignature *sigtmp;
/* Allocate key block */
h = (VbKeyBlockHeader*)malloc(block_size);
if (!h)
return NULL;
data_key_dest = (uint8_t*)(h + 1);
block_chk_dest = data_key_dest + data_key->key_size;
block_sig_dest = block_chk_dest + SHA512_DIGEST_SIZE;
Memcpy(h->magic, KEY_BLOCK_MAGIC, KEY_BLOCK_MAGIC_SIZE);
h->header_version_major = KEY_BLOCK_HEADER_VERSION_MAJOR;
h->header_version_minor = KEY_BLOCK_HEADER_VERSION_MINOR;
h->key_block_size = block_size;
h->key_block_flags = flags;
/* Copy data key */
PublicKeyInit(&h->data_key, data_key_dest, data_key->key_size);
PublicKeyCopy(&h->data_key, data_key);
/* Set up signature structs so we can calculate the signatures */
SignatureInit(&h->key_block_checksum, block_chk_dest,
SHA512_DIGEST_SIZE, signed_size);
if (signing_key)
SignatureInit(&h->key_block_signature, block_sig_dest,
siglen_map[signing_key->algorithm], signed_size);
else
Memset(&h->key_block_signature, 0, sizeof(VbSignature));
/* Calculate checksum */
sigtmp = CalculateChecksum((uint8_t*)h, signed_size);
SignatureCopy(&h->key_block_checksum, sigtmp);
free(sigtmp);
/* Calculate signature */
if (signing_key) {
sigtmp = CalculateSignature((uint8_t*)h, signed_size, signing_key);
SignatureCopy(&h->key_block_signature, sigtmp);
free(sigtmp);
}
/* Return the header */
return h;
}
/********************************************************************
Function name: MpuDSecDemo
Input parameters:
NULL
Return:
NULL
Function:
MPU SRAM Secmode function.
********************************************************************/
void MpuDSecDemo(void)
{
UINT32 desaddr,srcaddr,back;
UINT16 i;
UINT8 *p;
UINT32 *addr1;
desaddr = 0x2000F800;
srcaddr = (UINT32)dma_src;
MpuSetSecMode(MPUCR_SEC1_EN);
addr1 = (UINT32 *)0x2000F800;
back = *addr1;
*addr1 = 0x12345678;
if(*addr1 != 0x12345678)
{
//Todo: program fail;
printf("MpuDSecDemo err \r\n");
}
else
{
*addr1 = back;
printf("MpuDSecDemo OK\r\n");
}
Memset(dma_src, 0xFF, sizeof(dma_src));
ScuDmaClkEn();
DmaChLock(0);
SetupMode(0, MEM_MEM, DISCRIC, 0, 0, 1, 1, W_8BIT, 10, 0);
SetTransAddress(0, srcaddr, desaddr);
SetTransLength(0, 10);
if(DmaTrans(0) != DMA_RET_SUCESS)
{
//TODO:program fail;
}
else
{
p = (UINT8*)0x2000F800;
for(i = 0;i<10;i++,p++)
{
if(dma_src[i]!= *p)
{
//TODO: program fail
printf("MpuDSecDemo DMA err \r\n");
return;
}
}
}
printf("MpuDSecDemo DMA OK \r\n");
DmaChUnlock(0);
ScuDmaClkDis();
MpuClrSecMode(MPUCR_SEC1_EN);
}
//-----------------------------------------------------------------------------
// Initialize
//-----------------------------------------------------------------------------
void CRenderer::Initialize( void )
{
m_pLineBuffer = NULL;
m_pDevice = NULL;
m_pViewProjCB = NULL;
m_pWorldCB = NULL;
m_nDefaultMesh = INVALID_HANDLE;
m_nDefaultTexture = INVALID_HANDLE;
m_pCurrentView = NULL;
m_nNumCommands = 0;
Memset( m_pRenderCommands, 0, sizeof( m_pRenderCommands ) );
m_nNumBoxes = 0;
m_nSphereMesh = INVALID_HANDLE;
m_nDebugBox = INVALID_HANDLE;
m_pPrevCommands = m_pRenderCommands[0];
m_pCurrCommands = m_pRenderCommands[1];
m_pPrevTransforms = m_pTransforms[0];
m_pCurrTransforms = m_pTransforms[1];
m_pPrevDebugBoxes = m_DebugBoxes[0];
m_pCurrDebugBoxes = m_DebugBoxes[1];
m_pPrevDebugRays = m_DebugRays[0];
m_pCurrDebugRays = m_DebugRays[1];
m_pPrevLights = &m_pLights[0];
m_pCurrLights = &m_pLights[1];
Memset( m_ppVertexShaders, 0, sizeof( m_ppVertexShaders ) );
Memset( m_ppVertexLayouts, 0, sizeof( m_ppVertexLayouts ) );
Memset( m_ppPixelShaders, 0, sizeof( m_ppPixelShaders ) );
Memset( m_ppSamplerStates, 0, sizeof( m_ppSamplerStates ) );
Memset( m_ppMeshes, 0, sizeof( m_ppMeshes ) );
m_nNumMeshes = 0;
Memset( m_ppTextures, 0, sizeof( m_ppTextures ) );
m_nNumTextures = 0;
Memset( m_pLights, 0, sizeof( m_pLights ) );
m_nWidth = m_nHeight = -1;
m_pTestRT = NULL;
}
void* HcpNI::Memset(void* pDest, const hcp_Int Value, const hcp_Size_t Length, void* pContext) {
void* result = NULL;
if (pContext != NULL) {
auto hni = static_cast<HcpNI*>(pContext);
result = hni->Memset(pDest, Value, Length);
}
return result;
}
VbKernelPreambleHeader *CreateKernelPreamble(
uint64_t kernel_version,
uint64_t body_load_address,
uint64_t bootloader_address,
uint64_t bootloader_size,
const VbSignature *body_signature,
uint64_t desired_size,
const VbPrivateKey *signing_key)
{
VbKernelPreambleHeader *h;
uint64_t signed_size = (sizeof(VbKernelPreambleHeader) +
body_signature->sig_size);
uint64_t block_size = signed_size + siglen_map[signing_key->algorithm];
uint8_t *body_sig_dest;
uint8_t *block_sig_dest;
VbSignature *sigtmp;
/* If the block size is smaller than the desired size, pad it */
if (block_size < desired_size)
block_size = desired_size;
/* Allocate key block */
h = (VbKernelPreambleHeader *)malloc(block_size);
if (!h)
return NULL;
Memset(h, 0, block_size);
body_sig_dest = (uint8_t *)(h + 1);
block_sig_dest = body_sig_dest + body_signature->sig_size;
h->header_version_major = KERNEL_PREAMBLE_HEADER_VERSION_MAJOR;
h->header_version_minor = KERNEL_PREAMBLE_HEADER_VERSION_MINOR;
h->preamble_size = block_size;
h->kernel_version = kernel_version;
h->body_load_address = body_load_address;
h->bootloader_address = bootloader_address;
h->bootloader_size = bootloader_size;
/* Copy body signature */
SignatureInit(&h->body_signature, body_sig_dest,
body_signature->sig_size, 0);
SignatureCopy(&h->body_signature, body_signature);
/* Set up signature struct so we can calculate the signature */
SignatureInit(&h->preamble_signature, block_sig_dest,
siglen_map[signing_key->algorithm], signed_size);
/* Calculate signature */
sigtmp = CalculateSignature((uint8_t *)h, signed_size, signing_key);
SignatureCopy(&h->preamble_signature, sigtmp);
free(sigtmp);
/* Return the header */
return h;
}
VbFirmwarePreambleHeader *CreateFirmwarePreamble(
uint64_t firmware_version,
const VbPublicKey *kernel_subkey,
const VbSignature *body_signature,
const VbPrivateKey *signing_key,
uint32_t flags)
{
VbFirmwarePreambleHeader *h;
uint64_t signed_size = (sizeof(VbFirmwarePreambleHeader) +
kernel_subkey->key_size +
body_signature->sig_size);
uint64_t block_size = signed_size + siglen_map[signing_key->algorithm];
uint8_t *kernel_subkey_dest;
uint8_t *body_sig_dest;
uint8_t *block_sig_dest;
VbSignature *sigtmp;
/* Allocate key block */
h = (VbFirmwarePreambleHeader *)malloc(block_size);
if (!h)
return NULL;
Memset(h, 0, block_size);
kernel_subkey_dest = (uint8_t *)(h + 1);
body_sig_dest = kernel_subkey_dest + kernel_subkey->key_size;
block_sig_dest = body_sig_dest + body_signature->sig_size;
h->header_version_major = FIRMWARE_PREAMBLE_HEADER_VERSION_MAJOR;
h->header_version_minor = FIRMWARE_PREAMBLE_HEADER_VERSION_MINOR;
h->preamble_size = block_size;
h->firmware_version = firmware_version;
h->flags = flags;
/* Copy data key */
PublicKeyInit(&h->kernel_subkey, kernel_subkey_dest,
kernel_subkey->key_size);
PublicKeyCopy(&h->kernel_subkey, kernel_subkey);
/* Copy body signature */
SignatureInit(&h->body_signature, body_sig_dest,
body_signature->sig_size, 0);
SignatureCopy(&h->body_signature, body_signature);
/* Set up signature struct so we can calculate the signature */
SignatureInit(&h->preamble_signature, block_sig_dest,
siglen_map[signing_key->algorithm], signed_size);
/* Calculate signature */
sigtmp = CalculateSignature((uint8_t *)h, signed_size, signing_key);
SignatureCopy(&h->preamble_signature, sigtmp);
free(sigtmp);
/* Return the header */
return h;
}
int symm_crypt_init(void * sub_proc,void * para)
{
int ret;
// add youself's plugin init func here
struct init_struct * init_para=para;
if(para==NULL)
return -EINVAL;
Memset(passwd,0,DIGEST_SIZE);
Strncpy(passwd,init_para->passwd,DIGEST_SIZE);
return 0;
}
const void *StatefulMemset_r(MemcpyState *state, const uint8_t val,
uint64_t len)
{
if (state->overrun)
return NULL;
if (len > state->remaining_len) {
state->overrun = 1;
return NULL;
}
Memset(state->remaining_buf, val, len);
state->remaining_buf += len;
state->remaining_len -= len;
return state; /* Must return something non-NULL. */
}
/**
* @UART uart sleep wakeup demo
* @param none
* @return none
*/
void UartSleepWuDemo(void)
{
UINT8 recbuf[3];
Memset(recbuf,0x0,3);
ModuleIrqRegister(Uart_Exception, UartIrqService);
printf("Uart WFI sleep enetr!\r\n");
//sleep
SCB->SCR &= ~0x04;
//sleep mode enter
__WFI();
UartReceive(recbuf, 1);
printf("\r\n");
printf("Uart WFI sleep Wakeup!\r\n");
}
void * init_pointer_queue(int size)
{
POINTER_QUEUE * queue;
BYTE * buffer;
buffer=Talloc(sizeof(POINTER_QUEUE)+sizeof(void *)*size);
if(buffer==NULL)
return NULL;
queue=(POINTER_QUEUE *)buffer;
Memset(queue,0,sizeof(POINTER_QUEUE)+sizeof(void *)*size);
queue->buffer=(void **)(buffer+sizeof(POINTER_QUEUE));
queue->size=size;
queue->head=-1;
return queue;
}
/**
* @Spim1 standard mode read NorFlash function
* @param
* @return none
* @note
* -Spim1 standard mode read NorFlash
*/
void Spim1ReadNorFlashStdMode(UINT32 start_add, UINT8 *data_buf, UINT32 read_len)
{
UINT32 read_addr;
UINT32 tmplen, total_len = 0;
UINT8 ins_buf[4];
while (total_len < read_len)
{
tmplen = read_len - total_len;
if (tmplen > FLASH_PAGE_SIZE)
{
tmplen = FLASH_PAGE_SIZE;
}
read_addr = start_add + total_len;
ins_buf[0]= read_data;
ins_buf[1]=(UINT8)((read_addr>>16) & 0x000000ff);
ins_buf[2]=(UINT8)((read_addr>>8) & 0x000000ff);
ins_buf[3]=(UINT8)((read_addr>>0) & 0x000000ff);
Spim1CheckNorFlashBusy();
Spim1SetCsLow();
Spim1SendData(0, ins_buf, 4);
Spim1RecvData(0, data_buf + total_len, tmplen);
Spim1SetCsHigh();
read_addr = start_add + total_len;
ins_buf[0]= read_data;
ins_buf[1]=(UINT8)((read_addr>>16) & 0x000000ff);
ins_buf[2]=(UINT8)((read_addr>>8) & 0x000000ff);
ins_buf[3]=(UINT8)((read_addr>>0) & 0x000000ff);
Spim1CheckNorFlashBusy();
Spim1SetCsLow();
Spim1SendData(0, ins_buf, 4);
Memset(data_buf, 0, tmplen);
Spim1RecvData(0, data_buf + total_len, tmplen);
Spim1SetCsHigh();
total_len += tmplen;
}
}
/**************************************************************************
* fn:
* socket: 发送的socket
* fd: 录像文件的句柄
***************************************************************************/
int DcpStartRecDownload( int socket, int fd )
{
int ret = -1;
pthread_t threadId;
REC_DOWNLOAD_T *pRecDownload = (REC_DOWNLOAD_T *)Malloc( sizeof(REC_DOWNLOAD_T) );
if( NULL != pRecDownload )
{
pRecDownload->socket = socket;
pRecDownload->fd = fd;
Memset( &pRecDownload->sendPack.packHead, 0x00,
sizeof(pRecDownload->sendPack.packHead) );
ret = ThreadCreate( &threadId, DcpRecDownloadThread, pRecDownload );
}
return ret;
}
/**
* Initialization function. Returns context for processing dev-mode delay.
*/
VbAudioContext *VbAudioOpen(VbCommonParams *cparams)
{
GoogleBinaryBlockHeader* gbb =
(GoogleBinaryBlockHeader *)cparams->gbb_data;
VbAudioContext *audio = &au;
int use_short = 0;
uint64_t a, b;
/* Note: may need to allocate things here in future */
/* Calibrate audio delay */
a = VbExGetTimer();
VbExSleepMs(10);
b = VbExGetTimer();
ticks_per_msec = (b - a) / 10ULL ;
VBDEBUG(("VbAudioOpen() - ticks_per_msec is %llu\n", ticks_per_msec));
/* Initialize */
Memset(audio, 0, sizeof(*audio));
audio->background_beep = 1;
audio->play_until = b; /* "zero" starts now */
/* See if we have full background sound capability or not. */
if (VBERROR_SUCCESS != VbExBeep(0,0)) {
VBDEBUG(("VbAudioOpen() - VbExBeep() is limited\n"));
audio->background_beep = 0;
}
/*
* Prepare to generate audio/delay event. Use a short developer screen
* delay if indicated by GBB flags.
*/
if (gbb->major_version == GBB_MAJOR_VER && gbb->minor_version >= 1
&& (gbb->flags & GBB_FLAG_DEV_SCREEN_SHORT_DELAY)) {
VBDEBUG(("VbAudioOpen() - using short dev screen delay\n"));
use_short = 1;
}
VbGetDevMusicNotes(audio, use_short);
VBDEBUG(("VbAudioOpen() - note count %d\n", audio->note_count));
return audio;
}
