void info_table_add_peer(info_table_t *table, char *col_name, shpeer_t *peer)
{
struct in_addr in_addr;
int pid;
if (!peer)
return;
info_table_add_str(table, "APP", peer->label);
info_table_add_str(table, "GROUP", peer->group);
info_table_add_key(table, "TOKEN", shpeer_kpub(peer));
info_table_add_key(table, "PRIV", shpeer_kpriv(peer));
if (peer->type == SHNET_PEER_IPV4 &&
peer->addr.sin_port) {
info_table_add_int(table, "PORT", ntohs(peer->addr.sin_port));
}
#if 0
if (run_flags & PFLAG_VERBOSE) {
if (peer->arch & SHARCH_LINUX && peer->arch & SHARCH_32BIT)
info_table_add_str(table, "ARCH", "LIN32");
else if (peer->arch & SHARCH_WIN && peer->arch & SHARCH_32BIT)
info_table_add_str(table, "ARCH", "WIN32");
else if (peer->arch & SHARCH_LINUX)
info_table_add_str(table, "ARCH", "LIN");
else if (peer->arch & SHARCH_WIN)
info_table_add_str(table, "ARCH", "WIN");
}
#endif
pid = share_appinfo_pid(peer->label);
info_table_add_int(table, "PID", pid);
}
int sharedaemon_bcast_send_peer(shpeer_t *peer)
{
struct sockaddr_in addr;
socklen_t addr_len;
struct timeval to;
fd_set write_set;
char dgram[512];
ssize_t w_len;
int fd;
int err;
fd = bcast_send_init();
if (fd < 0) {
fprintf(stderr, "DEBUG: sharedaemon_bcast_send: bcast_init error %d\n", err);
return (err);
}
FD_ZERO(&write_set);
FD_SET(fd, &write_set);
/* nonblocking write */
memset(&to, 0, sizeof(to));
err = select(fd+1, NULL, &write_set, NULL, &to);
if (err < 0) {
close(fd);
return (-errno);
}
if (err == 0) {
close(fd);
return (0); /* not able to send */
}
memset(dgram, 0, sizeof(dgram));
memcpy(dgram, peer, sizeof(shpeer_t));
addr_len = sizeof(addr);
memset(&addr, 0, addr_len);
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
addr.sin_port = htons(SHARED_BROADCAST_PORT);
w_len = sendto(fd,
dgram, sizeof(shpeer_t), 0, &addr, sizeof(addr));
if (w_len < 0) {
fprintf(stderr, "DEBUG: sharedaemon_bcast_send: sendto error: %s\n", strerror(errno));
close(fd);
return (-errno);
}
fprintf(stderr, "DEBUG: sharedaemon_bcast_send: peer \"%s\" <%d bytes>\n", shpeer_print(peer), w_len);
fprintf(stderr, "DEBUG: peer pubkey: %s\n", shkey_print(shpeer_kpub(peer)));
fprintf(stderr, "DEBUG: peer priv key: %s\n", shkey_print(shpeer_kpriv(peer)));
/* close socket; only used once. */
close(fd);
return (0);
}
/**
* @param origin a peer reference to the sender of the bond
*/
tx_bond_t *load_bond_peer(shpeer_t *sender, shpeer_t *receiver, shpeer_t *ref)
{
return (load_bond(get_bond_key(shpeer_kpriv(sender), shpeer_kpriv(receiver), shpeer_kpub(ref))));
}
int sharelog_list(shpeer_t *peer, time_t stime, time_t etime)
{
shbuf_t *buff;
fd_set read_fd;
shjson_t *json;
char tbuf[256];
char *data;
time_t now;
char *str;
int err;
int fd;
fd = shconnect_host("127.0.0.1", PROCESS_PORT, SHNET_ASYNC);
if (fd < 0)
return (fd);
json = shjson_init(NULL);
shjson_num_add(json, "id", 1);
shjson_str_add(json, "method", "log.list");
shjson_str_add(json, "key", (char *)shkey_print(shpeer_kpub(peer)));
shjson_null_add(json, "params");
str = shjson_print(json);
shjson_free(&json);
err = shnet_write(fd, str, strlen(str));
free(str);
if (err < 0) {
shclose(fd);
return (err);
}
err = shnet_write(fd, "\n", 1);
if (err < 0) {
shclose(fd);
return (err);
}
while (1) {
FD_ZERO(&read_fd);
FD_SET(fd, &read_fd);
err = shnet_verify(&read_fd, NULL, NULL);
if (err < 0) {
continue;
}
buff = shnet_read_buf(fd);
if (!buff)
break;
data = shbuf_data(buff);
if (!strchr(data, '\n'))
continue;
json = shjson_init(data);
if (json) {
char *text = shjson_astr(json, "result", NULL);
if (text) {
printf("%s", text);
}
shjson_free(&json);
}
break;
}
shclose(fd);
return (0);
}
int sharelog_tail(shpeer_t *peer)
{
shbuf_t *buff;
fd_set read_fd;
shjson_t *json;
char tbuf[256];
time_t stime, etime;
time_t now;
char *str;
int err;
int fd;
fd = shconnect_host("127.0.0.1", PROCESS_PORT, SHNET_ASYNC);
if (fd < 0)
return (fd);
json = shjson_init(NULL);
shjson_num_add(json, "id", 1);
shjson_str_add(json, "method", "log.subscribe");
shjson_str_add(json, "key", (char *)shkey_print(shpeer_kpub(peer)));
shjson_null_add(json, "params");
str = shjson_print(json);
shjson_free(&json);
err = shnet_write(fd, str, strlen(str));
free(str);
if (err < 0) {
shclose(fd);
return (err);
}
err = shnet_write(fd, "\n", 1);
if (err < 0) {
shclose(fd);
return (err);
}
while (proc_mode == RUN_TAIL) {
FD_ZERO(&read_fd);
FD_SET(fd, &read_fd);
err = shnet_verify(&read_fd, NULL, NULL);
if (err < 0) {
continue;
}
buff = shnet_read_buf(fd);
if (!buff || shbuf_size(buff) == 0)
continue;
json = shjson_init(shbuf_data(buff));
if (json) {
char *text = shjson_astr(json, "result", NULL);
if (text) {
now = time(NULL);
strftime(tbuf, sizeof(tbuf) - 1, "%D %T", localtime(&now));
printf("[%s] %s", tbuf, text);
}
}
shbuf_clear(buff);
}
shclose(fd);
return (0);
}
int sharedaemon_bcast_recv(void)
{
struct sockaddr_in addr;
socklen_t addr_len;
struct timeval to;
fd_set read_set;
shpeer_t *peer;
char dgram[512];
ssize_t r_len;
int err;
err = bcast_recv_init();
if (err) {
return (err);
}
FD_ZERO(&read_set);
FD_SET(_bcast_recv_fd, &read_set);
/* nonblocking read */
memset(&to, 0, sizeof(to));
err = select(_bcast_recv_fd+1, &read_set, NULL, NULL, &to);
if (err < 0) {
return (-errno);
}
if (err == 0) {
//fprintf(stderr, "\rWaiting for select(_bcast_recv_fd)..");
//fflush(stderr);
return (0); /* nothing to read */
}
addr_len = sizeof(addr);
memset(&addr, 0, addr_len);
r_len = recvfrom(_bcast_recv_fd,
dgram, sizeof dgram, 0, &addr, &addr_len);
if (r_len < 0) {
fprintf(stderr, "DEBUG: %d = recvfrom()\n", r_len);
return (-errno);
}
/* and who are you? */
if (r_len < sizeof(shpeer_t)) {
fprintf(stderr, "DEBUG: <%d bytes> pending..\n", r_len);
return (SHERR_INVAL);
}
#if 0
now = shtime();
tx = (tx_t *)dgram;
if (shtime_after(tx->tx_stamp, now) ||
shtime_before(tx->tx_stamp, shtime_adj(now, -BROADCAST_TIMEOUT))) {
/* broadcast message must indicate sane time-frame. */
return (SHERR_TIME);
}
switch (tx->tx_op) {
case TX_PEER:
peer_tx = (tx_peer_t *)dgram;
if (0 != shkey_cmp(&tx->tx_peer, shpeer_kpriv(&peer_tx->peer)))
return (SHERR_INVAL); /* only accept self-referencing broadcast */
}
#endif
/* share-daemon broadcasting it's peer address. */
peer = (shpeer_t *)dgram;
if (!shkey_cmp(shpeer_kpub(sharedaemon_peer()), shpeer_kpub(peer))) {
/* this is not a shared peer */
return (0); /* all done */
}
if (!shkey_cmp(shpeer_kpub(sharedaemon_peer()), shpeer_kpub(peer))) {
fprintf(stderr, "DEBUG: invalid key\n");
/* this is a peer referencing ourselves. */
//err = sharedaemon_netclient_alias(&addr);
}
switch (peer->type) {
case SHNET_PEER_LOCAL:
case SHNET_PEER_IPV4:
/*
memset(&addr, '\000', sizeof(struct sockaddr_in));
memcpy(&addr, &peer_tx->peer.addr, sizeof(peer_tx->peer.addr));
*/
fprintf(stderr, "DEBUG: received UDP broadcast with peer \"%s\"\n", shpeer_print(peer));
fprintf(stderr, "DEBUG: received UDP broadcast for \"%s\" port %d\n", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port));
if (!peer->addr.sin_port)
break; /* otay */
addr.sin_family = AF_INET;
err = sharedaemon_netclient_conn(peer, &addr);
if (err)
return (err);
break;
}
fprintf(stderr, "DEBUG: processed bcast recv\n");
return (0);
}
