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; }