void StateRunning::keyPressed(ofKeyEventArgs & _args)
{
int key=_args.key;
keyHandle(true, key);
switch(key) {
case OF_KEY_DEL:
changeState(_manager, new StateEnd());
break;
}
}
// ------------------------------------------------------------------
// ciObjectFactory::get
//
// Get the ciObject corresponding to some oop. If the ciObject has
// already been created, it is returned. Otherwise, a new ciObject
// is created.
ciObject* ciObjectFactory::get(oop key) {
ASSERT_IN_VM;
assert(Universe::heap()->is_in_reserved(key), "must be");
NonPermObject* &bucket = find_non_perm(key);
if (bucket != NULL) {
return bucket->object();
}
// The ciObject does not yet exist. Create it and insert it
// into the cache.
Handle keyHandle(key);
ciObject* new_object = create_new_object(keyHandle());
assert(keyHandle() == new_object->get_oop(), "must be properly recorded");
init_ident_of(new_object);
assert(Universe::heap()->is_in_reserved(new_object->get_oop()), "must be");
// Not a perm-space object.
insert_non_perm(bucket, keyHandle(), new_object);
return new_object;
}
void Window::keyHandleWP()
{
keyHandle(0, 1);
if(wxyz[0] == 0) delete wv;
if(wxyz[0] == 1) {
GLWidget *idx = currentGlWidget;
for (int i = 0; i < NumRows; ++i) {
for (int k = 0; k < NumColumns; ++k) {
if(idx != glWidgets[i][k]) glWidgets[i][k]->hide();
}
}
mainLayout->addWidget(idx, 0, 0, 4, 4);
this->repaint();//1st draw
}
if(wxyz[0] == 2) {
currentGlWidget->play(true);
wxyz[0]--;
}
}
void Window::keyHandleWM()
{
wv = new QWebView(this);
keyHandle(0, -1);
if(wxyz[0] == -1) {
mainLayout->addWidget(wv, 0, 0, 4, 4);
wv->setUrl(QUrl("qrc:/docs.html"));
}
if(wxyz[0] < -1) close();//exit on escape!
if(wxyz[0] == 0) {
for (int i = 0; i < NumRows; ++i) {
for (int k = 0; k < NumColumns; ++k) {
mainLayout->addWidget(glWidgets[i][k], i, k);
glWidgets[i][k]->show();
}
}
currentGlWidget->play(false);
}
}
// Convert a Private Key object into an opaque key handle, using AES Key Wrap
// with the long-lived aPersistentKey mixed with aAppParam to convert aPrivKey.
// The key handle's format is version || saltLen || salt || wrappedPrivateKey
static UniqueSECItem
KeyHandleFromPrivateKey(const UniquePK11SlotInfo& aSlot,
const UniquePK11SymKey& aPersistentKey,
uint8_t* aAppParam, uint32_t aAppParamLen,
const UniqueSECKEYPrivateKey& aPrivKey,
const nsNSSShutDownPreventionLock&)
{
MOZ_ASSERT(aSlot);
MOZ_ASSERT(aPersistentKey);
MOZ_ASSERT(aAppParam);
MOZ_ASSERT(aPrivKey);
if (NS_WARN_IF(!aSlot || !aPersistentKey || !aPrivKey || !aAppParam)) {
return nullptr;
}
// Generate a random salt
uint8_t saltParam[kSaltByteLen];
SECStatus srv = PK11_GenerateRandomOnSlot(aSlot.get(), saltParam,
sizeof(saltParam));
if (NS_WARN_IF(srv != SECSuccess)) {
MOZ_LOG(gNSSTokenLog, LogLevel::Warning,
("Failed to generate a salt, NSS error #%d", PORT_GetError()));
return nullptr;
}
// Prepare the HKDF (https://tools.ietf.org/html/rfc5869)
CK_NSS_HKDFParams hkdfParams = { true, saltParam, sizeof(saltParam),
true, aAppParam, aAppParamLen };
SECItem kdfParams = { siBuffer, (unsigned char*)&hkdfParams,
sizeof(hkdfParams) };
// Derive a wrapping key from aPersistentKey, the salt, and the aAppParam.
// CKM_AES_KEY_GEN and CKA_WRAP are key type and usage attributes of the
// derived symmetric key and don't matter because we ignore them anyway.
UniquePK11SymKey wrapKey(PK11_Derive(aPersistentKey.get(), CKM_NSS_HKDF_SHA256,
&kdfParams, CKM_AES_KEY_GEN, CKA_WRAP,
kWrappingKeyByteLen));
if (NS_WARN_IF(!wrapKey.get())) {
MOZ_LOG(gNSSTokenLog, LogLevel::Warning,
("Failed to derive a wrapping key, NSS error #%d", PORT_GetError()));
return nullptr;
}
UniqueSECItem wrappedKey(::SECITEM_AllocItem(/* default arena */ nullptr,
/* no buffer */ nullptr,
kWrappedKeyBufLen));
if (NS_WARN_IF(!wrappedKey)) {
MOZ_LOG(gNSSTokenLog, LogLevel::Warning, ("Failed to allocate memory"));
return nullptr;
}
UniqueSECItem param(PK11_ParamFromIV(CKM_NSS_AES_KEY_WRAP_PAD,
/* default IV */ nullptr ));
srv = PK11_WrapPrivKey(aSlot.get(), wrapKey.get(), aPrivKey.get(),
CKM_NSS_AES_KEY_WRAP_PAD, param.get(), wrappedKey.get(),
/* wincx */ nullptr);
if (NS_WARN_IF(srv != SECSuccess)) {
MOZ_LOG(gNSSTokenLog, LogLevel::Warning,
("Failed to wrap U2F key, NSS error #%d", PORT_GetError()));
return nullptr;
}
// Concatenate the salt and the wrapped Private Key together
mozilla::dom::CryptoBuffer keyHandleBuf;
if (NS_WARN_IF(!keyHandleBuf.SetCapacity(wrappedKey.get()->len + sizeof(saltParam) + 2,
mozilla::fallible))) {
MOZ_LOG(gNSSTokenLog, LogLevel::Warning, ("Failed to allocate memory"));
return nullptr;
}
// It's OK to ignore the return values here because we're writing into
// pre-allocated space
keyHandleBuf.AppendElement(SoftTokenHandle::Version1, mozilla::fallible);
keyHandleBuf.AppendElement(sizeof(saltParam), mozilla::fallible);
keyHandleBuf.AppendElements(saltParam, sizeof(saltParam), mozilla::fallible);
keyHandleBuf.AppendSECItem(wrappedKey.get());
UniqueSECItem keyHandle(::SECITEM_AllocItem(nullptr, nullptr, 0));
if (NS_WARN_IF(!keyHandle)) {
MOZ_LOG(gNSSTokenLog, LogLevel::Warning, ("Failed to allocate memory"));
return nullptr;
}
if (NS_WARN_IF(!keyHandleBuf.ToSECItem(/* default arena */ nullptr, keyHandle.get()))) {
MOZ_LOG(gNSSTokenLog, LogLevel::Warning, ("Failed to allocate memory"));
return nullptr;
}
return keyHandle;
}
void StateRunning::keyReleased(ofKeyEventArgs & _args)
{
int key=_args.key;
keyHandle(false, key);
}
// ------------------------------------------------------------------
// ciObjectFactory::get
//
// Get the ciObject corresponding to some oop. If the ciObject has
// already been created, it is returned. Otherwise, a new ciObject
// is created.
ciObject* ciObjectFactory::get(oop key) {
ASSERT_IN_VM;
#ifdef ASSERT
if (CIObjectFactoryVerify) {
oop last = NULL;
for (int j = 0; j< _ci_objects->length(); j++) {
oop o = _ci_objects->at(j)->get_oop();
assert(last < o, "out of order");
last = o;
}
}
#endif // ASSERT
int len = _ci_objects->length();
int index = find(key, _ci_objects);
#ifdef ASSERT
if (CIObjectFactoryVerify) {
for (int i=0; i<_ci_objects->length(); i++) {
if (_ci_objects->at(i)->get_oop() == key) {
assert(index == i, " bad lookup");
}
}
}
#endif
if (!is_found_at(index, key, _ci_objects)) {
// Check in the non-perm area before putting it in the list.
NonPermObject* &bucket = find_non_perm(key);
if (bucket != NULL) {
return bucket->object();
}
// Check in the shared symbol area before putting it in the list.
if (key->is_symbol()) {
vmSymbols::SID sid = vmSymbols::find_sid((symbolOop)key);
if (sid != vmSymbols::NO_SID) {
// do not pollute the main cache with it
return vm_symbol_at(sid);
}
}
// The ciObject does not yet exist. Create it and insert it
// into the cache.
Handle keyHandle(key);
ciObject* new_object = create_new_object(keyHandle());
assert(keyHandle() == new_object->get_oop(), "must be properly recorded");
init_ident_of(new_object);
if (!new_object->is_perm()) {
// Not a perm-space object.
insert_non_perm(bucket, keyHandle(), new_object);
return new_object;
}
if (len != _ci_objects->length()) {
// creating the new object has recursively entered new objects
// into the table. We need to recompute our index.
index = find(keyHandle(), _ci_objects);
}
assert(!is_found_at(index, keyHandle(), _ci_objects), "no double insert");
insert(index, new_object, _ci_objects);
return new_object;
}
return _ci_objects->at(index);
}
void Window::keyHandleZP()
{
keyHandle(3, 1);
}
void Window::keyHandleZM()
{
keyHandle(3, -1);
}
void Window::keyHandleYP()
{
keyHandle(2, 1);
}
void Window::keyHandleYM()
{
keyHandle(2, -1);
}
void Window::keyHandleXP()
{
keyHandle(1, 256);//special for space/enter key pair
}
void Window::keyHandleXM()
{
keyHandle(1, 1);
}
int main( int argc, char **argv )
{
dlCamera *camera;
dlShader *shader;
dlObject *object;
/* FPS Counter */
unsigned int now = 0;
unsigned int last = 0;
unsigned int frameCounter = 0;
unsigned int FPS = 0;
unsigned int fpsDelay = 0;
float duration = 0;
float delta = 0;
char WIN_TITLE[LINE_MAX];
/* init debug channels */
dlDEBINIT(argc, argv);
if(SDL_Init( SDL_INIT_VIDEO ) != 0)
cleanup(EXIT_FAILURE);
if(dlCreateWindow( WINDOW_WIDTH, WINDOW_HEIGHT, WINDOW_BITS, WINDOW_FLAGS ) != 0)
cleanup(EXIT_FAILURE);
if(dlCreateDisplay( WINDOW_WIDTH, WINDOW_HEIGHT, DL_RENDER_OGL3 ) != 0)
cleanup(EXIT_FAILURE);
/* create camera */
camera = dlNewCamera();
if(!camera)
cleanup(EXIT_FAILURE);
/* create test plane */
object = dlNewPlane( 0.1, 0.1, 1 );
if(!object)
cleanup(EXIT_FAILURE);
/* create shader */
shader = dlNewShader( "shader/ogl3.shd" );
if(!shader)
cleanup(EXIT_FAILURE);
/* bind */
dlBindShader(shader);
/* startup graph */
dlMemoryGraph();
/* wait for escape key */
while(!dlKeyPress(SDLK_ESCAPE))
{
last = now;
now = SDL_GetTicks();
delta = (now - last) / 1000.0f;
/* sets this as active camera */
dlCameraRender( camera );
keyHandle();
dlDraw( object );
dlSwapBuffers();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
if(fpsDelay < SDL_GetTicks())
{
if(duration > 0.0f)
FPS = (float)frameCounter / duration;
sprintf(WIN_TITLE, "OpenGL [FPS: %d]", FPS);
SDL_WM_SetCaption( WIN_TITLE, NULL );
frameCounter = 0; fpsDelay = now + 1000; duration = 0;
}
++frameCounter;
duration += delta;
}
dlFreeCamera( camera );
dlFreeObject( object );
dlFreeShader( shader );
cleanup(EXIT_SUCCESS);
return(EXIT_SUCCESS);
}
