int
tr_peerIoReconnect( tr_peerIo * io )
{
short int pendingEvents;
tr_session * session;
assert( tr_isPeerIo( io ) );
assert( !tr_peerIoIsIncoming( io ) );
session = tr_peerIoGetSession( io );
pendingEvents = io->pendingEvents;
event_disable( io, EV_READ | EV_WRITE );
if( io->socket >= 0 )
tr_netClose( session, io->socket );
io->socket = tr_netOpenPeerSocket( session, &io->addr, io->port, io->isSeed );
event_set( &io->event_read, io->socket, EV_READ, event_read_cb, io );
event_set( &io->event_write, io->socket, EV_WRITE, event_write_cb, io );
if( io->socket >= 0 )
{
event_enable( io, pendingEvents );
tr_netSetTOS( io->socket, session->peerSocketTOS );
maybeSetCongestionAlgorithm( io->socket, session->peer_congestion_algorithm );
return 0;
}
return -1;
}
void test_architecture_event_interrupt_02(void)
{
TEST_ENTER();
event_release(ARCHITECTURE_IDT_SYSCALL_BASE + 0);
event_release(ARCHITECTURE_IDT_SYSCALL_BASE + 1);
event_release(ARCHITECTURE_IDT_SYSCALL_BASE + 2);
if (event_reserve(ARCHITECTURE_IDT_SYSCALL_BASE + 0,
EVENT_TYPE_FUNCTION,
EVENT_ROUTINE(test_architecture_event_interrupt_02_handler_56),
EVENT_DATA(NULL)) != STATUS_OK)
TEST_ERROR("[event_reserve] error");
if (event_reserve(ARCHITECTURE_IDT_SYSCALL_BASE + 1,
EVENT_TYPE_FUNCTION,
EVENT_ROUTINE(test_architecture_event_interrupt_02_handler_57),
EVENT_DATA(NULL)) != STATUS_OK)
TEST_ERROR("[event_reserve] error");
if (event_reserve(ARCHITECTURE_IDT_SYSCALL_BASE + 2,
EVENT_TYPE_FUNCTION,
EVENT_ROUTINE(test_architecture_event_interrupt_02_handler_58),
EVENT_DATA(NULL)) != STATUS_OK)
TEST_ERROR("[event_reserve] error");
if (event_enable() != STATUS_OK)
TEST_ERROR("[event_enable] error");
asm volatile("int $56");
asm volatile("int $57");
asm volatile("int $58");
if (event_disable() != STATUS_OK)
TEST_ERROR("[event_disable] error");
if (thrown != 3)
TEST_ERROR("some interrupt events have not been caught");
if (event_release(ARCHITECTURE_IDT_SYSCALL_BASE + 0) != STATUS_OK)
TEST_ERROR("[event_release] error");
if (event_release(ARCHITECTURE_IDT_SYSCALL_BASE + 1) != STATUS_OK)
TEST_ERROR("[event_release] error");
if (event_release(ARCHITECTURE_IDT_SYSCALL_BASE + 2) != STATUS_OK)
TEST_ERROR("[event_release] error");
TEST_SIGNATURE(cd09iwfjg9gerkg43hg);
TEST_LEAVE();
}
static int setup_child_event(struct event *event, pid_t child_pid)
{
event_init_named(event, 0x400FA, "PM_RUN_INST_CMPL");
event->attr.exclude_kernel = 1;
event->attr.exclude_hv = 1;
event->attr.exclude_idle = 1;
FAIL_IF(event_open_with_pid(event, child_pid));
FAIL_IF(event_enable(event));
return 0;
}
static int setup_cpu_event(struct event *event, int cpu)
{
event_init_named(event, 0x400FA, "PM_RUN_INST_CMPL");
event->attr.pinned = 1;
event->attr.exclude_kernel = 1;
event->attr.exclude_hv = 1;
event->attr.exclude_idle = 1;
SKIP_IF(require_paranoia_below(1));
FAIL_IF(event_open_with_cpu(event, cpu));
FAIL_IF(event_enable(event));
return 0;
}
void test_core_timer_repeat_01(void)
{
s_clock clock;
t_uint64 start;
i_timer tid;
if (timer_reserve(TIMER_TYPE_FUNCTION,
TIMER_ROUTINE(test_core_timer_repeat_01_handler),
TIMER_DATA(NULL),
1500,
TIMER_OPTION_REPEAT,
&tid) != STATUS_OK)
TEST_ERROR("[timer_reserve] error");
if (clock_current(&clock) != STATUS_OK)
TEST_ERROR("[clock_current] error");
start = CLOCK_UNIQUE(&clock);
if (event_enable() != STATUS_OK)
TEST_ERROR("[event_enable] error");
while (1)
{
t_uint64 current;
if (clock_current(&clock) != STATUS_OK)
TEST_ERROR("[clock_current] error");
current = CLOCK_UNIQUE(&clock);
if (current > (start + 3500))
break;
}
if (event_disable() != STATUS_OK)
TEST_ERROR("[event_disable] error");
if (timed != 2)
TEST_ERROR("the timer has not been triggered twice as expected but %u",
timed);
TEST_SIGNATURE(sdiocvjigi4h4h3);
TEST_LEAVE();
}
void
tr_peerIoSetEnabled( tr_peerIo * io,
tr_direction dir,
tr_bool isEnabled )
{
const short event = dir == TR_UP ? EV_WRITE : EV_READ;
assert( tr_isPeerIo( io ) );
assert( tr_isDirection( dir ) );
assert( tr_amInEventThread( io->session ) );
assert( io->session->events != NULL );
if( isEnabled )
event_enable( io, event );
else
event_disable( io, event );
}
int main(int argc, char* argv[])
{
setScrollField(6, 43);
printLine("================================================================================", 0, 0x0B);
printLine(" Editor", 2, 0x0B);
printLine("--------------------------------------------------------------------------------", 4, 0x0B);
iSetCursor(0, 6);
Editor editor;
if(argc > 1)
editor.open(argv[1]);
union {
KEY_t key;
char text;
} buffer;
event_enable(true);
EVENT_t ev = event_poll(&buffer, 2048, EVENT_NONE);
bool ctrl;
for (;;)
{
switch (ev)
{
case EVENT_NONE:
waitForEvent(0);
break;
case EVENT_TEXT_ENTERED:
if(!ctrl)
editor.textEnteredEvent(buffer.text);
break;
case EVENT_KEY_DOWN:
{
switch (buffer.key)
{
case KEY_LCTRL: case KEY_RCTRL:
ctrl = true;
break;
case KEY_ESC:
{
return (0);
}
case KEY_S:
{
if (ctrl)
editor.save();
else
editor.keyPressedEvent(buffer.key);
break;
}
case KEY_O:
{
if (ctrl)
{
// Open
}
else
editor.keyPressedEvent(buffer.key);
break;
}
default:
editor.keyPressedEvent(buffer.key);
break;
}
break;
}
case EVENT_KEY_UP:
switch (buffer.key)
{
case KEY_LCTRL: case KEY_RCTRL:
ctrl = false;
break;
default:
break;
}
break;
default:
break;
}
ev = event_poll(&buffer, 4096, EVENT_NONE);
}
return (0);
}
