static pn_event_type_t message_stream_handler(test_handler_t *th, pn_event_t *e) {
struct message_stream_context *ctx = (struct message_stream_context*)th->context;
switch (pn_event_type(e)) {
case PN_CONNECTION_BOUND:
pn_transport_set_max_frame(pn_event_transport(e), FRAME);
return PN_EVENT_NONE;
case PN_SESSION_INIT:
pn_session_set_incoming_capacity(pn_event_session(e), FRAME); /* Single frame incoming */
pn_session_set_outgoing_window(pn_event_session(e), 1); /* Single frame outgoing */
return PN_EVENT_NONE;
case PN_LINK_REMOTE_OPEN:
common_handler(th, e);
if (pn_link_is_receiver(pn_event_link(e))) {
pn_link_flow(pn_event_link(e), 1);
} else {
ctx->sender = pn_event_link(e);
}
return PN_EVENT_NONE;
case PN_LINK_FLOW: /* Start a delivery */
if (pn_link_is_sender(pn_event_link(e)) && !ctx->dlv) {
ctx->dlv = pn_delivery(pn_event_link(e), pn_dtag("x", 1));
}
return PN_LINK_FLOW;
case PN_CONNECTION_WAKE: { /* Send a chunk */
ssize_t remains = ctx->size - ctx->sent;
ssize_t n = (CHUNK < remains) ? CHUNK : remains;
TEST_CHECK(th->t, n == pn_link_send(ctx->sender, ctx->send_buf.start + ctx->sent, n));
ctx->sent += n;
if (ctx->sent == ctx->size) {
TEST_CHECK(th->t, pn_link_advance(ctx->sender));
}
return PN_CONNECTION_WAKE;
}
case PN_DELIVERY: { /* Receive a delivery - smaller than a chunk? */
pn_delivery_t *dlv = pn_event_delivery(e);
if (pn_delivery_readable(dlv)) {
ssize_t n = pn_delivery_pending(dlv);
rwbytes_ensure(&ctx->recv_buf, ctx->received + n);
TEST_ASSERT(n == pn_link_recv(pn_event_link(e), ctx->recv_buf.start + ctx->received, n));
ctx->received += n;
}
ctx->complete = !pn_delivery_partial(dlv);
return PN_DELIVERY;
}
default:
return common_handler(th, e);
}
}
/* close a connection when it is remote open */
static pn_event_type_t open_close_handler(test_handler_t *th, pn_event_t *e) {
switch (pn_event_type(e)) {
case PN_CONNECTION_REMOTE_OPEN:
pn_connection_close(pn_event_connection(e));
return PN_EVENT_NONE; /* common_handler will finish on TRANSPORT_CLOSED */
default:
return common_handler(th, e);
}
}
/* Return on connection open, close and return on wake */
static pn_event_type_t open_wake_handler(test_handler_t *th, pn_event_t *e) {
switch (pn_event_type(e)) {
case PN_CONNECTION_REMOTE_OPEN:
return pn_event_type(e);
case PN_CONNECTION_WAKE:
pn_connection_close(pn_event_connection(e));
return pn_event_type(e);
default:
return common_handler(th, e);
}
}
static pn_event_type_t ssl_client_handler(test_handler_t *h, pn_event_t *e) {
switch (pn_event_type(e)) {
case PN_CONNECTION_BOUND:
return ssl_handler(h, e);
case PN_CONNECTION_REMOTE_OPEN: {
pn_event_type_t et = ssl_handler(h, e);
pn_connection_close(pn_event_connection(e));
return et;
}
break;
default:
return common_handler(h, e);
}
}
/* Like common_handler but does not auto-close the listener after one accept,
and returns on LISTENER_CLOSE
*/
static pn_event_type_t listen_handler(test_handler_t *th, pn_event_t *e) {
switch (pn_event_type(e)) {
case PN_LISTENER_ACCEPT:
/* No automatic listener close/free for tests that accept multiple connections */
last_accepted = pn_connection();
pn_listener_accept2(pn_event_listener(e), last_accepted, NULL);
/* No automatic close */
return PN_EVENT_NONE;
case PN_LISTENER_CLOSE:
return PN_LISTENER_CLOSE;
default:
return common_handler(th, e);
}
}
uint32_t *isr_handler(uint32_t *regs)
{
#ifdef CONFIG_SUPPRESS_INTERRUPTS
up_ledon(LED_INIRQ);
PANIC(OSERR_ERREXCEPTION); /* Doesn't return */
return regs; /* To keep the compiler happy */
#else
uint32_t *ret;
/* Dispatch the interrupt */
up_ledon(LED_INIRQ);
ret = common_handler((int)regs[REG_IRQNO], regs);
up_ledoff(LED_INIRQ);
return ret;
#endif
}
uint32_t *irq_handler(uint32_t *regs)
{
#ifdef CONFIG_SUPPRESS_INTERRUPTS
up_ledon(LED_INIRQ);
PANIC(OSERR_ERREXCEPTION); /* Doesn't return */
return regs; /* To keep the compiler happy */
#else
uint32_t *ret;
int irq;
up_ledon(LED_INIRQ);
/* Get the IRQ number */
irq = (int)regs[REG_IRQNO];
/* Send an EOI (end of interrupt) signal to the PICs if this interrupt
* involved the slave.
*/
if (irq >= IRQ8)
{
/* Send reset signal to slave */
idt_outb(PIC_OCW2_EOI_NONSPEC, PIC2_OCW2);
}
/* Send reset signal to master */
idt_outb(PIC_OCW2_EOI_NONSPEC, PIC1_OCW2);
/* Dispatch the interrupt */
ret = common_handler(irq, regs);
up_ledoff(LED_INIRQ);
return ret;
#endif
}
void
PIT3_Handler(void)
{
common_handler(PIT_3);
}
void
PIT2_Handler(void)
{
common_handler(PIT_2);
}
void
PIT1_Handler(void)
{
common_handler(PIT_1);
}
void
PIT0_Handler(void)
{
common_handler(PIT_0);
}
