static void on_secure_handshake_done(grpc_exec_ctx *exec_ctx, void *statep,
grpc_security_status status,
grpc_endpoint *secure_endpoint,
grpc_auth_context *auth_context) {
grpc_server_secure_state *state = statep;
grpc_transport *transport;
if (status == GRPC_SECURITY_OK) {
if (secure_endpoint) {
gpr_mu_lock(&state->mu);
if (!state->is_shutdown) {
transport = grpc_create_chttp2_transport(
exec_ctx, grpc_server_get_channel_args(state->server),
secure_endpoint, 0);
setup_transport(exec_ctx, state, transport, auth_context);
grpc_chttp2_transport_start_reading(exec_ctx, transport, NULL, 0);
} else {
/* We need to consume this here, because the server may already have
* gone away. */
grpc_endpoint_destroy(exec_ctx, secure_endpoint);
}
gpr_mu_unlock(&state->mu);
}
} else {
gpr_log(GPR_ERROR, "Secure transport failed with error %d", status);
}
state_unref(state);
}
static int loop(int type)
{
void (*workfn) (int ci);
void (*deadfn) (int ci);
int rv, i;
rv = setup_config(type);
if (rv < 0)
goto fail;
rv = setup_timer();
if (rv < 0)
goto fail;
rv = setup_transport();
if (rv < 0)
goto fail;
rv = setup_ticket();
if (rv < 0)
goto fail;
rv = setup_listener(BOOTHC_SOCK_PATH);
if (rv < 0)
goto fail;
client_add(rv, process_listener, NULL);
while (1) {
rv = poll(pollfd, client_maxi + 1, poll_timeout);
if (rv == -1 && errno == EINTR)
continue;
if (rv < 0) {
log_error("poll errno %d", errno);
goto fail;
}
for (i = 0; i <= client_maxi; i++) {
if (client[i].fd < 0)
continue;
if (pollfd[i].revents & POLLIN) {
workfn = client[i].workfn;
if (workfn)
workfn(i);
}
if (pollfd[i].revents &
(POLLERR | POLLHUP | POLLNVAL)) {
deadfn = client[i].deadfn;
if (deadfn)
deadfn(i);
}
}
process_timerlist();
}
return 0;
fail:
return -1;
}
static int setup(int type)
{
int rv;
rv = setup_config(type);
if (rv < 0)
goto fail;
rv = setup_timer();
if (rv < 0)
goto fail;
rv = setup_transport();
if (rv < 0)
goto fail;
rv = setup_ticket();
if (rv < 0)
goto fail;
rv = setup_listener(BOOTHC_SOCK_PATH);
if (rv < 0)
goto fail;
client_add(rv, process_listener, NULL);
return 0;
fail:
return -1;
}
int main(int argc, char **argv) {
ev_default_loop(EVFLAG_SIGNALFD);
initialize_connections(EV_DEFAULT);
setup_transport(EV_DEFAULT_ &ws_transport);
setup_transport(EV_DEFAULT_ &fp_transport);
setup_transport(EV_DEFAULT_ &po_transport);
serve_flash_policy(EV_DEFAULT);
uq_redis_connect(EV_DEFAULT);
ev_run(EV_DEFAULT_ 0);
finalize_connections();
return 0;
}
static int loop(int fd)
{
void (*workfn) (int ci);
void (*deadfn) (int ci);
int rv, i;
rv = setup_transport();
if (rv < 0)
goto fail;
rv = setup_ticket();
if (rv < 0)
goto fail;
rv = write_daemon_state(fd, BOOTHD_STARTED);
if (rv != 0) {
log_error("write daemon state %d to lockfile error %s: %s",
BOOTHD_STARTED, cl.lockfile, strerror(errno));
goto fail;
}
log_info("BOOTH %s daemon started, node id is 0x%08X (%d).",
type_to_string(local->type),
local->site_id, local->site_id);
while (1) {
rv = poll(pollfds, client_maxi + 1, poll_timeout);
if (rv == -1 && errno == EINTR)
continue;
if (rv < 0) {
log_error("poll failed: %s (%d)", strerror(errno), errno);
goto fail;
}
for (i = 0; i <= client_maxi; i++) {
if (clients[i].fd < 0)
continue;
if (pollfds[i].revents & POLLIN) {
workfn = clients[i].workfn;
if (workfn)
workfn(i);
}
if (pollfds[i].revents &
(POLLERR | POLLHUP | POLLNVAL)) {
deadfn = clients[i].deadfn;
if (deadfn)
deadfn(i);
}
}
process_tickets();
}
return 0;
fail:
return -1;
}
static void new_transport(grpc_exec_ctx *exec_ctx, void *server,
grpc_endpoint *tcp) {
/*
* Beware that the call to grpc_create_chttp2_transport() has to happen before
* grpc_tcp_server_destroy(). This is fine here, but similar code
* asynchronously doing a handshake instead of calling grpc_tcp_server_start()
* (as in server_secure_chttp2.c) needs to add synchronization to avoid this
* case.
*/
grpc_transport *transport = grpc_create_chttp2_transport(
exec_ctx, grpc_server_get_channel_args(server), tcp, 0);
setup_transport(exec_ctx, server, transport);
grpc_chttp2_transport_start_reading(exec_ctx, transport, NULL, 0);
}
static int sendtoxymond(char *recipient, char *message, FILE *respfd, char **respstr, int fullresponse, int timeout)
{
struct in_addr addr;
struct sockaddr_in saddr;
int sockfd = -1;
fd_set readfds;
fd_set writefds;
int res, isconnected, wdone, rdone;
struct timeval tmo;
char *msgptr = message;
char *p;
char *rcptip = NULL;
int rcptport = 0;
int connretries = SENDRETRIES;
char *httpmessage = NULL;
char recvbuf[32768];
int haveseenhttphdrs = 1;
int respstrsz = 0;
int respstrlen = 0;
int result = XYMONSEND_OK;
if (dontsendmessages && !respfd && !respstr) {
fprintf(stdout, "%s\n", message);
fflush(stdout);
return XYMONSEND_OK;
}
setup_transport(recipient);
dbgprintf("Recipient listed as '%s'\n", recipient);
if (strncmp(recipient, "http://", strlen("http://")) != 0) {
/* Standard communications, directly to Xymon daemon */
rcptip = strdup(recipient);
rcptport = xymondportnumber;
p = strchr(rcptip, ':');
if (p) {
*p = '\0'; p++; rcptport = atoi(p);
}
dbgprintf("Standard protocol on port %d\n", rcptport);
}
else {
char *bufp;
char *posturl = NULL;
char *posthost = NULL;
if (xymonproxyhost == NULL) {
char *p;
/*
* No proxy. "recipient" is "http://host[:port]/url/for/post"
* Strip off "http://", and point "posturl" to the part after the hostname.
* If a portnumber is present, strip it off and update rcptport.
*/
rcptip = strdup(recipient+strlen("http://"));
rcptport = xymondportnumber;
p = strchr(rcptip, '/');
if (p) {
posturl = strdup(p);
*p = '\0';
}
p = strchr(rcptip, ':');
if (p) {
*p = '\0';
p++;
rcptport = atoi(p);
}
posthost = strdup(rcptip);
dbgprintf("HTTP protocol directly to host %s\n", posthost);
}
else {
char *p;
/*
* With proxy. The full "recipient" must be in the POST request.
*/
rcptip = strdup(xymonproxyhost);
rcptport = xymonproxyport;
posturl = strdup(recipient);
p = strchr(recipient + strlen("http://"), '/');
if (p) {
*p = '\0';
posthost = strdup(recipient + strlen("http://"));
*p = '/';
p = strchr(posthost, ':');
if (p) *p = '\0';
}
dbgprintf("HTTP protocol via proxy to host %s\n", posthost);
}
if ((posturl == NULL) || (posthost == NULL)) {
sprintf(errordetails + strlen(errordetails), "Unable to parse HTTP recipient");
if (posturl) xfree(posturl);
if (posthost) xfree(posthost);
if (rcptip) xfree(rcptip);
return XYMONSEND_EBADURL;
}
bufp = msgptr = httpmessage = malloc(strlen(message)+1024);
bufp += sprintf(httpmessage, "POST %s HTTP/1.0\n", posturl);
bufp += sprintf(bufp, "MIME-version: 1.0\n");
bufp += sprintf(bufp, "Content-Type: application/octet-stream\n");
bufp += sprintf(bufp, "Content-Length: %d\n", (int)strlen(message));
bufp += sprintf(bufp, "Host: %s\n", posthost);
bufp += sprintf(bufp, "\n%s", message);
if (posturl) xfree(posturl);
if (posthost) xfree(posthost);
haveseenhttphdrs = 0;
dbgprintf("HTTP message is:\n%s\n", httpmessage);
}
if (inet_aton(rcptip, &addr) == 0) {
/* recipient is not an IP - do DNS lookup */
struct hostent *hent;
char hostip[IP_ADDR_STRLEN];
hent = gethostbyname(rcptip);
if (hent) {
memcpy(&addr, *(hent->h_addr_list), sizeof(struct in_addr));
strcpy(hostip, inet_ntoa(addr));
if (inet_aton(hostip, &addr) == 0) {
result = XYMONSEND_EBADIP;
goto done;
}
}
else {
sprintf(errordetails+strlen(errordetails), "Cannot determine IP address of message recipient %s", rcptip);
result = XYMONSEND_EIPUNKNOWN;
goto done;
}
}
retry_connect:
dbgprintf("Will connect to address %s port %d\n", rcptip, rcptport);
memset(&saddr, 0, sizeof(saddr));
saddr.sin_family = AF_INET;
saddr.sin_addr.s_addr = addr.s_addr;
saddr.sin_port = htons(rcptport);
/* Get a non-blocking socket */
sockfd = socket(PF_INET, SOCK_STREAM, 0);
if (sockfd == -1) { result = XYMONSEND_ENOSOCKET; goto done; }
res = fcntl(sockfd, F_SETFL, O_NONBLOCK);
if (res != 0) { result = XYMONSEND_ECANNOTDONONBLOCK; goto done; }
res = connect(sockfd, (struct sockaddr *)&saddr, sizeof(saddr));
if ((res == -1) && (errno != EINPROGRESS)) {
sprintf(errordetails+strlen(errordetails), "connect to Xymon daemon@%s:%d failed (%s)", rcptip, rcptport, strerror(errno));
result = XYMONSEND_ECONNFAILED;
goto done;
}
rdone = ((respfd == NULL) && (respstr == NULL));
isconnected = wdone = 0;
while (!wdone || !rdone) {
FD_ZERO(&writefds);
FD_ZERO(&readfds);
if (!rdone) FD_SET(sockfd, &readfds);
if (!wdone) FD_SET(sockfd, &writefds);
tmo.tv_sec = timeout; tmo.tv_usec = 0;
res = select(sockfd+1, &readfds, &writefds, NULL, (timeout ? &tmo : NULL));
if (res == -1) {
sprintf(errordetails+strlen(errordetails), "Select failure while sending to Xymon daemon@%s:%d", rcptip, rcptport);
result = XYMONSEND_ESELFAILED;
goto done;
}
else if (res == 0) {
/* Timeout! */
shutdown(sockfd, SHUT_RDWR);
close(sockfd);
if (!isconnected && (connretries > 0)) {
dbgprintf("Timeout while talking to Xymon daemon@%s:%d - retrying\n", rcptip, rcptport);
connretries--;
sleep(1);
goto retry_connect; /* Yuck! */
}
result = XYMONSEND_ETIMEOUT;
goto done;
}
else {
if (!isconnected) {
/* Havent seen our connect() status yet - must be now */
int connres;
socklen_t connressize = sizeof(connres);
res = getsockopt(sockfd, SOL_SOCKET, SO_ERROR, &connres, &connressize);
dbgprintf("Connect status is %d\n", connres);
isconnected = (connres == 0);
if (!isconnected) {
sprintf(errordetails+strlen(errordetails), "Could not connect to Xymon daemon@%s:%d (%s)",
rcptip, rcptport, strerror(connres));
result = XYMONSEND_ECONNFAILED;
goto done;
}
}
if (!rdone && FD_ISSET(sockfd, &readfds)) {
char *outp;
int n;
n = recv(sockfd, recvbuf, sizeof(recvbuf)-1, 0);
if (n > 0) {
dbgprintf("Read %d bytes\n", n);
recvbuf[n] = '\0';
/*
* When running over a HTTP transport, we must strip
* off the HTTP headers we get back, so the response
* is consistent with what we get from the normal Xymon daemon
* transport.
* (Non-http transport sets "haveseenhttphdrs" to 1)
*/
if (!haveseenhttphdrs) {
outp = strstr(recvbuf, "\r\n\r\n");
if (outp) {
outp += 4;
n -= (outp - recvbuf);
haveseenhttphdrs = 1;
}
else n = 0;
}
else outp = recvbuf;
if (n > 0) {
if (respfd) {
fwrite(outp, n, 1, respfd);
}
else if (respstr) {
char *respend;
if (respstrsz == 0) {
respstrsz = (n+sizeof(recvbuf));
*respstr = (char *)malloc(respstrsz);
}
else if ((n+respstrlen) >= respstrsz) {
respstrsz += (n+sizeof(recvbuf));
*respstr = (char *)realloc(*respstr, respstrsz);
}
respend = (*respstr) + respstrlen;
memcpy(respend, outp, n);
*(respend + n) = '\0';
respstrlen += n;
}
if (!fullresponse) {
rdone = (strchr(outp, '\n') == NULL);
}
}
}
else rdone = 1;
if (rdone) shutdown(sockfd, SHUT_RD);
}
if (!wdone && FD_ISSET(sockfd, &writefds)) {
/* Send some data */
res = write(sockfd, msgptr, strlen(msgptr));
if (res == -1) {
sprintf(errordetails+strlen(errordetails), "Write error while sending message to Xymon daemon@%s:%d", rcptip, rcptport);
result = XYMONSEND_EWRITEERROR;
goto done;
}
else {
dbgprintf("Sent %d bytes\n", res);
msgptr += res;
wdone = (strlen(msgptr) == 0);
if (wdone) shutdown(sockfd, SHUT_WR);
}
}
}
}
done:
dbgprintf("Closing connection\n");
shutdown(sockfd, SHUT_RDWR);
if (sockfd > 0) close(sockfd);
xfree(rcptip);
if (httpmessage) xfree(httpmessage);
return result;
}
