kdxcxs
/
n2n
mirror of https://github.com/ntop/n2n.git
1
0
Fork 0
Code Issues Releases Wiki Activity
Browse Source

Simplify edge mgmt handling by building a request structure and using it for replies

pull/947/head
Hamish Coleman 3 years ago
parent
9278e15896
commit
35c83a0825
1 changed files with 113 additions and 118 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 231
      src/edge_management.c

231
src/edge_management.c
View File

@ -19,32 +19,47 @@
#include "n2n.h" #include "n2n.h"
#include "edge_utils_win32.h" #include "edge_utils_win32.h"
/*
* Everything needed to reply to a request
*/
typedef struct mgmt_req {
n2n_edge_t *eee;
enum n2n_mgmt_type type;
char *tag;
struct sockaddr_in sender_sock;
} mgmt_req_t;
#define FLAG_WROK 1 #define FLAG_WROK 1
typedef struct mgmt_handler { typedef struct mgmt_handler {
int flags; int flags;
char *cmd; char *cmd;
char *help; char *help;
void (*func)(n2n_edge_t *eee, char *udp_buf, struct sockaddr_in sender_sock, enum n2n_mgmt_type type, char *tag, char *argv0, char *argv); void (*func)(mgmt_req_t *reg, char *udp_buf, char *argv0, char *argv);
} mgmt_handler_t; } mgmt_handler_t;
static void mgmt_error (n2n_edge_t *eee, char *udp_buf, const struct sockaddr_in sender_sock, char *tag, char *msg) { static void send_reply (mgmt_req_t *req, char *udp_buf, size_t msg_len) {
// TODO: error handling
sendto(req->eee->udp_mgmt_sock, udp_buf, msg_len, 0,
(struct sockaddr *) &req->sender_sock, sizeof(struct sockaddr_in));
}
static void mgmt_error (mgmt_req_t *req, char *udp_buf, char *msg) {
size_t msg_len; size_t msg_len;
msg_len = snprintf(udp_buf, N2N_PKT_BUF_SIZE, msg_len = snprintf(udp_buf, N2N_PKT_BUF_SIZE,
"{" "{"
"\"_tag\":\"%s\"," "\"_tag\":\"%s\","
"\"_type\":\"error\"," "\"_type\":\"error\","
"\"error\":\"%s\"}\n", "\"error\":\"%s\"}\n",
tag, req->tag,
msg); msg);
sendto(eee->udp_mgmt_sock, udp_buf, msg_len, 0, send_reply(req, udp_buf, msg_len);
(struct sockaddr *) &sender_sock, sizeof(struct sockaddr_in));
} }
static void mgmt_stop (n2n_edge_t *eee, char *udp_buf, const struct sockaddr_in sender_sock, enum n2n_mgmt_type type, char *tag, char *argv0, char *argv) { static void mgmt_stop (mgmt_req_t *req, char *udp_buf, char *argv0, char *argv) {
size_t msg_len; size_t msg_len;
if(type==N2N_MGMT_WRITE) { if(req->type==N2N_MGMT_WRITE) {
*eee->keep_running = 0; *req->eee->keep_running = 0;
} }
msg_len = snprintf(udp_buf, N2N_PKT_BUF_SIZE, msg_len = snprintf(udp_buf, N2N_PKT_BUF_SIZE,
@ -52,17 +67,16 @@ static void mgmt_stop (n2n_edge_t *eee, char *udp_buf, const struct sockaddr_in
"\"_tag\":\"%s\"," "\"_tag\":\"%s\","
"\"_type\":\"row\"," "\"_type\":\"row\","
"\"keep_running\":%u}\n", "\"keep_running\":%u}\n",
tag, req->tag,
*eee->keep_running); *req->eee->keep_running);
sendto(eee->udp_mgmt_sock, udp_buf, msg_len, 0, send_reply(req, udp_buf, msg_len);
(struct sockaddr *) &sender_sock, sizeof(struct sockaddr_in));
} }
static void mgmt_verbose (n2n_edge_t *eee, char *udp_buf, const struct sockaddr_in sender_sock, enum n2n_mgmt_type type, char *tag, char *argv0, char *argv) { static void mgmt_verbose (mgmt_req_t *req, char *udp_buf, char *argv0, char *argv) {
size_t msg_len; size_t msg_len;
if(type==N2N_MGMT_WRITE) { if(req->type==N2N_MGMT_WRITE) {
if(argv) { if(argv) {
setTraceLevel(strtoul(argv, NULL, 0)); setTraceLevel(strtoul(argv, NULL, 0));
} }
@ -73,18 +87,17 @@ static void mgmt_verbose (n2n_edge_t *eee, char *udp_buf, const struct sockaddr_
"\"_tag\":\"%s\"," "\"_tag\":\"%s\","
"\"_type\":\"row\"," "\"_type\":\"row\","
"\"traceLevel\":%u}\n", "\"traceLevel\":%u}\n",
tag, req->tag,
getTraceLevel()); getTraceLevel());
sendto(eee->udp_mgmt_sock, udp_buf, msg_len, 0, send_reply(req, udp_buf, msg_len);
(struct sockaddr *) &sender_sock, sizeof(struct sockaddr_in));
} }
static void mgmt_communities (n2n_edge_t *eee, char *udp_buf, const struct sockaddr_in sender_sock, enum n2n_mgmt_type type, char *tag, char *argv0, char *argv) { static void mgmt_communities (mgmt_req_t *req, char *udp_buf, char *argv0, char *argv) {
size_t msg_len; size_t msg_len;
if(eee->conf.header_encryption != HEADER_ENCRYPTION_NONE) { if(req->eee->conf.header_encryption != HEADER_ENCRYPTION_NONE) {
mgmt_error(eee, udp_buf, sender_sock, tag, "noaccess"); mgmt_error(req, udp_buf, "noaccess");
return; return;
} }
@ -93,21 +106,20 @@ static void mgmt_communities (n2n_edge_t *eee, char *udp_buf, const struct socka
"\"_tag\":\"%s\"," "\"_tag\":\"%s\","
"\"_type\":\"row\"," "\"_type\":\"row\","
"\"community\":\"%s\"}", "\"community\":\"%s\"}",
tag, req->tag,
eee->conf.community_name); req->eee->conf.community_name);
sendto(eee->udp_mgmt_sock, udp_buf, msg_len, 0, send_reply(req, udp_buf, msg_len);
(struct sockaddr *) &sender_sock, sizeof(struct sockaddr_in));
} }
static void mgmt_supernodes (n2n_edge_t *eee, char *udp_buf, const struct sockaddr_in sender_sock, enum n2n_mgmt_type type, char *tag, char *argv0, char *argv) { static void mgmt_supernodes (mgmt_req_t *req, char *udp_buf, char *argv0, char *argv) {
size_t msg_len; size_t msg_len;
struct peer_info *peer, *tmpPeer; struct peer_info *peer, *tmpPeer;
macstr_t mac_buf; macstr_t mac_buf;
n2n_sock_str_t sockbuf; n2n_sock_str_t sockbuf;
selection_criterion_str_t sel_buf; selection_criterion_str_t sel_buf;
HASH_ITER(hh, eee->conf.supernodes, peer, tmpPeer) { HASH_ITER(hh, req->eee->conf.supernodes, peer, tmpPeer) {
/* /*
* TODO: * TODO:
@ -128,22 +140,21 @@ static void mgmt_supernodes (n2n_edge_t *eee, char *udp_buf, const struct sockad
"\"selection\":\"%s\"," "\"selection\":\"%s\","
"\"last_seen\":%li," "\"last_seen\":%li,"
"\"uptime\":%li}\n", "\"uptime\":%li}\n",
tag, req->tag,
peer->version, peer->version,
peer->purgeable, peer->purgeable,
(peer == eee->curr_sn) ? (eee->sn_wait ? 2 : 1 ) : 0, (peer == req->eee->curr_sn) ? (req->eee->sn_wait ? 2 : 1 ) : 0,
is_null_mac(peer->mac_addr) ? "" : macaddr_str(mac_buf, peer->mac_addr), is_null_mac(peer->mac_addr) ? "" : macaddr_str(mac_buf, peer->mac_addr),
sock_to_cstr(sockbuf, &(peer->sock)), sock_to_cstr(sockbuf, &(peer->sock)),
sn_selection_criterion_str(eee, sel_buf, peer), sn_selection_criterion_str(req->eee, sel_buf, peer),
peer->last_seen, peer->last_seen,
peer->uptime); peer->uptime);
sendto(eee->udp_mgmt_sock, udp_buf, msg_len, 0, send_reply(req, udp_buf, msg_len);
(struct sockaddr *) &sender_sock, sizeof(struct sockaddr_in));
} }
} }
static void mgmt_edges_row (n2n_edge_t *eee, char *udp_buf, const struct sockaddr_in sender_sock, char *tag, struct peer_info *peer, char *mode) { static void mgmt_edges_row (mgmt_req_t *req, char *udp_buf, struct peer_info *peer, char *mode) {
size_t msg_len; size_t msg_len;
macstr_t mac_buf; macstr_t mac_buf;
n2n_sock_str_t sockbuf; n2n_sock_str_t sockbuf;
@ -163,7 +174,7 @@ static void mgmt_edges_row (n2n_edge_t *eee, char *udp_buf, const struct sockadd
"\"last_p2p\":%li,\n" "\"last_p2p\":%li,\n"
"\"last_sent_query\":%li,\n" "\"last_sent_query\":%li,\n"
"\"last_seen\":%li}\n", "\"last_seen\":%li}\n",
tag, req->tag,
mode, mode,
(peer->dev_addr.net_addr == 0) ? "" : ip_subnet_to_str(ip_bit_str, &peer->dev_addr), (peer->dev_addr.net_addr == 0) ? "" : ip_subnet_to_str(ip_bit_str, &peer->dev_addr),
peer->purgeable, peer->purgeable,
@ -175,25 +186,24 @@ static void mgmt_edges_row (n2n_edge_t *eee, char *udp_buf, const struct sockadd
peer->last_sent_query, peer->last_sent_query,
peer->last_seen); peer->last_seen);
sendto(eee->udp_mgmt_sock, udp_buf, msg_len, 0 /*flags*/, send_reply(req, udp_buf, msg_len);
(struct sockaddr *) &sender_sock, sizeof(struct sockaddr_in));
} }
static void mgmt_edges (n2n_edge_t *eee, char *udp_buf, const struct sockaddr_in sender_sock, enum n2n_mgmt_type type, char *tag, char *argv0, char *argv) { static void mgmt_edges (mgmt_req_t *req, char *udp_buf, char *argv0, char *argv) {
struct peer_info *peer, *tmpPeer; struct peer_info *peer, *tmpPeer;
// dump nodes with forwarding through supernodes // dump nodes with forwarding through supernodes
HASH_ITER(hh, eee->pending_peers, peer, tmpPeer) { HASH_ITER(hh, req->eee->pending_peers, peer, tmpPeer) {
mgmt_edges_row(eee, udp_buf, sender_sock, tag, peer, "pSp"); mgmt_edges_row(req, udp_buf, peer, "pSp");
} }
// dump peer-to-peer nodes // dump peer-to-peer nodes
HASH_ITER(hh, eee->known_peers, peer, tmpPeer) { HASH_ITER(hh, req->eee->known_peers, peer, tmpPeer) {
mgmt_edges_row(eee, udp_buf, sender_sock, tag, peer, "p2p"); mgmt_edges_row(req, udp_buf, peer, "p2p");
} }
} }
static void mgmt_timestamps (n2n_edge_t *eee, char *udp_buf, const struct sockaddr_in sender_sock, enum n2n_mgmt_type type, char *tag, char *argv0, char *argv) { static void mgmt_timestamps (mgmt_req_t *req, char *udp_buf, char *argv0, char *argv) {
size_t msg_len; size_t msg_len;
msg_len = snprintf(udp_buf, N2N_PKT_BUF_SIZE, msg_len = snprintf(udp_buf, N2N_PKT_BUF_SIZE,
@ -203,16 +213,15 @@ static void mgmt_timestamps (n2n_edge_t *eee, char *udp_buf, const struct sockad
"\"start_time\":%lu," "\"start_time\":%lu,"
"\"last_super\":%ld," "\"last_super\":%ld,"
"\"last_p2p\":%ld}\n", "\"last_p2p\":%ld}\n",
tag, req->tag,
eee->start_time, req->eee->start_time,
eee->last_sup, req->eee->last_sup,
eee->last_p2p); req->eee->last_p2p);
sendto(eee->udp_mgmt_sock, udp_buf, msg_len, 0, send_reply(req, udp_buf, msg_len);
(struct sockaddr *) &sender_sock, sizeof(struct sockaddr_in));
} }
static void mgmt_packetstats (n2n_edge_t *eee, char *udp_buf, const struct sockaddr_in sender_sock, enum n2n_mgmt_type type, char *tag, char *argv0, char *argv) { static void mgmt_packetstats (mgmt_req_t *req, char *udp_buf, char *argv0, char *argv) {
size_t msg_len; size_t msg_len;
msg_len = snprintf(udp_buf, N2N_PKT_BUF_SIZE, msg_len = snprintf(udp_buf, N2N_PKT_BUF_SIZE,
@ -222,12 +231,11 @@ static void mgmt_packetstats (n2n_edge_t *eee, char *udp_buf, const struct socka
"\"type\":\"transop\"," "\"type\":\"transop\","
"\"tx_pkt\":%lu," "\"tx_pkt\":%lu,"
"\"rx_pkt\":%lu}\n", "\"rx_pkt\":%lu}\n",
tag, req->tag,
eee->transop.tx_cnt, req->eee->transop.tx_cnt,
eee->transop.rx_cnt); req->eee->transop.rx_cnt);
sendto(eee->udp_mgmt_sock, udp_buf, msg_len, 0, send_reply(req, udp_buf, msg_len);
(struct sockaddr *) &sender_sock, sizeof(struct sockaddr_in));
msg_len = snprintf(udp_buf, N2N_PKT_BUF_SIZE, msg_len = snprintf(udp_buf, N2N_PKT_BUF_SIZE,
"{" "{"
@ -236,12 +244,11 @@ static void mgmt_packetstats (n2n_edge_t *eee, char *udp_buf, const struct socka
"\"type\":\"p2p\"," "\"type\":\"p2p\","
"\"tx_pkt\":%u," "\"tx_pkt\":%u,"
"\"rx_pkt\":%u}\n", "\"rx_pkt\":%u}\n",
tag, req->tag,
eee->stats.tx_p2p, req->eee->stats.tx_p2p,
eee->stats.rx_p2p); req->eee->stats.rx_p2p);
sendto(eee->udp_mgmt_sock, udp_buf, msg_len, 0, send_reply(req, udp_buf, msg_len);
(struct sockaddr *) &sender_sock, sizeof(struct sockaddr_in));
msg_len = snprintf(udp_buf, N2N_PKT_BUF_SIZE, msg_len = snprintf(udp_buf, N2N_PKT_BUF_SIZE,
"{" "{"
@ -250,12 +257,11 @@ static void mgmt_packetstats (n2n_edge_t *eee, char *udp_buf, const struct socka
"\"type\":\"super\"," "\"type\":\"super\","
"\"tx_pkt\":%u," "\"tx_pkt\":%u,"
"\"rx_pkt\":%u}\n", "\"rx_pkt\":%u}\n",
tag, req->tag,
eee->stats.tx_sup, req->eee->stats.tx_sup,
eee->stats.rx_sup); req->eee->stats.rx_sup);
sendto(eee->udp_mgmt_sock, udp_buf, msg_len, 0, send_reply(req, udp_buf, msg_len);
(struct sockaddr *) &sender_sock, sizeof(struct sockaddr_in));
msg_len = snprintf(udp_buf, N2N_PKT_BUF_SIZE, msg_len = snprintf(udp_buf, N2N_PKT_BUF_SIZE,
"{" "{"
@ -264,20 +270,19 @@ static void mgmt_packetstats (n2n_edge_t *eee, char *udp_buf, const struct socka
"\"type\":\"super_broadcast\"," "\"type\":\"super_broadcast\","
"\"tx_pkt\":%u," "\"tx_pkt\":%u,"
"\"rx_pkt\":%u}\n", "\"rx_pkt\":%u}\n",
tag, req->tag,
eee->stats.tx_sup_broadcast, req->eee->stats.tx_sup_broadcast,
eee->stats.rx_sup_broadcast); req->eee->stats.rx_sup_broadcast);
sendto(eee->udp_mgmt_sock, udp_buf, msg_len, 0, send_reply(req, udp_buf, msg_len);
(struct sockaddr *) &sender_sock, sizeof(struct sockaddr_in));
} }
static void mgmt_unimplemented (n2n_edge_t *eee, char *udp_buf, const struct sockaddr_in sender_sock, enum n2n_mgmt_type type, char *tag, char *argv0, char *argv) { static void mgmt_unimplemented (mgmt_req_t *req, char *udp_buf, char *argv0, char *argv) {
mgmt_error(eee, udp_buf, sender_sock, tag, "unimplemented"); mgmt_error(req, udp_buf, "unimplemented");
} }
static void mgmt_help (n2n_edge_t *eee, char *udp_buf, const struct sockaddr_in sender_sock, enum n2n_mgmt_type type, char *tag, char *argv0, char *argv); static void mgmt_help (mgmt_req_t *req, char *udp_buf, char *argv0, char *argv);
mgmt_handler_t mgmt_handlers[] = { mgmt_handler_t mgmt_handlers[] = {
{ .cmd = "reload_communities", .flags = FLAG_WROK, .help = "Reserved for supernode", .func = mgmt_unimplemented}, { .cmd = "reload_communities", .flags = FLAG_WROK, .help = "Reserved for supernode", .func = mgmt_unimplemented},
@ -293,7 +298,7 @@ mgmt_handler_t mgmt_handlers[] = {
{ .cmd = NULL }, { .cmd = NULL },
}; };
static void mgmt_help (n2n_edge_t *eee, char *udp_buf, const struct sockaddr_in sender_sock, enum n2n_mgmt_type type, char *tag, char *argv0, char *argv) { static void mgmt_help (mgmt_req_t *req, char *udp_buf, char *argv0, char *argv) {
size_t msg_len; size_t msg_len;
mgmt_handler_t *handler; mgmt_handler_t *handler;
@ -309,12 +314,11 @@ static void mgmt_help (n2n_edge_t *eee, char *udp_buf, const struct sockaddr_in
"\"_type\":\"row\"," "\"_type\":\"row\","
"\"cmd\":\"%s\"," "\"cmd\":\"%s\","
"\"help\":\"%s\"}\n", "\"help\":\"%s\"}\n",
tag, req->tag,
handler->cmd, handler->cmd,
handler->help); handler->help);
sendto(eee->udp_mgmt_sock, udp_buf, msg_len, 0, send_reply(req, udp_buf, msg_len);
(struct sockaddr *) &sender_sock, sizeof(struct sockaddr_in));
} }
} }
@ -325,32 +329,30 @@ static void mgmt_help (n2n_edge_t *eee, char *udp_buf, const struct sockaddr_in
* Reads are not dangerous, so they are simply allowed * Reads are not dangerous, so they are simply allowed
* Writes are possibly dangerous, so they need a fake password * Writes are possibly dangerous, so they need a fake password
*/ */
static int mgmt_auth (n2n_edge_t *eee, const struct sockaddr_in sender_sock, enum n2n_mgmt_type type, char *auth, char *argv0, char *argv) { static int mgmt_auth (mgmt_req_t *req, char *auth, char *argv0, char *argv) {
if(auth) { if(auth) {
/* If we have an auth key, it must match */ /* If we have an auth key, it must match */
if(eee->conf.mgmt_password_hash == pearson_hash_64((uint8_t*)auth, strlen(auth))) { if(req->eee->conf.mgmt_password_hash == pearson_hash_64((uint8_t*)auth, strlen(auth))) {
return 1; return 1;
} }
return 0; return 0;
} }
/* if we dont have an auth key, we can still read */ /* if we dont have an auth key, we can still read */
if(type == N2N_MGMT_READ) { if(req->type == N2N_MGMT_READ) {
return 1; return 1;
} }
return 0; return 0;
} }
static void handleMgmtJson (n2n_edge_t *eee, char *udp_buf, const struct sockaddr_in sender_sock) { static void handleMgmtJson (mgmt_req_t *req, char *udp_buf, const int recvlen) {
char cmdlinebuf[80]; char cmdlinebuf[80];
enum n2n_mgmt_type type;
char *typechar; char *typechar;
char *options; char *options;
char *argv0; char *argv0;
char *argv; char *argv;
char *tag;
char *flagstr; char *flagstr;
int flags; int flags;
char *auth; char *auth;
@ -364,31 +366,32 @@ static void handleMgmtJson (n2n_edge_t *eee, char *udp_buf, const struct sockadd
traceEvent(TRACE_DEBUG, "mgmt json %s", cmdlinebuf); traceEvent(TRACE_DEBUG, "mgmt json %s", cmdlinebuf);
typechar = strtok(cmdlinebuf, " \r\n"); typechar = strtok(cmdlinebuf, " \r\n");
req->tag = "-1";
if(!typechar) { if(!typechar) {
/* should not happen */ /* should not happen */
mgmt_error(eee, udp_buf, sender_sock, "-1", "notype"); mgmt_error(req, udp_buf, "notype");
return; return;
} }
if(*typechar == 'r') { if(*typechar == 'r') {
type=N2N_MGMT_READ; req->type=N2N_MGMT_READ;
} else if(*typechar == 'w') { } else if(*typechar == 'w') {
type=N2N_MGMT_WRITE; req->type=N2N_MGMT_WRITE;
} else { } else {
/* dunno how we got here */ /* dunno how we got here */
mgmt_error(eee, udp_buf, sender_sock, "-1", "badtype"); mgmt_error(req, udp_buf, "badtype");
return; return;
} }
/* Extract the tag to use in all reply packets */ /* Extract the tag to use in all reply packets */
options = strtok(NULL, " \r\n"); options = strtok(NULL, " \r\n");
if(!options) { if(!options) {
mgmt_error(eee, udp_buf, sender_sock, "-1", "nooptions"); mgmt_error(req, udp_buf, "nooptions");
return; return;
} }
argv0 = strtok(NULL, " \r\n"); argv0 = strtok(NULL, " \r\n");
if(!argv0) { if(!argv0) {
mgmt_error(eee, udp_buf, sender_sock, "-1", "nocmd"); mgmt_error(req, udp_buf, "nocmd");
return; return;
} }
@ -401,7 +404,7 @@ static void handleMgmtJson (n2n_edge_t *eee, char *udp_buf, const struct sockadd
/* /*
* There might be an auth token mixed in with the tag * There might be an auth token mixed in with the tag
*/ */
tag = strtok(options, ":"); req->tag = strtok(options, ":");
flagstr = strtok(NULL, ":"); flagstr = strtok(NULL, ":");
if(flagstr) { if(flagstr) {
flags = strtoul(flagstr, NULL, 16); flags = strtoul(flagstr, NULL, 16);
@ -416,8 +419,8 @@ static void handleMgmtJson (n2n_edge_t *eee, char *udp_buf, const struct sockadd
auth = NULL; auth = NULL;
} }
if(!mgmt_auth(eee, sender_sock, type, auth, argv0, argv)) { if(!mgmt_auth(req, auth, argv0, argv)) {
mgmt_error(eee, udp_buf, sender_sock, tag, "badauth"); mgmt_error(req, udp_buf, "badauth");
return; return;
} }
@ -427,12 +430,12 @@ static void handleMgmtJson (n2n_edge_t *eee, char *udp_buf, const struct sockadd
} }
} }
if(!handler->cmd) { if(!handler->cmd) {
mgmt_error(eee, udp_buf, sender_sock, tag, "unknowncmd"); mgmt_error(req, udp_buf, "unknowncmd");
return; return;
} }
if((type==N2N_MGMT_WRITE) && !(handler->flags & FLAG_WROK)) { if((req->type==N2N_MGMT_WRITE) && !(handler->flags & FLAG_WROK)) {
mgmt_error(eee, udp_buf, sender_sock, tag, "readonly"); mgmt_error(req, udp_buf, "readonly");
return; return;
} }
@ -443,16 +446,14 @@ static void handleMgmtJson (n2n_edge_t *eee, char *udp_buf, const struct sockadd
* - do we care? * - do we care?
*/ */
msg_len = snprintf(udp_buf, N2N_PKT_BUF_SIZE, msg_len = snprintf(udp_buf, N2N_PKT_BUF_SIZE,
"{\"_tag\":\"%s\",\"_type\":\"begin\",\"cmd\":\"%s\"}\n", tag, argv0); "{\"_tag\":\"%s\",\"_type\":\"begin\",\"cmd\":\"%s\"}\n", req->tag, argv0);
sendto(eee->udp_mgmt_sock, udp_buf, msg_len, 0, send_reply(req, udp_buf, msg_len);
(struct sockaddr *) &sender_sock, sizeof(struct sockaddr_in));
handler->func(eee, udp_buf, sender_sock, type, tag, argv0, argv); handler->func(req, udp_buf, argv0, argv);
msg_len = snprintf(udp_buf, N2N_PKT_BUF_SIZE, msg_len = snprintf(udp_buf, N2N_PKT_BUF_SIZE,
"{\"_tag\":\"%s\",\"_type\":\"end\"}\n", tag); "{\"_tag\":\"%s\",\"_type\":\"end\"}\n", req->tag);
sendto(eee->udp_mgmt_sock, udp_buf, msg_len, 0, send_reply(req, udp_buf, msg_len);
(struct sockaddr *) &sender_sock, sizeof(struct sockaddr_in));
return; return;
} }
@ -463,7 +464,7 @@ void readFromMgmtSocket (n2n_edge_t *eee) {
char udp_buf[N2N_PKT_BUF_SIZE]; /* Compete UDP packet */ char udp_buf[N2N_PKT_BUF_SIZE]; /* Compete UDP packet */
ssize_t recvlen; ssize_t recvlen;
/* ssize_t sendlen; */ /* ssize_t sendlen; */
struct sockaddr_in sender_sock; mgmt_req_t req;
socklen_t i; socklen_t i;
size_t msg_len; size_t msg_len;
time_t now; time_t now;
@ -480,11 +481,12 @@ void readFromMgmtSocket (n2n_edge_t *eee) {
uint32_t num = 0; uint32_t num = 0;
selection_criterion_str_t sel_buf; selection_criterion_str_t sel_buf;
req.eee = eee;
now = time(NULL); now = time(NULL);
i = sizeof(sender_sock); i = sizeof(req.sender_sock);
recvlen = recvfrom(eee->udp_mgmt_sock, udp_buf, N2N_PKT_BUF_SIZE, 0 /*flags*/, recvlen = recvfrom(eee->udp_mgmt_sock, udp_buf, N2N_PKT_BUF_SIZE, 0 /*flags*/,
(struct sockaddr *) &sender_sock, (socklen_t *) &i); (struct sockaddr *) &req.sender_sock, (socklen_t *) &i);
if(recvlen < 0) { if(recvlen < 0) {
traceEvent(TRACE_WARNING, "mgmt recvfrom failed: %d - %s", errno, strerror(errno)); traceEvent(TRACE_WARNING, "mgmt recvfrom failed: %d - %s", errno, strerror(errno));
@ -507,8 +509,7 @@ void readFromMgmtSocket (n2n_edge_t *eee) {
"\tw ... | start update with JSON reply\n" "\tw ... | start update with JSON reply\n"
"\t<enter> | Display statistics\n\n"); "\t<enter> | Display statistics\n\n");
sendto(eee->udp_mgmt_sock, udp_buf, msg_len, 0 /*flags*/, send_reply(&req, udp_buf, msg_len);
(struct sockaddr *) &sender_sock, sizeof(struct sockaddr_in));
return; return;
} }
@ -527,8 +528,7 @@ void readFromMgmtSocket (n2n_edge_t *eee) {
msg_len += snprintf((char *) (udp_buf + msg_len), (N2N_PKT_BUF_SIZE - msg_len), msg_len += snprintf((char *) (udp_buf + msg_len), (N2N_PKT_BUF_SIZE - msg_len),
"> +OK traceLevel=%u\n", (unsigned int) getTraceLevel()); "> +OK traceLevel=%u\n", (unsigned int) getTraceLevel());
sendto(eee->udp_mgmt_sock, udp_buf, msg_len, 0 /*flags*/, send_reply(&req, udp_buf, msg_len);
(struct sockaddr *) &sender_sock, sizeof(struct sockaddr_in));
return; return;
} }
@ -547,14 +547,13 @@ void readFromMgmtSocket (n2n_edge_t *eee) {
traceEvent(TRACE_NORMAL, "-verb traceLevel=%u", (unsigned int) getTraceLevel()); traceEvent(TRACE_NORMAL, "-verb traceLevel=%u", (unsigned int) getTraceLevel());
sendto(eee->udp_mgmt_sock, udp_buf, msg_len, 0 /*flags*/, send_reply(&req, udp_buf, msg_len);
(struct sockaddr *) &sender_sock, sizeof(struct sockaddr_in));
return; return;
} }
if((udp_buf[0] == 'r' || udp_buf[0] == 'w') && (udp_buf[1] == ' ')) { if((udp_buf[0] == 'r' || udp_buf[0] == 'w') && (udp_buf[1] == ' ')) {
/* this is a JSON request */ /* this is a JSON request */
handleMgmtJson(eee, udp_buf, sender_sock); handleMgmtJson(&req, udp_buf, recvlen);
return; return;
} }
@ -586,8 +585,7 @@ void readFromMgmtSocket (n2n_edge_t *eee) {
peer->dev_desc, peer->dev_desc,
(peer->last_seen) ? time_buf : ""); (peer->last_seen) ? time_buf : "");
sendto(eee->udp_mgmt_sock, udp_buf, msg_len, 0 /*flags*/, send_reply(&req, udp_buf, msg_len);
(struct sockaddr *) &sender_sock, sizeof(struct sockaddr_in));
msg_len = 0; msg_len = 0;
} }
@ -610,8 +608,7 @@ void readFromMgmtSocket (n2n_edge_t *eee) {
peer->dev_desc, peer->dev_desc,
(peer->last_seen) ? time_buf : ""); (peer->last_seen) ? time_buf : "");
sendto(eee->udp_mgmt_sock, udp_buf, msg_len, 0 /*flags*/, send_reply(&req, udp_buf, msg_len);
(struct sockaddr *) &sender_sock, sizeof(struct sockaddr_in));
msg_len = 0; msg_len = 0;
} }
@ -636,8 +633,7 @@ void readFromMgmtSocket (n2n_edge_t *eee) {
(peer->last_seen) ? time_buf : "", (peer->last_seen) ? time_buf : "",
(peer->uptime) ? uptime_buf : ""); (peer->uptime) ? uptime_buf : "");
sendto(eee->udp_mgmt_sock, udp_buf, msg_len, 0, send_reply(&req, udp_buf, msg_len);
(struct sockaddr *) &sender_sock, sizeof(struct sockaddr_in));
msg_len = 0; msg_len = 0;
} }
@ -683,6 +679,5 @@ void readFromMgmtSocket (n2n_edge_t *eee) {
msg_len += snprintf((char *) (udp_buf + msg_len), (N2N_PKT_BUF_SIZE - msg_len), msg_len += snprintf((char *) (udp_buf + msg_len), (N2N_PKT_BUF_SIZE - msg_len),
"\nType \"help\" to see more commands.\n\n"); "\nType \"help\" to see more commands.\n\n");
/* sendlen = */ sendto(eee->udp_mgmt_sock, udp_buf, msg_len, 0 /*flags*/, send_reply(&req, udp_buf, msg_len);
(struct sockaddr *) &sender_sock, sizeof(struct sockaddr_in));
} }

Write Preview
Loading…
Cancel
Save