void readcb(struct bufferevent *bev, void *ptr)
{
struct conn_state *st = ptr;
if (st->state == WAIT_HELLO) {
handle_hello(st);
}
if (st->state == WAIT_CERT) {
handle_cert(st);
}
if (st->state == WAIT_KEYX) {
handle_keyx(st);
}
}
int
server_logic(client_t *c, proto_msg_t *msg)
{
TRACE_MSG(msg);
switch (proto_msg_type(msg)) {
case MSG_HELLO:
return (handle_hello(c, msg));
case MSG_OP:
return (handle_op(c, msg));
case MSG_TEXT:
return (handle_text(c, msg));
case MSG_NUM:
return (handle_num(c, msg));
default:
return (send_text_message(c, "thank you!"));
}
}
void pim_interface::data_available(const sockaddr_in6 *src, const sockaddr_in6 *dst) {
pim_message *pimmsg = g_mrd->ipktb->header<pim_message>();
int len = g_mrd->ipktb->rlength;
m_stats.counter(AllCount, RX)++;
if (pimmsg->type() != pim_msg_register && should_log(MESSAGE_SIG)) {
log().xprintf("%s message from %{addr} to %{addr} len %u\n",
pimmsg->type_name(), src->sin6_addr,
dst->sin6_addr, (uint32_t)len);
}
if (pimmsg->type() == pim_msg_register)
len = sizeof(pim_register_message);
if (!(pimmsg->has_valid_checksum(src->sin6_addr, dst->sin6_addr, len)
|| (pimmsg->type() == pim_msg_register &&
pimmsg->has_valid_checksum(src->sin6_addr, dst->sin6_addr, g_mrd->ipktb->rlength)))) {
m_stats.counter(AllCount, Bad)++;
if (should_log(MESSAGE_ERR)) {
log().xprintf("Dropping message from %{addr} to %{addr}"
" len %u: Bad Checksum\n", src->sin6_addr,
dst->sin6_addr, (uint32_t)g_mrd->ipktb->rlength);
}
return;
}
if (dst->sin6_addr == pim_all_routers) {
if ((int)src->sin6_scope_id != owner()->index()) {
if (should_log(MESSAGE_ERR)) {
log().xprintf("Dropping message from %{addr} to %{addr}"
" len %u: Wrong interface\n", src->sin6_addr,
dst->sin6_addr, (uint32_t)g_mrd->ipktb->rlength);
}
return;
}
switch (pimmsg->type()) {
case pim_msg_hello:
handle_hello(src, (pim_hello_message *)g_mrd->ipktb->pheader(), g_mrd->ipktb->rlength);
break;
case pim_msg_joinprune:
handle_joinprune(src, (pim_joinprune_message *)g_mrd->ipktb->pheader(), g_mrd->ipktb->rlength);
break;
case pim_msg_assert:
handle_assert(src, (pim_assert_message *)g_mrd->ipktb->pheader(), g_mrd->ipktb->rlength);
break;
case pim_msg_bootstrap:
handle_bootstrap(src, dst, (pim_bootstrap_message *)g_mrd->ipktb->pheader(), g_mrd->ipktb->rlength);
break;
default:
m_stats.counter(AllCount, Bad)++;
}
} else {
switch (pimmsg->type()) {
case pim_msg_register:
handle_register(src, dst);
break;
case pim_msg_register_stop:
handle_register_stop(src);
break;
case pim_msg_bootstrap:
handle_bootstrap(src, dst, (pim_bootstrap_message *)g_mrd->ipktb->pheader(), g_mrd->ipktb->rlength);
break;
case pim_msg_candidate_rp_adv:
handle_candidate_rp_adv(src,
(pim_candidate_rp_adv_message *)g_mrd->ipktb->pheader(),
g_mrd->ipktb->rlength);
break;
default:
m_stats.counter(AllCount, Bad)++;
}
}
}
void ClientHandler::client_handler_thread()
{
int num;
network_message message;
int pointeroffset = 0;
char network_str[100];
inet_ntop(AF_INET, &client_addr.sin_addr, network_str, sizeof(network_str));
std::cout << " connection from " << network_str
<< ":" << client_addr.sin_port << std::endl;
while(!stop)
{
//get message type
if ((num = read(client_socket, ((char *)&message)+pointeroffset, sizeof(network_message)-pointeroffset)) == -1)
{
std::cout <<"recv error" << std::endl;
disconnected();
}
else if(num == 0)
{ //disconnected
disconnected();
std::cout << "disconnected" << std::endl;
break;
}
pointeroffset = (pointeroffset + num) % sizeof(message);
if (pointeroffset == 0)
{
switch(message.type)
{
case message_type::hello:
if(!handle_hello(message) || !send_id())
{
disconnected();
}
break;
case message_type::new_card:
break;
case message_type::accepted:
break;
case message_type::denied:
break;
case message_type::i_have_card:
break;
case message_type::give_id:
break;
case message_type::client_list:
break;
case message_type::set_ready:
handle_ready_set(message.value);
break;
case message_type::state_update:
break;
}
}
}
close(client_socket);
}
static bool handle_line (s4pp_ctx_t *ctx, char *line, uint16_t len)
{
if (line[len -1] == '\n')
line[len -1] = 0;
else
goto protocol_error;
if (strncmp ("S4PP/", line, 5) == 0)
{
// S4PP/x.y <algo,algo...> <max_samples>
if (ctx->state != S4PP_CONNECT || !handle_hello (ctx, line))
goto protocol_error;
}
else if (strncmp ("TOK:", line, 4) == 0)
{
if (ctx->state == S4PP_HELLO)
handle_auth (ctx, line + 4, len - 5); // len - 5 => ditch \0
else
goto protocol_error;
}
else if (strncmp ("REJ:", line, 4) == 0)
goto protocol_error;
else if (strncmp ("NOK:", line, 4) == 0)
{
if (ctx->state != S4PP_COMMITTING)
goto protocol_error;
// we don't pipeline sequences, so don't need to check the seqno
ctx->state = S4PP_AUTHED;
invoke_done (ctx, false);
}
else if (strncmp ("OK:", line, 3) == 0)
{
if (ctx->state != S4PP_COMMITTING)
goto protocol_error;
ctx->proto_errs = 0;
ctx->state = S4PP_AUTHED;
invoke_done (ctx, true);
}
else if (strncmp ("NTFY:", line, 5) == 0)
{
char *argsp = 0;
unsigned long code = strtoul (line + 5, &argsp, 10);
unsigned nargs = 0;
for (char *p = argsp; *p; ++p)
if (*p == ',')
++nargs;
const char **args = malloc (sizeof (char *) * (nargs + 1));
if (args)
{
unsigned i = 0;
for (char *p = argsp; *p; ++p)
{
if (*p == ',')
{
args[i++] = p + 1;
*p = 0;
}
}
args[i] = 0; // Be nice and leave a null at the end of args array
ctx->ntfy (ctx, (unsigned)code, nargs, args);
free (args);
}
// else silently ignore it? or whinge somehow? TODO
}
else
goto protocol_error;
return_res;
protocol_error:
if (ctx->conn)
ctx->io->disconnect (ctx->conn);
ctx->conn = NULL;
ctx->err = S4PP_PROTOCOL_ERROR;
ctx->state = S4PP_ERRORED;
if (ctx->proto_errs >= MAX_PROTOCOL_ERRORS_BEFORE_FATAL)
ctx->fatal = true; // "escape hatch" to avoid reconnect hammering
else
++ctx->proto_errs;
invoke_done (ctx, false);
return_res;
}
