/**
* 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();
}
}
