// Return the size of the given block in multiples of the word size static inline unsigned int block_size(const uint32_t* block) { REQUIRES(block != NULL); REQUIRES(in_heap(block)); //return (block[0] & 0x3FFFFFFF); return (*block)&(~0x7); }
// RETURNS: true iff the given trie TR contains a member that equal to s bool trie_member(trie TR, char *s) { REQUIRES(is_trie(TR)); REQUIRES(s != NULL && strlen(s) > 0); tnode *T = tnode_lookup(TR->root, s, 0); return T != NULL && T->is_end; }
bool trie_prefix(trie TR, char *s) { REQUIRES(is_trie(TR)); REQUIRES(s != NULL && strlen(s) > 0); tnode *T = tnode_lookup(TR->root, s, 0); return T != NULL && T->middle != NULL; }
// Mark the given block as free(1)/alloced(0) by marking the header and footer. static inline void block_mark(uint32_t* block, int free) { REQUIRES(block != NULL); REQUIRES(in_heap(block)); unsigned int next = block_size(block) + 1; block[0] = free ? block[0] & (int) 0xBFFFFFFF : block[0] | 0x40000000; block[next] = block[0]; }
// Set the size of the given block in multiples of 4 bytes static inline void set_size(uint32_t* const block, unsigned int size) { REQUIRES(block != NULL); REQUIRES(in_heap(block)); REQUIRES(size % 2 == 0); set_val(block, size); }
// Return a pointer to the memory malloc should return static inline uint32_t* block_mem(uint32_t* const block) { REQUIRES(block != NULL); REQUIRES(in_heap(block)); REQUIRES(aligned(block + 1)); if (VERBOSE) printf("Heap size = %d bytes \n", (int)mem_heapsize()); return block + 1; }
static void checkblock(void *bp) { REQUIRES (bp!=NULL); REQUIRES ((size_t)(bp)%8 == 0); if ((size_t)bp % 8) printf("Error: %p is not doubleword aligned\n", bp); if (GET(HDRP(GET_LOC(bp))) != GET(FTRP(GET_LOC(bp)))) printf("Error: header does not match footer\n"); }
static int readRDNcomponent( INOUT STREAM *stream, INOUT DN_COMPONENT **dnComponentListPtrPtr, IN_LENGTH_SHORT const int rdnDataLeft ) { CRYPT_ERRTYPE_TYPE dummy; BYTE stringBuffer[ MAX_ATTRIBUTE_SIZE + 8 ]; void *value; const int rdnStart = stell( stream ); int type, valueLength, valueStringType, stringTag; int flags = DN_FLAG_NOCHECK, status; assert( isWritePtr( stream, sizeof( STREAM ) ) ); assert( isWritePtr( dnComponentListPtrPtr, sizeof( DN_COMPONENT * ) ) ); REQUIRES( rdnDataLeft > 0 && rdnDataLeft < MAX_INTLENGTH_SHORT ); REQUIRES( rdnStart > 0 && rdnStart < MAX_INTLENGTH_SHORT ); /* Read the type information for this AVA */ status = readAVA( stream, &type, &valueLength, &stringTag ); if( cryptStatusError( status ) ) return( status ); if( valueLength <= 0 ) { /* Skip broken AVAs with zero-length strings */ return( CRYPT_OK ); } status = sMemGetDataBlock( stream, &value, valueLength ); if( cryptStatusOK( status ) ) status = sSkip( stream, valueLength ); if( cryptStatusError( status ) ) return( status ); ANALYSER_HINT( value != NULL ); /* If there's room for another AVA, mark this one as being continued. The +10 value is the minimum length for an AVA: SEQUENCE { OID, value } (2-bytes SEQUENCE + 5 bytes OID + 2 bytes (tag + length) + 1 byte min- length data). We don't do a simple =/!= check to get around incorrectly encoded lengths */ if( rdnDataLeft >= ( stell( stream ) - rdnStart ) + 10 ) flags |= DN_FLAG_CONTINUED; /* Convert the string into the local character set */ status = copyFromAsn1String( stringBuffer, MAX_ATTRIBUTE_SIZE, &valueLength, &valueStringType, value, valueLength, stringTag ); if( cryptStatusError( status ) ) return( status ); /* Add the DN component to the DN. If we hit a non-memory related error we turn it into a generic CRYPT_ERROR_BADDATA error since the other codes are somewhat too specific for this case, something like CRYPT_ERROR_INITED or an arg error isn't too useful for the caller */ status = insertDNstring( dnComponentListPtrPtr, type, stringBuffer, valueLength, valueStringType, flags, &dummy ); return( ( cryptStatusError( status ) && status != CRYPT_ERROR_MEMORY ) ? \ CRYPT_ERROR_BADDATA : status ); }
/* * Merge block with adjacent free blocks * Return: the pointer to the new free block */ static void *coalesce(void *block) { REQUIRES(block != NULL); REQUIRES(in_heap(block)); uint32_t *prev_block = block_prev(block); uint32_t *next_block = block_next(block); int prev_free = block_free(prev_block); int next_free = block_free(next_block); unsigned int words = block_size(block); if (prev_free && next_free) { // Case 4, both free block_delete(prev_block); block_delete(next_block); words += block_size(prev_block) + block_size(next_block) + 4; set_size(prev_block, words); block_mark(prev_block, FREE); block = (void *)prev_block; block_insert(block); ENSURES(in_list(block)); } else if (!prev_free && next_free) { // Case 2, next if free block_delete(next_block); words += block_size(next_block) + 2; set_size(block, words); block_mark(block, FREE); block_insert(block); ENSURES(in_list(block)); } else if (prev_free && !next_free) { // Case 3, prev is free block_delete(prev_block); words += block_size(prev_block) + 2; set_size(prev_block, words); block_mark(prev_block, FREE); block = (void *)prev_block; block_insert(block); ENSURES(in_list(block)); } else { // Case 1, both unfree block_insert(block); ENSURES(in_list(block)); return block; } return block; }
static int insertMemBlock( INOUT MEM_INFO_HEADER **allocatedListHeadPtr, INOUT MEM_INFO_HEADER **allocatedListTailPtr, INOUT MEM_INFO_HEADER *memHdrPtr ) { MEM_INFO_HEADER *allocatedListHead = *allocatedListHeadPtr; MEM_INFO_HEADER *allocatedListTail = *allocatedListTailPtr; assert( isWritePtr( allocatedListHeadPtr, sizeof( MEM_INFO_HEADER * ) ) ); assert( allocatedListHead == NULL || \ isWritePtr( allocatedListHead, sizeof( MEM_INFO_HEADER ) ) ); assert( isWritePtr( allocatedListTailPtr, sizeof( MEM_INFO_HEADER * ) ) ); assert( allocatedListTail == NULL || \ isWritePtr( allocatedListTail, sizeof( MEM_INFO_HEADER ) ) ); assert( isWritePtr( memHdrPtr, sizeof( MEM_INFO_HEADER * ) ) ); /* Precondition: The memory block list is empty, or there's at least a one-entry list present */ REQUIRES( ( allocatedListHead == NULL && allocatedListTail == NULL ) || \ ( allocatedListHead != NULL && allocatedListTail != NULL ) ); /* If it's a new list, set up the head and tail pointers and return */ if( allocatedListHead == NULL ) { /* In yet another of gcc's endless supply of compiler bugs, if the following two lines of code are combined into a single line then the write to the first value, *allocatedListHeadPtr, ends up going to some arbitrary memory location and only the second write goes to the correct location (completely different code is generated for the two writes) This leaves krnlData->allocatedListHead as a NULL pointer, leading to an exception being triggered the next time that it's accessed */ #if defined( __GNUC__ ) && ( __GNUC__ == 4 ) *allocatedListHeadPtr = memHdrPtr; *allocatedListTailPtr = memHdrPtr; #else *allocatedListHeadPtr = *allocatedListTailPtr = memHdrPtr; #endif /* gcc 4.x compiler bug */ return( CRYPT_OK ); } /* It's an existing list, add the new element to the end */ REQUIRES( checkMemBlockHdr( allocatedListTail ) ); allocatedListTail->next = memHdrPtr; setMemChecksum( allocatedListTail ); memHdrPtr->prev = allocatedListTail; *allocatedListTailPtr = memHdrPtr; /* Postcondition: The new block has been linked into the end of the list */ ENSURES( allocatedListTail->next == memHdrPtr && \ memHdrPtr->prev == allocatedListTail && \ memHdrPtr->next == NULL ); return( CRYPT_OK ); }
void bst_insert(bst B, elem x) { REQUIRES(is_bst(B)); REQUIRES(x != NULL); B->root = tree_insert(B->root, x, B); ENSURES(is_bst(B)); return; }
gmacError_t Mode::memset(accptr_t addr, int c, size_t size) { REQUIRES(addr != 0); REQUIRES(size > 0); gmacError_t ret; ret = Parent::memset(addr, c, size); return ret; }
static int deleteItemFunction( DEVICE_INFO *deviceInfo, const KEYMGMT_ITEM_TYPE itemType, const CRYPT_KEYID_TYPE keyIDtype, const void *keyID, const int keyIDlength ) { HARDWARE_INFO *hardwareInfo = deviceInfo->deviceHardware; MESSAGE_KEYMGMT_INFO getkeyInfo, deletekeyInfo; int status; assert( isWritePtr( deviceInfo, sizeof( DEVICE_INFO ) ) ); assert( isReadPtr( keyID, keyIDlength ) ); REQUIRES( itemType == KEYMGMT_ITEM_PUBLICKEY || \ itemType == KEYMGMT_ITEM_PRIVATEKEY ); REQUIRES( keyIDtype == CRYPT_KEYID_NAME ); REQUIRES( keyIDlength > 0 && keyIDlength <= CRYPT_MAX_TEXTSIZE ); /* Perform the delete both from the PKCS #15 storage object and the native storage. This gets a bit complicated because in order to find the hardware object we have to extract the storageID, and in order to get that we have to instantiate a dummy private-key object to contain it. In addition if the object that's stored isn't a private-key object then there's no associated cryptographic hardware object. To handle this we try and instantiate a dummy private-key object in order to get the storageID. If this succeeds, we locate the underlying hardware object and delete it. Finally, we delete the PKCS #15 object, either a pure public-key/certificate object or the private-key metadata for the cryptographic hardware object */ if( hardwareInfo->iCryptKeyset == CRYPT_ERROR ) return( CRYPT_ERROR_NOTINITED ); setMessageKeymgmtInfo( &getkeyInfo, keyIDtype, keyID, keyIDlength, NULL, 0, KEYMGMT_FLAG_NONE ); status = krnlSendMessage( hardwareInfo->iCryptKeyset, IMESSAGE_KEY_GETKEY, &getkeyInfo, KEYMGMT_ITEM_PRIVATEKEY ); if( cryptStatusOK( status ) ) { int keyHandle; /* It's a private-key object, get its hardware reference and delete it. If this fails we continue anyway because we know that there's also a PKCS #15 object to delete */ status = getHardwareReference( getkeyInfo.cryptHandle, &keyHandle ); if( cryptStatusOK( status ) ) ( void ) hwDeleteItem( keyHandle ); krnlSendNotifier( getkeyInfo.cryptHandle, IMESSAGE_DECREFCOUNT ); } setMessageKeymgmtInfo( &deletekeyInfo, keyIDtype, keyID, keyIDlength, NULL, 0, KEYMGMT_FLAG_NONE ); return( krnlSendMessage( hardwareInfo->iCryptKeyset, IMESSAGE_KEY_DELETEKEY, &deletekeyInfo, itemType ) ); }
static void add_block_to_list(int index, void* block){ REQUIRES(0 <= index && index <= NUM_FREE_LISTS); REQUIRES(block != NULL); REQUIRES(in_heap(block)); set_prev_pointer(block, NULL); set_next_pointer(block, free_lists[index]); if(free_lists[index] != NULL) set_prev_pointer(free_lists[index], block); free_lists[index] = block; }
gmacError_t Mode::copyToAccelerator(accptr_t acc, const hostptr_t host, size_t size) { REQUIRES(acc != 0); REQUIRES(host != NULL); REQUIRES(size > 0); gmacError_t ret; ret = Parent::copyToAccelerator(acc, host, size); return ret; }
gmacError_t Mode::bufferToAccelerator(accptr_t dst, IOBufferImpl &buffer, size_t size, size_t off) { REQUIRES(size > 0); REQUIRES(off + size <= buffer.size()); gmacError_t ret; ret = Parent::bufferToAccelerator(dst, buffer, size, off); return ret; }
gmacError_t Mode::acceleratorToBuffer(IOBufferImpl &buffer, const accptr_t dst, size_t size, size_t off) { REQUIRES(size > 0); REQUIRES(off + size <= buffer.size()); gmacError_t ret; ret = Parent::acceleratorToBuffer(buffer, dst, size, off); return ret; }
// GIVEN: a tnode T and a non-empty string s[i,) // RETURNS: if s[i,) is a prefix of T, return the node that corresponding // to the last char of s, otherwise return NULL tnode *tnode_lookup(tnode *T, char *s, size_t i) { REQUIRES(is_tnode_root(T)); REQUIRES(s != NULL); REQUIRES(i < strlen(s)); if (T == NULL) return NULL; if (s[i] < T->c) return tnode_lookup(T->left, s, i); if (s[i] > T->c) return tnode_lookup(T->right, s, i); if (s[i+1] == '\0') return T; return tnode_lookup(T->middle, s, i+1); }
bool is_heap_except_down(heap H, int n) { REQUIRES(is_safe_heap(H)); REQUIRES(1 <= n && n < H->next); for (int i = 2; i < H->next; i++) { ASSERT(2 <= i); if (!(i/2 == n || ok_above(H, i/2, i))) return false; } return true; }
queue_elem deq(queue *Q) { REQUIRES(is_queue(Q)); REQUIRES(!queue_empty(Q)); queue_elem x = Q->front->data; /* save old queue element to return */ list *q = Q->front; /* save old list node to free */ Q->front = Q->front->next; free(q); /* free old list node */ ENSURES(is_queue(Q)); return x; /* return old queue element */ }
gmacError_t Mode::copyToHost(hostptr_t host, const accptr_t acc, size_t size) { REQUIRES(host != NULL); REQUIRES(acc != 0); REQUIRES(size > 0); gmacError_t ret; ret = Parent::copyToHost(host, acc, size); return ret; }
gmacError_t Mode::copyAccelerator(accptr_t dst, const accptr_t src, size_t size) { REQUIRES(dst != 0); REQUIRES(src != 0); REQUIRES(size > 0); gmacError_t ret; ret = Parent::copyAccelerator(dst, src, size); return ret; }
int dynCreate( OUT DYNBUF *dynBuf, IN_HANDLE const CRYPT_HANDLE cryptHandle, IN_ATTRIBUTE const CRYPT_ATTRIBUTE_TYPE attributeType ) { assert( isWritePtr( dynBuf, sizeof( DYNBUF ) ) ); REQUIRES( isHandleRangeValid( cryptHandle ) ); REQUIRES( isAttribute( attributeType ) || \ isInternalAttribute( attributeType ) ); return( getDynData( dynBuf, cryptHandle, IMESSAGE_GETATTRIBUTE_S, attributeType ) ); }
// DETAILS: s might contains '*' which representa arbitrary number of arbitrary // character // EFFECT: add all members in the given T that match the given string // s to q void trie_member_generalized(trie T, char *s, Queue q) { REQUIRES(is_trie(T)); REQUIRES(s != NULL); REQUIRES(is_Queue(q)); struct strbuf *sb = strbuf_new(8); tnode_lookup_generalized(T->root, s, 0, strlen(s), sb, q); free(strbuf_dealloc(sb)); ENSURES(is_Queue(q)); return; }
// Return the header to the successor free block static inline uint32_t* block_succ(uint32_t* const block) { REQUIRES(block != NULL); REQUIRES(in_heap(block)); uint32_t * address = heap_listp + block[2]; ENSURES(address != NULL); ENSURES(in_heap(address)); if (address == heap_listp) return NULL; else return address; }
// GIVNE: a tree T whose left and right subtrees are legal trees // EFFECT: rotate T to the right side // RETURNS: the rotated tree tree* rotate_right(tree* T, bst B) { REQUIRES(T != NULL && T->left != NULL); REQUIRES(is_tree(T, B)); REQUIRES(is_tree(T, B)); tree* L = T->left; T->left = L->right; L->right = T; fix_height(T, B); fix_height(L, B); ENSURES(is_tree(L, B)); return L; }
void Texture::LoadSkyboxFromFile ( const std::string& texturePath ) { REQUIRES( !IsLoaded() ); REQUIRES( !texturePath.empty() ); m_filePath = texturePath; m_texels = stbi_load( m_filePath.c_str(), &m_width, &m_height, &m_channels, 0 ); LoadSkyboxToOpenGL(); PROMISES( IsLoaded() ); PROMISES( GetFilePath() == texturePath ); }
// GIVNE: a tree T whose left and right subtrees are legal trees // EFFECT: rotate T to the left size // RETURNS: the rotated tree tree* rotate_left(tree* T, bst B) { REQUIRES(T != NULL && T->right != NULL); REQUIRES(is_tree(T->left, B)); REQUIRES(is_tree(T->right, B)); tree* R = T->right; T->right = R->left; R->left = T; fix_height(T, B); fix_height(R, B); ENSURES(is_tree(R, B)); return R; }
void trans(int M, int N, int A[N][M], int B[M][N]){ int i, j, tmp; REQUIRES(M > 0); REQUIRES(N > 0); for (i = 0; i < N; i++){ for (j = 0; j < M; j++){ tmp = A[i][j]; B[j][i] = tmp; } } ENSURES(is_transpose(M, N, A, B)); }
void basicBlockingTrans(int M, int N, int A[N][M], int B[M][N]) { int i, j, k, l, tmp; REQUIRES(M > 0); REQUIRES(N > 0); for (i = 0; i < N; i += 8) { for (j = 0; j < M; j += 8) { for (k = i; k <= i + 3 && k < N; k++) { for (l = j; l <= j + 3 && l < M; l++) { tmp = A[k][l]; B[l][k] = tmp; } } for (k = i; k <= i + 3 && k < N; k++) { for (l = j + 4; l <= j + 7 && l < M; l++) { tmp = A[k][l]; B[l][k] = tmp; } } for (k = i + 4; k <= i + 7 && k < N; k++) { for (l = j; l <= j + 4 && l < M; l++) { tmp = A[k][l]; B[l][k] = tmp; } } for (k = i + 4; k <= i + 7 && k < N; k++) { for (l = j + 4; l <= j + 7 && l < M; l++) { tmp = A[k][l]; B[l][k] = tmp; } } } } ENSURES(is_transpose(M, N, A, B)); }