diff --git a/script/wireshark-dissector.lua b/script/wireshark-dissector.lua index d9f4230..f227ac0 100644 --- a/script/wireshark-dissector.lua +++ b/script/wireshark-dissector.lua @@ -1,63 +1,67 @@ -- dofile("wireshark-dissector.lua") -- do booth_proto = Proto("Booth","Booth") function T32(tree, buffer, start, format) local b = buffer(start, 4) return tree:add(b, string.format(format, b:uint())) end function booth_proto.dissector(buffer, pinfo, tree) local endbuf = buffer:len() pinfo.cols.protocol = "Booth" if (endbuf < 24) then pinfo.cols.info = "Booth - too small" else local hdr = tree:add(booth_proto, buffer(0, 24), "Booth header") - local cmd = buffer(16, 4) + local cmd = buffer(28, 4) local tcmd = T32(hdr, cmd, 0, "Cmd %08x, \"" .. cmd:string() .. "\""); - local from = buffer(8, 4) + local from = buffer(20, 4) local tfrom = T32(hdr, from, 0, "From %08x"); if bit.band(from:uint(), 0x80000000) > 0 then tfrom:add_expert_info(PI_PROTOCOL, PI_WARN, "Highest bit set") end - local len = buffer(12, 4) + local len = buffer(24, 4) local tlen = T32(hdr, len, 0, "Length %8d"); if len:uint() > 1000 then tlen:add_expert_info(PI_PROTOCOL, PI_WARN, "Length too big?") end - T32(hdr, buffer, 20, "Result %08x"); - T32(hdr, buffer, 0, "Magic %08x"); - T32(hdr, buffer, 4, "Version %08x"); + T32(hdr, buffer, 32, "Result %08x"); + T32(hdr, buffer, 12, "Magic %08x"); + T32(hdr, buffer, 16, "Version %08x"); + T32(hdr, buffer, 0, "IV %08x"); + T32(hdr, buffer, 4, "Auth1 %08x"); + T32(hdr, buffer, 8, "Auth2 %08x"); - if (endbuf > 24) then - local tick = tree:add(booth_proto, buffer(24, endbuf-24), "Booth data") - local name = buffer(24, 64) + + if (endbuf > 36) then + local tick = tree:add(booth_proto, buffer(36, endbuf-36), "Booth data") + local name = buffer(36, 64) tick:add(name, "Ticket name: ", name:string()) - T32(tick, buffer, 24+64 + 0, "Owner: %08x") - T32(tick, buffer, 24+64 + 4, "Ballot: %08x") - T32(tick, buffer, 24+64 + 8, "Prev. Ballot: %08x") - T32(tick, buffer, 24+64 + 12, "Expiry: %8d") + T32(tick, buffer, 36+64 + 0, "Owner: %08x") + T32(tick, buffer, 36+64 + 4, "Ballot: %08x") + T32(tick, buffer, 36+64 + 8, "Prev. Ballot: %08x") + T32(tick, buffer, 36+64 + 12, "Expiry: %8d") end pinfo.cols.info = "Booth, cmd " .. cmd:string() end tree:add(booth_proto, buffer(0, endbuf), "data") end local tbl = DissectorTable.get("udp.port") tbl:add(9929, booth_proto) local tbl = DissectorTable.get("tcp.port") tbl:add(9929, booth_proto) end diff --git a/src/booth.h b/src/booth.h index 336a8a5..78f5591 100644 --- a/src/booth.h +++ b/src/booth.h @@ -1,244 +1,250 @@ /* * Copyright (C) 2011 Jiaju Zhang * Copyright (C) 2013-2014 Philipp Marek * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #ifndef _BOOTH_H #define _BOOTH_H #include #include #include #include #include #define BOOTH_RUN_DIR "/var/run/booth/" #define BOOTH_LOG_DIR "/var/log" #define BOOTH_LOGFILE_NAME "booth.log" #define BOOTH_DEFAULT_CONF_DIR "/etc/booth/" #define BOOTH_DEFAULT_CONF_NAME "booth" #define BOOTH_DEFAULT_CONF_EXT ".conf" #define BOOTH_DEFAULT_CONF \ BOOTH_DEFAULT_CONF_DIR BOOTH_DEFAULT_CONF_NAME BOOTH_DEFAULT_CONF_EXT #define DAEMON_NAME "boothd" #define BOOTH_PATH_LEN 127 #define BOOTH_DEFAULT_PORT 9929 /* TODO: remove */ #define BOOTH_PROTO_FAMILY AF_INET #define BOOTHC_MAGIC 0x5F1BA08C #define BOOTHC_VERSION 0x00010002 /** Timeout value for poll(). * Determines frequency of periodic jobs, eg. when send-retries are done. * See process_tickets(). */ #define POLL_TIMEOUT 1000 /** @{ */ /** The on-network data structures and constants. */ #define BOOTH_NAME_LEN 64 #define NO_OWNER (-1) typedef unsigned char boothc_site [BOOTH_NAME_LEN]; typedef unsigned char boothc_ticket[BOOTH_NAME_LEN]; struct boothc_header { + /** Authentication data; not used now. */ + uint32_t iv; + uint32_t auth1; + uint32_t auth2; + + /** BOOTHC_MAGIC */ uint32_t magic; /** BOOTHC_VERSION */ uint32_t version; /** Packet source; site_id. See add_site(). */ uint32_t from; /** Length including header */ uint32_t length; /** The command respectively protocol state. See cmd_request_t. */ uint32_t cmd; /** Result of operation. 0 == OK */ uint32_t result; char data[0]; } __attribute__((packed)); struct ticket_msg { /** Ticket name. */ boothc_ticket id; /** Owner. May be NO_OWNER. See add_site(). */ uint32_t owner; /** Current ballot number. Might be < prev_ballot if overflown. */ uint32_t ballot; /** Previous ballot. */ uint32_t prev_ballot; /* Would we want to say _whose_ proposal is more important * when sending OP_REJECTED ? */ /** Seconds until expiration. */ uint32_t expiry; } __attribute__((packed)); struct boothc_ticket_msg { struct boothc_header header; struct ticket_msg ticket; } __attribute__((packed)); /** State and message IDs. * * These numbers are unlikely to conflict with other enums. * All have to be swabbed to network order before sending. * * \dot * digraph states { * node [shape=box]; * ST_INIT [label="ST_INIT"]; * * subgraph messages { // messages * rank=same; * node [shape=point, rank=same]; * edge [style=tapered, penwidth=3, arrowtail=none, arrowhead=none, dir=forward]; * * ST_INIT:e -> ST_INITs [label="sends out CMD_CATCHUP"]; * } * * ST_INIT -> ST_STABLE [label="recv CMR_CATCHUP"]; * ST_STABLE; * * ST_STABLE -> OP_PROPOSING [label="booth call to assign ticket"]; * } * \enddot * * */ #define CHAR2CONST(a,b,c,d) ((a << 24) | (b << 16) | (c << 8) | d) #define STG2CONST(X) ({ const char _ggg[4] = X; return (uint32_t*)_ggg; }) typedef enum { /* 0x43 = "C"ommands */ CMD_LIST = CHAR2CONST('C', 'L', 's', 't'), CMD_GRANT = CHAR2CONST('C', 'G', 'n', 't'), CMD_REVOKE = CHAR2CONST('C', 'R', 'v', 'k'), CMD_CATCHUP = CHAR2CONST('C', 'C', 't', 'p'), /* Replies */ CMR_GENERAL = CHAR2CONST('G', 'n', 'l', 'R'), // Increase distance to CMR_GRANT CMR_LIST = CHAR2CONST('R', 'L', 's', 't'), CMR_GRANT = CHAR2CONST('R', 'G', 'n', 't'), CMR_REVOKE = CHAR2CONST('R', 'R', 'v', 'k'), CMR_CATCHUP = CHAR2CONST('R', 'C', 't', 'p'), /* Paxos */ OP_PREPARING = CHAR2CONST('P', 'r', 'e', 'p'), OP_PROMISING = CHAR2CONST('P', 'r', 'o', 'm'), OP_PROPOSING = CHAR2CONST('P', 'r', 'o', 'p'), OP_ACCEPTING = CHAR2CONST('A', 'c', 'p', 't'), OP_RECOVERY = CHAR2CONST('R', 'c', 'v', 'y'), OP_COMMITTED = CHAR2CONST('C', 'm', 'm', 't'), OP_REJECTED = CHAR2CONST('R', 'J', 'C', '!'), /* These are not used over the wire */ ST_INIT = CHAR2CONST('I', 'n', 'i', 't'), ST_STABLE = CHAR2CONST('S', 't', 'b', 'l'), } cmd_request_t; /* TODO: make readable constants */ typedef enum { /* for compatibility with other functions */ RLT_SUCCESS = 0, RLT_ASYNC = CHAR2CONST('A', 's', 'y', 'n'), RLT_SYNC_SUCC = CHAR2CONST('S', 'c', 'c', 's'), RLT_SYNC_FAIL = CHAR2CONST('F', 'a', 'i', 'l'), RLT_INVALID_ARG = CHAR2CONST('I', 'A', 'r', 'g'), RLT_OVERGRANT = CHAR2CONST('O', 'v', 'e', 'r'), RLT_PROBABLY_SUCCESS = CHAR2CONST('S', 'u', 'c', '?'), RLT_BUSY = CHAR2CONST('B', 'u', 's', 'y'), } cmd_result_t; /** @} */ /** @{ */ struct booth_site { /** Calculated ID. See add_site(). */ int site_id; int type; int local; /** Roles, like ACCEPTOR, PROPOSER, or LEARNER. Not really used ATM. */ int role; char addr_string[BOOTH_NAME_LEN]; int tcp_fd; int udp_fd; /* 0-based, used for indexing into per-ticket weights */ int index; uint64_t bitmask; unsigned short family; union { struct sockaddr_in sa4; struct sockaddr_in6 sa6; }; int saddrlen; int addrlen; } __attribute__((packed)); extern struct booth_site *local; /** @} */ struct booth_transport; struct client { int fd; const struct booth_transport *transport; void (*workfn)(int); void (*deadfn)(int); }; extern struct client *clients; extern struct pollfd *pollfds; int client_add(int fd, const struct booth_transport *tpt, void (*workfn)(int ci), void (*deadfn)(int ci)); int do_read(int fd, void *buf, size_t count); int do_write(int fd, void *buf, size_t count); void process_connection(int ci); void safe_copy(char *dest, char *value, size_t buflen, const char *description); #endif /* _BOOTH_H */ diff --git a/src/inline-fn.h b/src/inline-fn.h index 453c9c5..39d23c0 100644 --- a/src/inline-fn.h +++ b/src/inline-fn.h @@ -1,267 +1,270 @@ /* * Copyright (C) 2013-2014 Philipp Marek * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This software is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #ifndef _INLINE_FN_H #define _INLINE_FN_H #include #include #include #include #include "config.h" #include "transport.h" inline static uint32_t get_local_id(void) { return local ? local->site_id : -1; } inline static uint32_t get_node_id(struct booth_site *node) { return node ? node->site_id : NO_OWNER; } inline static int ticket_valid_for(const struct ticket_config *tk) { int left; left = tk->expires - time(NULL); return (left < 0) ? 0 : left; } /** Returns number of seconds left, if any. */ inline static int owner_and_valid(const struct ticket_config *tk) { if (tk->owner != local) return 0; return ticket_valid_for(tk); } static inline void init_header_bare(struct boothc_header *h) { h->magic = htonl(BOOTHC_MAGIC); h->version = htonl(BOOTHC_VERSION); h->from = htonl(local->site_id); + h->iv = htonl(0); + h->auth1 = htonl(0); + h->auth2 = htonl(0); } static inline void init_header(struct boothc_header *h, int cmd, int result, int data_len) { init_header_bare(h); h->length = htonl(data_len); h->cmd = htonl(cmd); h->result = htonl(result); } static inline void init_ticket_site_header(struct boothc_ticket_msg *msg, int cmd) { init_header(&msg->header, cmd, 0, sizeof(*msg)); } static inline void init_ticket_msg(struct boothc_ticket_msg *msg, int cmd, int rv, struct ticket_config *tk) { assert(sizeof(msg->ticket.id) == sizeof(tk->name)); init_header(&msg->header, cmd, rv, sizeof(*msg)); if (!tk) { memset(&msg->ticket, 0, sizeof(msg->ticket)); } else { memcpy(msg->ticket.id, tk->name, sizeof(msg->ticket.id)); msg->ticket.expiry = htonl(ticket_valid_for(tk)); msg->ticket.owner = htonl(get_node_id(tk->owner)); msg->ticket.ballot = htonl(tk->new_ballot); msg->ticket.prev_ballot = htonl(tk->last_ack_ballot); } } static inline struct booth_transport const *transport(void) { return booth_transport + booth_conf->proto; } static inline const char *ticket_owner_string(struct booth_site *site) { return site ? site->addr_string : "NONE"; } static inline void disown_ticket(struct ticket_config *tk) { tk->owner = NULL; tk->proposed_owner = NULL; time(&tk->expires); } static inline void disown_if_expired(struct ticket_config *tk) { if (time(NULL) >= tk->expires || !tk->proposed_owner) disown_ticket(tk); } static inline int all_agree(struct ticket_config *tk) { return tk->proposal_acknowledges == booth_conf->site_bits; } static inline int majority_agree(struct ticket_config *tk) { /* Use ">" to get majority decision, even for an even number * of participants. */ return __builtin_popcount(tk->proposal_acknowledges) * 2 > booth_conf->site_count; } /* We allow half of the uint32_t to be used; * half of that below, half of that above the current known "good" value. * 0 UINT32_MAX * |--------------------------+----------------+------------| * | | | * |--------+-------| allowed range * | * current ballot * * So, on overflow it looks like that: * UINT32_MAX 0 * |--------------------------+-----------||---+------------| * | | | * |--------+-------| allowed range * | * current ballot * * This should be possible by using the same datatype and relying * on the under/overflow semantics. */ static inline int ballot_is_higher_than(uint32_t b_high, uint32_t b_low) { uint32_t diff; if (b_high == b_low) return 0; diff = b_high - b_low; if (diff < UINT32_MAX/4) return 1; diff = b_low - b_high; if (diff < UINT32_MAX/4) return 0; assert(!"ballot out of range - invalid"); } static inline uint32_t ballot_max2(uint32_t a, uint32_t b) { return ballot_is_higher_than(a, b) ? a : b; } static inline uint32_t ballot_max3(uint32_t a, uint32_t b, uint32_t c) { return ballot_max2( ballot_max2(a, b), c); } static inline double timeval_to_float(struct timeval tv) { return tv.tv_sec + tv.tv_usec*(double)1.0e-6; } static inline int timeval_msec(struct timeval tv) { int m; m = tv.tv_usec / 1000; if (m >= 1000) m = 999; return m; } static inline int timeval_compare(struct timeval tv1, struct timeval tv2) { if (tv1.tv_sec < tv2.tv_sec) return -1; if (tv1.tv_sec > tv2.tv_sec) return +1; if (tv1.tv_usec < tv2.tv_usec) return -1; if (tv1.tv_usec > tv2.tv_usec) return +1; return 0; } static inline int timeval_in_past(struct timeval which) { struct timeval tv; gettimeofday(&tv, NULL); return timeval_compare(tv, which) > 0; } static inline time_t next_renewal_starts_at(struct ticket_config *tk) { time_t half_exp, retries_needed; /* If not owner, don't renew. */ if (tk->owner != local) return 0; /* Try to renew at half of expiry time. */ half_exp = tk->expires - tk->expiry/2; /* Also start renewal if we couldn't get * a few message retransmission in the alloted * expiry time. */ retries_needed = tk->expires - tk->timeout * tk->retries/2; /* Return earlier timestamp. */ return half_exp < retries_needed ? half_exp : retries_needed; } static inline int should_start_renewal(struct ticket_config *tk) { time_t now, when; when = next_renewal_starts_at(tk); if (!when) return 0; time(&now); return when >= now; } #endif