/** * gnutls_session_key_update: * @session: is a #gnutls_session_t type. * @flags: zero of %GNUTLS_KU_PEER * * This function will update/refresh the session keys when the * TLS protocol is 1.3 or better. The peer is notified of the * update by sending a message, so this function should be * treated similarly to gnutls_record_send() --i.e., it may * return %GNUTLS_E_AGAIN or %GNUTLS_E_INTERRUPTED. * * When this flag %GNUTLS_KU_PEER is specified, this function * in addition to updating the local keys, will ask the peer to * refresh its keys too. * * If the negotiated version is not TLS 1.3 or better this * function will return %GNUTLS_E_INVALID_REQUEST. * * Returns: %GNUTLS_E_SUCCESS on success, otherwise a negative error code. * * Since: 3.6.3 **/ int gnutls_session_key_update(gnutls_session_t session, unsigned flags) { int ret; const version_entry_st *vers = get_version(session); if (!vers->tls13_sem) return GNUTLS_E_INVALID_REQUEST; ret = _gnutls13_send_key_update(session, AGAIN(STATE150), flags); STATE = STATE150; if (ret < 0) { gnutls_assert(); return ret; } STATE = STATE0; _gnutls_epoch_gc(session); /* it was completely sent, update the keys */ ret = update_keys(session, STAGE_UPD_OURS); if (ret < 0) return gnutls_assert_val(ret); return 0; }
int main(int argc, char const **argv) { glfwInit(); glfwOpenWindow(800, 600, 8, 8, 8, 8, 16, 0, GLFW_WINDOW); glfwSetWindowSizeCallback(set_window_size); glfwSetKeyCallback(set_key); init(); int running = 1; while(running) { update(); update_keys(); draw(); glfwSwapBuffers(); running = !glfwGetKey(GLFW_KEY_ESC) && glfwGetWindowParam(GLFW_OPENED); glfwSleep(0.01); } terminate(); glfwCloseWindow(); glfwTerminate(); return 0; }
void game_loop() { while (game_running) { // do things update_keys(); handle_input(); // draw things blank_screen(&renderer); draw_player(); SDL_RenderPresent(renderer); // keep things at a normal pace SDL_Delay(10); } }
void RpiKeyboard::update() { if (!active) return; int down; // Used to hold whether the key was moved to up or down int keycode; // Used to hold the keycode of the presed key unsigned char buf; // Characters are read one at a time to this buffer. while (read(fd, &buf, 1) >= 0) { down = !(buf & 0x80); // bit is 0 for down, 1 for up keycode = buf & 0x7F; // The rest is put into keycode update_keys(keycode, down); } }
int _gnutls13_recv_key_update(gnutls_session_t session, gnutls_buffer_st *buf) { int ret; time_t now = gnutls_time(0); if (buf->length != 1) return gnutls_assert_val(GNUTLS_E_UNEXPECTED_PACKET_LENGTH); if (unlikely(now - session->internals.last_key_update < KEY_UPDATES_PER_SEC)) { _gnutls_debug_log("reached maximum number of key updates per second (%d)\n", KEY_UPDATES_PER_SEC); return gnutls_assert_val(GNUTLS_E_TOO_MANY_HANDSHAKE_PACKETS); } session->internals.last_key_update = now; _gnutls_epoch_gc(session); _gnutls_handshake_log("HSK[%p]: received TLS 1.3 key update (%u)\n", session, (unsigned)buf->data[0]); switch(buf->data[0]) { case 0: /* peer updated its key, not requested our key update */ ret = update_keys(session, STAGE_UPD_PEERS); if (ret < 0) return gnutls_assert_val(ret); break; case 1: if (session->internals.hsk_flags & HSK_KEY_UPDATE_ASKED) { /* if we had asked a key update we shouldn't get this * reply */ return gnutls_assert_val(GNUTLS_E_ILLEGAL_PARAMETER); } /* peer updated its key, requested our key update */ ret = update_keys(session, STAGE_UPD_PEERS); if (ret < 0) return gnutls_assert_val(ret); /* we mark that a key update is schedule, and it * will be performed prior to sending the next application * message. */ if (session->internals.rsend_state == RECORD_SEND_NORMAL) session->internals.rsend_state = RECORD_SEND_KEY_UPDATE_1; else if (session->internals.rsend_state == RECORD_SEND_CORKED) session->internals.rsend_state = RECORD_SEND_CORKED_TO_KU; else return gnutls_assert_val(GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER); break; default: return gnutls_assert_val(GNUTLS_E_RECEIVED_ILLEGAL_PARAMETER); } session->internals.hsk_flags &= ~(unsigned)(HSK_KEY_UPDATE_ASKED); return 0; }
/* ======================================================================== This routine processes CPU interrupts. ======================================================================== */ void check_interrupts(void) { static volatile UINT64 last_rst75=0; if (((last_rst75 + rst7cycles) < cycles) && !INTDIS) { IM |= 0x40; // if(trace && tracefile != NULL) // fprintf(tracefile,"RST 7.5 Issued diff = %d\n", (DWORD) (cycles - last_rst75)); last_rst75=cycles; } /* TRAP should be first */ if(RST75PEND && !INTDIS && !RST75MASK) { if(trace && tracefile != NULL) fprintf(tracefile,"RST 7.5 CALLed\n"); if (gDebugInts) gIntActive = TRUE; gIntSP = SP; DECSP2; if (gReMem) { MEMSET(SP, PCL); MEMSET(SP+1, PCH); } else { gBaseMemory[SP] = PCL; gBaseMemory[SP+1] = PCH; } /* MEM16(SP)=PC; */ PCL=60; PCH=0; /* PC=60; */ cycle_delta += 10; /* This may not be correct */ IM=IM&0xBF; last_isr_cycle = cycles; if (gDelayUpdateKeys == 1) update_keys(); } else if(RST65PEND && !INTDIS && !RST65MASK) { if(trace && tracefile != NULL) fprintf(tracefile,"RST 6.5 CALLed\n"); if (gDebugInts) gIntActive = TRUE; gIntSP = SP; DECSP2; if (gReMem) { MEMSET(SP, PCL); MEMSET(SP+1, PCH); } else { gBaseMemory[SP] = PCL; gBaseMemory[SP+1] = PCH; } /* MEM16(SP)=PC; */ PCL=52; PCH=0; /* PC=52; */ cycle_delta += 10; /* This may not be correct */ // IM=IM&0xDF; last_isr_cycle = cycles; } return; }
// Draws one frame then returns void run_one_frame() { frame_drawn = 0; while (!frame_drawn) { if (halted || stopped) { long current_cycles = cgb_speed ? 2 : 4; update_timers(current_cycles); sound_add_cycles(current_cycles); inc_serial_cycles(current_cycles); // If Key pressed in "stop" mode, then gameboy is "unstopped" if (stopped) { if(key_pressed()) { stopped = 0; } } if (halted) { update_graphics(current_cycles); } } else if (!(halted || stopped)) { current_cycles = 0; current_cycles += exec_opcode(skip_bug); } cycles += current_cycles; #ifdef EFIAPI if (cycles > 3000) { #else if (cycles > 15000) { #endif quit |= update_keys(); cycles = 0; } skip_bug = handle_interrupts(); if (debug && step_count > 0 && --step_count == 0) { int flags = get_command(); step_count = (flags & STEPS_SET) ? get_steps() : STEPS_OFF; } } } void setup_debug() { if (debug) { int flags = get_command(); step_count = (flags & STEPS_SET) ? get_steps() : STEPS_OFF; breakpoint = (flags & BREAKPOINT_SET) ? get_breakpoint() : BREAKPOINT_OFF; } } void run() { log_message(LOG_INFO, "About to setup debug\n"); setup_debug(); log_message(LOG_INFO, "About to run\n"); while(!quit) { run_one_frame(); } }