static cell AMX_NATIVE_CALL ns_get_hive_ability(AMX *amx, cell *params) { CreatePlayerPointer(amx,params[1]); int result = get_private(player->GetEdict(), MAKE_OFFSET(HIVEABILITY)); return (params[2] > 0) ? (result >= params[2] - 1) : result; }
int MemPool_FixedArea::get_mem_size(MemPool_Handle p_handle) { ERR_FAIL_COND_V( !is_mem_valid(p_handle),-1 ); MemChunk *chunk=(MemChunk*)get_private( p_handle ); return chunk->len; }
static cell AMX_NATIVE_CALL ns_get_deaths(AMX *amx, cell *params) { CreatePlayerPointer(amx,params[1]); if (!player->IsConnected() || !player->HasPrivateData()) { return 0; } return get_private(player->GetEdict(),MAKE_OFFSET(DEATHS)); }
void MemPool_FixedArea::unlock_mem(MemPool_Handle p_handle) { ERR_FAIL_COND( !is_mem_valid( p_handle ) ); MemChunk *chunk=(MemChunk*)get_private( p_handle ); ERR_FAIL_COND( chunk->lock==0 ); chunk->lock--; }
// ns_get_weap_ammo(WeaponID) static cell AMX_NATIVE_CALL ns_get_weapon_clip(AMX *amx, cell *params) { CreateNonPlayerEdict(amx,params[1]); if (Entity->pvPrivateData == NULL || Entity->free) { return 0; } return get_private(Entity,MAKE_OFFSET(WEAPCLIP)); }
bool MemPool_FixedArea::lock_mem(MemPool_Handle p_handle) { ERR_FAIL_COND_V( !is_mem_valid( p_handle ), true ); MemChunk *chunk=(MemChunk*)get_private( p_handle ); chunk->lock++; return false; }
void *MemPool_FixedArea::get_mem(MemPool_Handle p_handle) { ERR_FAIL_COND_V( !is_mem_valid( p_handle ), NULL ); MemChunk *chunk=(MemChunk*)get_private( p_handle ); ERR_FAIL_COND_V( chunk->lock==0, NULL ); return &((unsigned char*)mem_area)[ chunk->pos ]; }
// ns_get_weap_reserve(PlayerID,WeaponType) static cell AMX_NATIVE_CALL ns_get_weap_reserve(AMX *amx, cell *params) { CreatePlayerPointer(amx,params[1]); if (!player->IsConnected()) { return 0; } if (!player->HasPrivateData()) { return 0; } switch (params[2]) { case WEAPON_PISTOL: return get_private(player->GetEdict(),MAKE_OFFSET(AMMO_PISTOL)); case WEAPON_LMG: return get_private(player->GetEdict(),MAKE_OFFSET(AMMO_LMG)); case WEAPON_SHOTGUN: return get_private(player->GetEdict(),MAKE_OFFSET(AMMO_SHOTGUN)); case WEAPON_HMG: return get_private(player->GetEdict(),MAKE_OFFSET(AMMO_HMG)); case WEAPON_GRENADE_GUN: return get_private(player->GetEdict(),MAKE_OFFSET(AMMO_GL)); case WEAPON_GRENADE: return get_private(player->GetEdict(),MAKE_OFFSET(AMMO_HG)); default: return 0; } return 0; }
DRI_DRM_STATIC int PVRSRVDrmRelease(struct drm_device *dev, struct drm_file *file) { void *psDriverPriv = get_private(file); PVR_TRACE(("PVRSRVDrmRelease: psDriverPriv=%p", psDriverPriv)); if (psDriverPriv) { PVRSRVRelease(psDriverPriv); } set_private(file, IMG_NULL); return 0; }
// ns_get_points(Player) static cell AMX_NATIVE_CALL ns_get_points(AMX *amx, cell *params) { if (!GameMan.IsCombat()) { return 0; } CreatePlayerPointer(amx,params[1]); if (!player->IsConnected()) { return 0; } if (!player->HasPrivateData()) { return 0; } return get_private(player->GetEdict(),MAKE_OFFSET(POINTS)); }
void MemPool_FixedArea::free_mem(MemPool_Handle p_handle) { ERR_FAIL_COND( !is_mem_valid(p_handle) ); MemChunk *chunk=(MemChunk*)get_private( p_handle ); ERR_FAIL_COND(chunk->lock); //it's locked ChunkMapPos chunk_map_pos; ERR_FAIL_COND( find_chunk_map(&chunk_map_pos,chunk) ); for (int i=chunk_map_pos;i<(chunks_allocated-1);i++) { chunk_map[ i ] = chunk_map[ i+1 ]; } chunks_allocated--; chunk->clear(); }
bool MemPool_FixedArea::is_mem_valid(MemPool_Handle p_handle) { if (p_handle.is_null()) return false; MemChunk *chunk=(MemChunk*)get_private( p_handle ); /* If not in range of the pool, it's not valid pointer inside */ if (chunk<&mem_chunks[0] || chunk>&mem_chunks[MAX_CHUNKS-1]) return false; /* Mem has been freed */ if (chunk->len==0) return false; /* Check if the item "check" integer is the same */ if (chunk->check!=get_check( p_handle )) return false; return true; }
DRI_DRM_STATIC int PVRSRVDrmRelease(struct inode *inode, struct file *filp) { struct drm_file *file_priv = filp->private_data; void *psDriverPriv = get_private(file_priv); int ret; ret = drm_release(inode, filp); if (ret != 0) { /* * An error means drm_release didn't call drm_lastclose, * but it will have freed file_priv. */ PVR_DPF((PVR_DBG_ERROR, "%s : drm_release failed: %d", __FUNCTION__, ret)); } PVRSRVRelease(psDriverPriv); return 0; }
bool MemPool_FixedArea::realloc_mem(MemPool_Handle p_handle,Uint32 p_new_amount) { ERR_FAIL_COND_V( !is_mem_valid(p_handle),true ); MemChunk *chunk=(MemChunk*)get_private( p_handle ); ERR_FAIL_COND_V(chunk->lock,true); //it's locked ChunkMapPos chunk_map_pos; ERR_FAIL_COND_V( find_chunk_map(&chunk_map_pos,chunk), true ); Uint32 new_len_request=p_new_amount; { /* Try strategies that can resize without touching other blocks first */ Uint32 next_chunk_begin_pos=(chunk_map_pos==(chunks_allocated-1))?mem_area_size:mem_chunks[ chunk_map[ chunk_map_pos+1 ] ].pos; /* FIRST let's try to see if we can resize without moving any data */ if ( (chunk->pos+new_len_request)<=next_chunk_begin_pos ) { chunk->len=new_len_request; return false; //nothing much was needed to do! } Uint32 prev_chunk_end_pos=(chunk_map_pos==0)?0:mem_chunks[ chunk_map[ chunk_map_pos-1 ] ].end(); //alloc either at begining or /* SECOND, If we can resize withouth moving the other blocks, try it */ if ( (next_chunk_begin_pos-prev_chunk_end_pos)>=new_len_request ) { COMPACT_CHUNK(*chunk,prev_chunk_end_pos); return false; } } /* If nothing worked, try to move it to the end */ Uint32 last_block_end_pos=mem_chunks[ chunk_map[ chunks_allocated-1 ] ].end(); /* Can move to the end? */ if ( (mem_area_size-last_block_end_pos)<new_len_request ) { /* No, can't move, try compacting */ compact(); //need to compute this again last_block_end_pos=mem_chunks[ chunk_map[ chunks_allocated-1 ] ].end(); ERR_FAIL_COND_V( (mem_area_size-last_block_end_pos)<new_len_request, true ); } /* Move it */ COMPACT_CHUNK(*chunk,last_block_end_pos); /* update map */ ChunkMemPos chunk_mem_pos=chunk_map[ chunk_map_pos ]; for (Uint32 i=chunk_map_pos;i<(chunks_allocated-1);i++) { chunk_map[ i ] = chunk_map [ i+1 ]; } chunk_map[chunks_allocated-1]=chunk_mem_pos; chunk->len=new_len_request; return false; }
// ns_get_weapon(idPlayer,weaponid,&weapontype=0) static cell AMX_NATIVE_CALL ns_get_weapon(AMX *amx, cell *params) { // Peachy did it like this: // if weapontype is 0, return the primary weapon index of the player // if weapontype is < 0, return the last inventory weapon index of the player // otherwise, scan the player's inventory and look for a weapon of the given type // such as WEAPON_KNIFE, etc, etc // I added the last parameter, which will byref the weapontype of the weapon found // returns 0 on failure // last param default value added to not conflict with his version CreatePlayerPointer(amx,params[1]); if (!player->IsConnected()) { return 0; } if (!player->HasPrivateData()) { return 0; } if (params[2]<0) // find lastinv weapon { edict_t *Weapon=private_to_edict(get_private_p<void *>(player->GetEdict(),MAKE_OFFSET(LAST_WEAPON))); if (Weapon==NULL) // no weapon { return 0; } if ((params[0] / sizeof(cell))>2) // If this plugin was compiled with peachy's .inc then don't byref { *MF_GetAmxAddr_NEW(amx,params[3])=get_private(Weapon,MAKE_OFFSET(WEAPID)); } return ENTINDEX_NEW(Weapon); } if (params[2]==0) // find current weapon { edict_t *Weapon=private_to_edict(get_private_p<void *>(player->GetEdict(),MAKE_OFFSET(CURRENT_WEAPON))); if (Weapon==NULL) // no weapon { return 0; } if ((params[0] / sizeof(cell))>2) // If this plugin was compiled with peachy's .inc then don't byref { *MF_GetAmxAddr_NEW(amx,params[3])=get_private(Weapon,MAKE_OFFSET(WEAPID)); } return ENTINDEX_NEW(Weapon); } // Finding weapon by ID char **pPlayerItems = reinterpret_cast<char**>(static_cast<char*>(player->GetEdict()->pvPrivateData) + MAKE_OFFSET(PLAYER_ITEMS)); char *pItem; int weapon=params[2]; for (int i = 0; i < 6; i++) { pItem = pPlayerItems[i]; while (pItem) { if (*(int *)(pItem + MAKE_OFFSET(WEAPID)) == weapon) { return ENTINDEX_NEW(private_to_edict(pItem)); } else { pItem = *(char **)(pItem + MAKE_OFFSET(WEAP_NEXT)); } } } return 0; }
void sshkey_tests(void) { struct sshkey *k1, *k2, *k3, *k4, *kr, *kd, *kf; #ifdef OPENSSL_HAS_ECC struct sshkey *ke; #endif struct sshbuf *b; TEST_START("new invalid"); k1 = sshkey_new(-42); ASSERT_PTR_EQ(k1, NULL); TEST_DONE(); TEST_START("new/free KEY_UNSPEC"); k1 = sshkey_new(KEY_UNSPEC); ASSERT_PTR_NE(k1, NULL); sshkey_free(k1); TEST_DONE(); TEST_START("new/free KEY_RSA1"); k1 = sshkey_new(KEY_RSA1); ASSERT_PTR_NE(k1, NULL); ASSERT_PTR_NE(k1->rsa, NULL); ASSERT_PTR_NE(k1->rsa->n, NULL); ASSERT_PTR_NE(k1->rsa->e, NULL); ASSERT_PTR_EQ(k1->rsa->p, NULL); sshkey_free(k1); TEST_DONE(); TEST_START("new/free KEY_RSA"); k1 = sshkey_new(KEY_RSA); ASSERT_PTR_NE(k1, NULL); ASSERT_PTR_NE(k1->rsa, NULL); ASSERT_PTR_NE(k1->rsa->n, NULL); ASSERT_PTR_NE(k1->rsa->e, NULL); ASSERT_PTR_EQ(k1->rsa->p, NULL); sshkey_free(k1); TEST_DONE(); TEST_START("new/free KEY_DSA"); k1 = sshkey_new(KEY_DSA); ASSERT_PTR_NE(k1, NULL); ASSERT_PTR_NE(k1->dsa, NULL); ASSERT_PTR_NE(k1->dsa->g, NULL); ASSERT_PTR_EQ(k1->dsa->priv_key, NULL); sshkey_free(k1); TEST_DONE(); #ifdef OPENSSL_HAS_ECC TEST_START("new/free KEY_ECDSA"); k1 = sshkey_new(KEY_ECDSA); ASSERT_PTR_NE(k1, NULL); ASSERT_PTR_EQ(k1->ecdsa, NULL); /* Can't allocate without NID */ sshkey_free(k1); TEST_DONE(); #endif TEST_START("new/free KEY_ED25519"); k1 = sshkey_new(KEY_ED25519); ASSERT_PTR_NE(k1, NULL); /* These should be blank until key loaded or generated */ ASSERT_PTR_EQ(k1->ed25519_sk, NULL); ASSERT_PTR_EQ(k1->ed25519_pk, NULL); sshkey_free(k1); TEST_DONE(); TEST_START("new_private KEY_RSA"); k1 = sshkey_new_private(KEY_RSA); ASSERT_PTR_NE(k1, NULL); ASSERT_PTR_NE(k1->rsa, NULL); ASSERT_PTR_NE(k1->rsa->n, NULL); ASSERT_PTR_NE(k1->rsa->e, NULL); ASSERT_PTR_NE(k1->rsa->p, NULL); ASSERT_INT_EQ(sshkey_add_private(k1), 0); sshkey_free(k1); TEST_DONE(); TEST_START("new_private KEY_DSA"); k1 = sshkey_new_private(KEY_DSA); ASSERT_PTR_NE(k1, NULL); ASSERT_PTR_NE(k1->dsa, NULL); ASSERT_PTR_NE(k1->dsa->g, NULL); ASSERT_PTR_NE(k1->dsa->priv_key, NULL); ASSERT_INT_EQ(sshkey_add_private(k1), 0); sshkey_free(k1); TEST_DONE(); TEST_START("generate KEY_RSA too small modulus"); ASSERT_INT_EQ(sshkey_generate(KEY_RSA, 128, &k1), SSH_ERR_INVALID_ARGUMENT); ASSERT_PTR_EQ(k1, NULL); TEST_DONE(); TEST_START("generate KEY_RSA too large modulus"); ASSERT_INT_EQ(sshkey_generate(KEY_RSA, 1 << 20, &k1), SSH_ERR_INVALID_ARGUMENT); ASSERT_PTR_EQ(k1, NULL); TEST_DONE(); TEST_START("generate KEY_DSA wrong bits"); ASSERT_INT_EQ(sshkey_generate(KEY_DSA, 2048, &k1), SSH_ERR_INVALID_ARGUMENT); ASSERT_PTR_EQ(k1, NULL); sshkey_free(k1); TEST_DONE(); #ifdef OPENSSL_HAS_ECC TEST_START("generate KEY_ECDSA wrong bits"); ASSERT_INT_EQ(sshkey_generate(KEY_ECDSA, 42, &k1), SSH_ERR_INVALID_ARGUMENT); ASSERT_PTR_EQ(k1, NULL); sshkey_free(k1); TEST_DONE(); #endif TEST_START("generate KEY_RSA"); ASSERT_INT_EQ(sshkey_generate(KEY_RSA, 767, &kr), SSH_ERR_INVALID_ARGUMENT); ASSERT_INT_EQ(sshkey_generate(KEY_RSA, 1024, &kr), 0); ASSERT_PTR_NE(kr, NULL); ASSERT_PTR_NE(kr->rsa, NULL); ASSERT_PTR_NE(kr->rsa->n, NULL); ASSERT_PTR_NE(kr->rsa->e, NULL); ASSERT_PTR_NE(kr->rsa->p, NULL); ASSERT_INT_EQ(BN_num_bits(kr->rsa->n), 1024); TEST_DONE(); TEST_START("generate KEY_DSA"); ASSERT_INT_EQ(sshkey_generate(KEY_DSA, 1024, &kd), 0); ASSERT_PTR_NE(kd, NULL); ASSERT_PTR_NE(kd->dsa, NULL); ASSERT_PTR_NE(kd->dsa->g, NULL); ASSERT_PTR_NE(kd->dsa->priv_key, NULL); TEST_DONE(); #ifdef OPENSSL_HAS_ECC TEST_START("generate KEY_ECDSA"); ASSERT_INT_EQ(sshkey_generate(KEY_ECDSA, 256, &ke), 0); ASSERT_PTR_NE(ke, NULL); ASSERT_PTR_NE(ke->ecdsa, NULL); ASSERT_PTR_NE(EC_KEY_get0_public_key(ke->ecdsa), NULL); ASSERT_PTR_NE(EC_KEY_get0_private_key(ke->ecdsa), NULL); TEST_DONE(); #endif TEST_START("generate KEY_ED25519"); ASSERT_INT_EQ(sshkey_generate(KEY_ED25519, 256, &kf), 0); ASSERT_PTR_NE(kf, NULL); ASSERT_INT_EQ(kf->type, KEY_ED25519); ASSERT_PTR_NE(kf->ed25519_pk, NULL); ASSERT_PTR_NE(kf->ed25519_sk, NULL); TEST_DONE(); TEST_START("demote KEY_RSA"); ASSERT_INT_EQ(sshkey_demote(kr, &k1), 0); ASSERT_PTR_NE(k1, NULL); ASSERT_PTR_NE(kr, k1); ASSERT_INT_EQ(k1->type, KEY_RSA); ASSERT_PTR_NE(k1->rsa, NULL); ASSERT_PTR_NE(k1->rsa->n, NULL); ASSERT_PTR_NE(k1->rsa->e, NULL); ASSERT_PTR_EQ(k1->rsa->p, NULL); TEST_DONE(); TEST_START("equal KEY_RSA/demoted KEY_RSA"); ASSERT_INT_EQ(sshkey_equal(kr, k1), 1); sshkey_free(k1); TEST_DONE(); TEST_START("demote KEY_DSA"); ASSERT_INT_EQ(sshkey_demote(kd, &k1), 0); ASSERT_PTR_NE(k1, NULL); ASSERT_PTR_NE(kd, k1); ASSERT_INT_EQ(k1->type, KEY_DSA); ASSERT_PTR_NE(k1->dsa, NULL); ASSERT_PTR_NE(k1->dsa->g, NULL); ASSERT_PTR_EQ(k1->dsa->priv_key, NULL); TEST_DONE(); TEST_START("equal KEY_DSA/demoted KEY_DSA"); ASSERT_INT_EQ(sshkey_equal(kd, k1), 1); sshkey_free(k1); TEST_DONE(); #ifdef OPENSSL_HAS_ECC TEST_START("demote KEY_ECDSA"); ASSERT_INT_EQ(sshkey_demote(ke, &k1), 0); ASSERT_PTR_NE(k1, NULL); ASSERT_PTR_NE(ke, k1); ASSERT_INT_EQ(k1->type, KEY_ECDSA); ASSERT_PTR_NE(k1->ecdsa, NULL); ASSERT_INT_EQ(k1->ecdsa_nid, ke->ecdsa_nid); ASSERT_PTR_NE(EC_KEY_get0_public_key(ke->ecdsa), NULL); ASSERT_PTR_EQ(EC_KEY_get0_private_key(k1->ecdsa), NULL); TEST_DONE(); TEST_START("equal KEY_ECDSA/demoted KEY_ECDSA"); ASSERT_INT_EQ(sshkey_equal(ke, k1), 1); sshkey_free(k1); TEST_DONE(); #endif TEST_START("demote KEY_ED25519"); ASSERT_INT_EQ(sshkey_demote(kf, &k1), 0); ASSERT_PTR_NE(k1, NULL); ASSERT_PTR_NE(kf, k1); ASSERT_INT_EQ(k1->type, KEY_ED25519); ASSERT_PTR_NE(k1->ed25519_pk, NULL); ASSERT_PTR_EQ(k1->ed25519_sk, NULL); TEST_DONE(); TEST_START("equal KEY_ED25519/demoted KEY_ED25519"); ASSERT_INT_EQ(sshkey_equal(kf, k1), 1); sshkey_free(k1); TEST_DONE(); TEST_START("equal mismatched key types"); ASSERT_INT_EQ(sshkey_equal(kd, kr), 0); #ifdef OPENSSL_HAS_ECC ASSERT_INT_EQ(sshkey_equal(kd, ke), 0); ASSERT_INT_EQ(sshkey_equal(kr, ke), 0); ASSERT_INT_EQ(sshkey_equal(ke, kf), 0); #endif ASSERT_INT_EQ(sshkey_equal(kd, kf), 0); TEST_DONE(); TEST_START("equal different keys"); ASSERT_INT_EQ(sshkey_generate(KEY_RSA, 1024, &k1), 0); ASSERT_INT_EQ(sshkey_equal(kr, k1), 0); sshkey_free(k1); ASSERT_INT_EQ(sshkey_generate(KEY_DSA, 1024, &k1), 0); ASSERT_INT_EQ(sshkey_equal(kd, k1), 0); sshkey_free(k1); #ifdef OPENSSL_HAS_ECC ASSERT_INT_EQ(sshkey_generate(KEY_ECDSA, 256, &k1), 0); ASSERT_INT_EQ(sshkey_equal(ke, k1), 0); sshkey_free(k1); #endif ASSERT_INT_EQ(sshkey_generate(KEY_ED25519, 256, &k1), 0); ASSERT_INT_EQ(sshkey_equal(kf, k1), 0); sshkey_free(k1); TEST_DONE(); sshkey_free(kr); sshkey_free(kd); #ifdef OPENSSL_HAS_ECC sshkey_free(ke); #endif sshkey_free(kf); TEST_START("certify key"); ASSERT_INT_EQ(sshkey_load_public(test_data_file("ed25519_1.pub"), &k1, NULL), 0); k2 = get_private("ed25519_2"); ASSERT_INT_EQ(sshkey_to_certified(k1), 0); ASSERT_PTR_NE(k1->cert, NULL); k1->cert->type = SSH2_CERT_TYPE_USER; k1->cert->serial = 1234; k1->cert->key_id = strdup("estragon"); ASSERT_PTR_NE(k1->cert->key_id, NULL); k1->cert->principals = calloc(4, sizeof(*k1->cert->principals)); ASSERT_PTR_NE(k1->cert->principals, NULL); k1->cert->principals[0] = strdup("estragon"); k1->cert->principals[1] = strdup("vladimir"); k1->cert->principals[2] = strdup("pozzo"); k1->cert->principals[3] = strdup("lucky"); ASSERT_PTR_NE(k1->cert->principals[0], NULL); ASSERT_PTR_NE(k1->cert->principals[1], NULL); ASSERT_PTR_NE(k1->cert->principals[2], NULL); ASSERT_PTR_NE(k1->cert->principals[3], NULL); k1->cert->valid_after = 0; k1->cert->valid_before = (u_int64_t)-1; k1->cert->critical = sshbuf_new(); ASSERT_PTR_NE(k1->cert->critical, NULL); k1->cert->extensions = sshbuf_new(); ASSERT_PTR_NE(k1->cert->extensions, NULL); put_opt(k1->cert->critical, "force-command", "/usr/bin/true"); put_opt(k1->cert->critical, "source-address", "127.0.0.1"); put_opt(k1->cert->extensions, "permit-X11-forwarding", NULL); put_opt(k1->cert->extensions, "permit-agent-forwarding", NULL); ASSERT_INT_EQ(sshkey_from_private(k2, &k1->cert->signature_key), 0); ASSERT_INT_EQ(sshkey_certify(k1, k2), 0); b = sshbuf_new(); ASSERT_PTR_NE(b, NULL); ASSERT_INT_EQ(sshkey_putb(k1, b), 0); ASSERT_INT_EQ(sshkey_from_blob(sshbuf_ptr(b), sshbuf_len(b), &k3), 0); sshkey_free(k1); sshkey_free(k2); sshkey_free(k3); sshbuf_reset(b); TEST_DONE(); TEST_START("sign and verify RSA"); k1 = get_private("rsa_1"); ASSERT_INT_EQ(sshkey_load_public(test_data_file("rsa_2.pub"), &k2, NULL), 0); signature_tests(k1, k2); sshkey_free(k1); sshkey_free(k2); TEST_DONE(); TEST_START("sign and verify DSA"); k1 = get_private("dsa_1"); ASSERT_INT_EQ(sshkey_load_public(test_data_file("dsa_2.pub"), &k2, NULL), 0); signature_tests(k1, k2); sshkey_free(k1); sshkey_free(k2); TEST_DONE(); #ifdef OPENSSL_HAS_ECC #ifndef WIN32_FIXME TEST_START("sign and verify ECDSA"); k1 = get_private("ecdsa_1"); ASSERT_INT_EQ(sshkey_load_public(test_data_file("ecdsa_2.pub"), &k2, NULL), 0); signature_tests(k1, k2); sshkey_free(k1); sshkey_free(k2); TEST_DONE(); #endif #endif TEST_START("sign and verify ED25519"); k1 = get_private("ed25519_1"); ASSERT_INT_EQ(sshkey_load_public(test_data_file("ed25519_2.pub"), &k2, NULL), 0); signature_tests(k1, k2); sshkey_free(k1); sshkey_free(k2); TEST_DONE(); TEST_START("nested certificate"); ASSERT_INT_EQ(sshkey_load_cert(test_data_file("rsa_1"), &k1), 0); ASSERT_INT_EQ(sshkey_load_public(test_data_file("rsa_1.pub"), &k2, NULL), 0); k3 = get_private("rsa_1"); build_cert(b, k2, "*****@*****.**", k3, k1); ASSERT_INT_EQ(sshkey_from_blob(sshbuf_ptr(b), sshbuf_len(b), &k4), SSH_ERR_KEY_CERT_INVALID_SIGN_KEY); ASSERT_PTR_EQ(k4, NULL); sshkey_free(k1); sshkey_free(k2); sshkey_free(k3); sshbuf_free(b); TEST_DONE(); }
DRI_DRM_STATIC void PVRSRVDrmPostClose(struct drm_device *dev, struct drm_file *file) { PVRSRVRelease(get_private(file)); set_private(file, IMG_NULL); }