int
VSS_open(const char *str, double tmo)
{
int retval = -1;
int nvaddr, n, i;
struct vss_addr **vaddr;
struct pollfd pfd;
nvaddr = VSS_resolve(str, NULL, &vaddr);
for (n = 0; n < nvaddr; n++) {
retval = VSS_connect(vaddr[n], tmo != 0.0);
if (retval >= 0 && tmo != 0.0) {
pfd.fd = retval;
pfd.events = POLLOUT;
i = poll(&pfd, 1, tmo * 1e3);
if (i == 0 || pfd.revents != POLLOUT) {
(void)close(retval);
retval = -1;
}
}
if (retval >= 0)
break;
}
for (n = 0; n < nvaddr; n++)
free(vaddr[n]);
free(vaddr);
return (retval);
}
/* Initiate a connection to <address> by resolving the
* hostname and returning a struct with necessary
* connection info.
*/
static struct vss_addr *
init_connection(const char *address)
{
struct vss_addr **ta;
struct vss_addr *tap;
char *addr, *port;
int i, n;
if (VSS_parse(address, &addr, &port) != 0) {
thread_log(0, 0, "Invalid address");
exit(2);
}
n = VSS_resolve(addr, port, &ta);
free(addr);
free(port);
if (n == 0) {
thread_log(0, 0, "Could not connect to server");
exit(2);
}
for (i = 1; i < n; ++i) {
free(ta[i]);
ta[i] = NULL;
}
tap = ta[0];
free(ta);
return (tap);
}
static void
server_start(struct vmod_fsdirector_file_system *fs)
{
struct vdi_simple *vs;
const struct vrt_backend *be;
vs = fs->vs;
be = vs->vrt;
AN(VSS_resolve(be->ipv4_addr, be->port, &fs->vss_addr));
fs->sock = VSS_listen(fs->vss_addr[0], be->max_connections);
assert(fs->sock >= 0);
WRK_BgThread(&fs->tp, fs->thread_name, server_bgthread, fs);
}
void
mgt_cli_telnet(const char *T_arg)
{
struct vss_addr **ta;
int i, n, sock, good;
struct telnet *tn;
char *p;
struct vsb *vsb;
char abuf[VTCP_ADDRBUFSIZE];
char pbuf[VTCP_PORTBUFSIZE];
n = VSS_resolve(T_arg, NULL, &ta);
if (n == 0) {
REPORT(LOG_ERR, "-T %s Could not be resolved\n", T_arg);
exit(2);
}
good = 0;
vsb = VSB_new_auto();
XXXAN(vsb);
for (i = 0; i < n; ++i) {
sock = VSS_listen(ta[i], 10);
if (sock < 0)
continue;
VTCP_myname(sock, abuf, sizeof abuf, pbuf, sizeof pbuf);
VSB_printf(vsb, "%s %s\n", abuf, pbuf);
good++;
tn = telnet_new(sock);
tn->ev = vev_new();
XXXAN(tn->ev);
tn->ev->fd = sock;
tn->ev->fd_flags = POLLIN;
tn->ev->callback = telnet_accept;
AZ(vev_add(mgt_evb, tn->ev));
free(ta[i]);
ta[i] = NULL;
}
free(ta);
if (good == 0) {
REPORT(LOG_ERR, "-T %s could not be listened on.", T_arg);
exit(2);
}
AZ(VSB_finish(vsb));
/* Save in shmem */
p = VSM_Alloc(VSB_len(vsb) + 1, "Arg", "-T", "");
AN(p);
strcpy(p, VSB_data(vsb));
VSB_delete(vsb);
}
void
mgt_cli_master(const char *M_arg)
{
(void)M_arg;
M_nta = VSS_resolve(M_arg, NULL, &M_ta);
if (M_nta <= 0) {
fprintf(stderr, "Could resolve -M argument to address\n");
exit (1);
}
M_nxt = 0;
AZ(M_poker);
M_poker = vev_new();
AN(M_poker);
M_poker->timeout = M_poll;
M_poker->callback = Marg_poker;
M_poker->name = "-M poker";
AZ(vev_add(mgt_evb, M_poker));
}
/* Initiate a connection to <address> by resolving the
* hostname and returning a struct with necessary
* connection info.
*/
static struct vss_addr *
init_connection(const char *address)
{
struct vss_addr **ta;
struct vss_addr *tap;
int i, n;
n = VSS_resolve(address, NULL, &ta);
if (n == 0) {
thread_log(0, 0, "Could not connect to server");
exit(2);
}
for (i = 1; i < n; ++i) {
free(ta[i]);
ta[i] = NULL;
}
tap = ta[0];
free(ta);
return (tap);
}
static void
varnish_launch(struct varnish *v)
{
struct vsb *vsb, *vsb1;
int i, nfd, nap;
struct vss_addr **ap;
char abuf[128], pbuf[128];
struct pollfd fd[2];
enum VCLI_status_e u;
char *r;
v->vd = VSM_New();
VSC_Setup(v->vd);
/* Create listener socket */
nap = VSS_resolve("127.0.0.1", "0", &ap);
AN(nap);
v->cli_fd = VSS_listen(ap[0], 1);
VTCP_myname(v->cli_fd, abuf, sizeof abuf, pbuf, sizeof pbuf);
AZ(VSB_finish(v->args));
vtc_log(v->vl, 2, "Launch");
vsb = VSB_new_auto();
AN(vsb);
VSB_printf(vsb, "cd ${pwd} &&");
VSB_printf(vsb, " ${varnishd} -d -d -n %s", v->workdir);
VSB_printf(vsb, " -l 10m,1m,-");
VSB_printf(vsb, " -p auto_restart=off");
VSB_printf(vsb, " -p syslog_cli_traffic=off");
VSB_printf(vsb, " -a '%s'", "127.0.0.1:0");
VSB_printf(vsb, " -S %s/_S", v->workdir);
VSB_printf(vsb, " -M '%s %s'", abuf, pbuf);
VSB_printf(vsb, " -P %s/varnishd.pid", v->workdir);
VSB_printf(vsb, " %s", VSB_data(v->storage));
VSB_printf(vsb, " %s", VSB_data(v->args));
AZ(VSB_finish(vsb));
vtc_log(v->vl, 3, "CMD: %s", VSB_data(vsb));
vsb1 = macro_expand(v->vl, VSB_data(vsb));
AN(vsb1);
VSB_delete(vsb);
vsb = vsb1;
vtc_log(v->vl, 3, "CMD: %s", VSB_data(vsb));
AZ(pipe(&v->fds[0]));
AZ(pipe(&v->fds[2]));
v->pid = fork();
assert(v->pid >= 0);
if (v->pid == 0) {
assert(dup2(v->fds[0], 0) == 0);
assert(dup2(v->fds[3], 1) == 1);
assert(dup2(1, 2) == 2);
AZ(close(v->fds[0]));
AZ(close(v->fds[1]));
AZ(close(v->fds[2]));
AZ(close(v->fds[3]));
for (i = 3; i <getdtablesize(); i++)
(void)close(i);
AZ(execl("/bin/sh", "/bin/sh", "-c", VSB_data(vsb), (char*)0));
exit(1);
} else {
vtc_log(v->vl, 3, "PID: %ld", (long)v->pid);
}
AZ(close(v->fds[0]));
AZ(close(v->fds[3]));
v->fds[0] = v->fds[2];
v->fds[2] = v->fds[3] = -1;
VSB_delete(vsb);
AZ(pthread_create(&v->tp, NULL, varnish_thread, v));
AZ(pthread_create(&v->tp_vsl, NULL, varnishlog_thread, v));
/* Wait for the varnish to call home */
memset(fd, 0, sizeof fd);
fd[0].fd = v->cli_fd;
fd[0].events = POLLIN;
fd[1].fd = v->fds[0];
fd[1].events = 0; /* Only care about POLLHUP, which is output-only */
i = poll(fd, 2, 10000);
vtc_log(v->vl, 4, "CLIPOLL %d 0x%x 0x%x",
i, fd[0].revents, fd[1].revents);
if (i == 0) {
vtc_log(v->vl, 0, "FAIL timeout waiting for CLI connection");
return;
}
if (fd[1].revents & POLLHUP) {
vtc_log(v->vl, 0, "FAIL debug pipe closed");
return;
}
if (!(fd[0].revents & POLLIN)) {
vtc_log(v->vl, 0, "FAIL CLI connection wait failure");
return;
}
nfd = accept(v->cli_fd, NULL, NULL);
if (nfd < 0) {
vtc_log(v->vl, 0, "FAIL no CLI connection accepted");
return;
}
AZ(close(v->cli_fd));
v->cli_fd = nfd;
vtc_log(v->vl, 3, "CLI connection fd = %d", v->cli_fd);
assert(v->cli_fd >= 0);
/* Receive the banner or auth response */
u = varnish_ask_cli(v, NULL, &r);
if (vtc_error)
return;
if (u != CLIS_AUTH)
vtc_log(v->vl, 0, "CLI auth demand expected: %u %s", u, r);
bprintf(abuf, "%s/_S", v->workdir);
nfd = open(abuf, O_RDONLY);
assert(nfd >= 0);
assert(sizeof abuf >= CLI_AUTH_RESPONSE_LEN + 7);
strcpy(abuf, "auth ");
VCLI_AuthResponse(nfd, r, abuf + 5);
AZ(close(nfd));
free(r);
strcat(abuf, "\n");
u = varnish_ask_cli(v, abuf, &r);
if (vtc_error)
return;
if (u != CLIS_OK)
vtc_log(v->vl, 0, "CLI auth command failed: %u %s", u, r);
free(r);
(void)VSL_Arg(v->vd, 'n', v->workdir);
AZ(VSC_Open(v->vd, 1));
}