/*
* Called everytime new data is read from any of the connections
* that are part of a pipe.
*/
static int
ktunnel_pipe_data(struct netbuf *nb)
{
struct connection *src = nb->owner;
struct connection *dst = src->hdlr_extra;
printf("received %d bytes on pipe %p (-> %p)\n", nb->s_off, src, dst);
net_send_queue(dst, nb->buf, nb->s_off, NULL, NETBUF_LAST_CHAIN);
net_send_flush(dst);
net_recv_reset(src, NETBUF_SEND_PAYLOAD_MAX, ktunnel_pipe_data);
return (KORE_RESULT_OK);
}
/*
* Called whenever data is available that must be piped through
* to the paired connection. (client<>backend or backend<>client).
*/
int
pipe_data(struct netbuf *nb)
{
struct connection *src = nb->owner;
struct connection *dst = src->hdlr_extra;
/* Flush data out towards destination. */
net_send_queue(dst, nb->buf, nb->s_off);
net_send_flush(dst);
/* Reset read for source. */
net_recv_reset(src, NETBUF_SEND_PAYLOAD_MAX, pipe_data);
return (KORE_RESULT_OK);
}
/*
* This function is called everytime we get up to 128 bytes of data.
* The connection can be found under nb->owner.
* The data received can be found under nb->buf.
* The length of the received data can be found under s_off.
*/
int
connection_recv_data(struct netbuf *nb)
{
struct connection *c = (struct connection *)nb->owner;
kore_log(LOG_NOTICE, "%p: received %u bytes", c, nb->s_off);
/* We will just dump these back to the client. */
net_send_queue(c, nb->buf, nb->s_off);
net_send_flush(c);
/* Now reset the receive command for the next one. */
net_recv_reset(c, 128, connection_recv_data);
return (KORE_RESULT_OK);
}
/*
* Connect to our target host:port and attach it to a struct connection that
* Kore understands. We set the disconnect method so we get a callback
* whenever either of the connections will go away so we can cleanup the
* one it is attached to.
*/
static int
ktunnel_pipe_create(struct connection *c, const char *host, const char *port)
{
struct sockaddr_in sin;
struct connection *cpipe;
u_int16_t nport;
int fd, err;
nport = kore_strtonum(port, 10, 1, SHRT_MAX, &err);
if (err == KORE_RESULT_ERROR) {
kore_log(LOG_ERR, "invalid port given %s", port);
return (KORE_RESULT_ERROR);
}
if ((fd = socket(AF_INET, SOCK_STREAM, 0)) == -1) {
kore_log(LOG_ERR, "socket(): %s", errno_s);
return (KORE_RESULT_ERROR);
}
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(nport);
sin.sin_addr.s_addr = inet_addr(host);
kore_log(LOG_NOTICE, "Attempting to connect to %s:%s", host, port);
if (connect(fd, (struct sockaddr *)&sin, sizeof(sin)) == -1) {
close(fd);
kore_log(LOG_ERR, "connect(): %s", errno_s);
return (KORE_RESULT_ERROR);
}
if (!kore_connection_nonblock(fd)) {
close(fd);
return (KORE_RESULT_ERROR);
}
cpipe = kore_connection_new(c);
cpipe->fd = fd;
cpipe->addr.ipv4 = sin;
cpipe->read = net_read;
cpipe->write = net_write;
cpipe->addrtype = AF_INET;
cpipe->proto = CONN_PROTO_UNKNOWN;
cpipe->state = CONN_STATE_ESTABLISHED;
/* Don't let these connections timeout any time soon. */
cpipe->idle_timer.length = 10000000000;
c->idle_timer.length = 10000000000;
c->hdlr_extra = cpipe;
cpipe->hdlr_extra = c;
c->disconnect = ktunnel_pipe_disconnect;
cpipe->disconnect = ktunnel_pipe_disconnect;
kore_worker_connection_add(cpipe);
kore_connection_start_idletimer(cpipe);
kore_platform_event_all(cpipe->fd, cpipe);
net_recv_reset(c, NETBUF_SEND_PAYLOAD_MAX, ktunnel_pipe_data);
net_recv_queue(cpipe, NETBUF_SEND_PAYLOAD_MAX, NETBUF_CALL_CB_ALWAYS,
ktunnel_pipe_data);
printf("connection started to %s (%p -> %p)\n", host, c, cpipe);
return (KORE_RESULT_OK);
}
