struct fwtcp *
fwtcp_create(struct fwspec *fwspec)
{
struct fwtcp *fwtcp;
SOCKET lsock;
int status;
err_t error;
lsock = proxy_bound_socket(fwspec->sdom, fwspec->stype, &fwspec->src.sa);
if (lsock == INVALID_SOCKET) {
perror("socket");
return NULL;
}
fwtcp = (struct fwtcp *)malloc(sizeof(*fwtcp));
if (fwtcp == NULL) {
closesocket(lsock);
return NULL;
}
fwtcp->pmhdl.callback = fwtcp_pmgr_listen;
fwtcp->pmhdl.data = (void *)fwtcp;
fwtcp->pmhdl.slot = -1;
fwtcp->sock = lsock;
fwtcp->fwspec = *fwspec; /* struct copy */
error = sys_mbox_new(&fwtcp->connmbox, 16);
if (error != ERR_OK) {
closesocket(lsock);
free(fwtcp);
return (NULL);
}
#define CALLBACK_MSG(MSG, FUNC) \
do { \
fwtcp->MSG.type = TCPIP_MSG_CALLBACK_STATIC; \
fwtcp->MSG.sem = NULL; \
fwtcp->MSG.msg.cb.function = FUNC; \
fwtcp->MSG.msg.cb.ctx = (void *)fwtcp; \
} while (0)
CALLBACK_MSG(msg_connect, fwtcp_pcb_connect);
CALLBACK_MSG(msg_delete, fwtcp_pcb_delete);
#undef CALLBACK_MSG
status = pollmgr_add(&fwtcp->pmhdl, fwtcp->sock, POLLIN);
if (status < 0) {
sys_mbox_free(&fwtcp->connmbox);
closesocket(lsock);
free(fwtcp);
return NULL;
}
fwtcp->next = fwtcp_list;
fwtcp_list = fwtcp;
return fwtcp;
}
/**
* POLLMGR_CHAN_PXUDP_ADD handler.
*
* Get new pxudp from lwip thread and start polling its socket.
*/
static int
pxudp_pmgr_chan_add(struct pollmgr_handler *handler, SOCKET fd, int revents)
{
struct pxudp *pxudp;
int status;
pxudp = pxudp_chan_recv(handler, fd, revents);
DPRINTF(("pxudp_add: new pxudp %p; pcb %p\n",
(void *)pxudp, (void *)pxudp->pcb));
LWIP_ASSERT1(pxudp != NULL);
LWIP_ASSERT1(pxudp->pmhdl.callback != NULL);
LWIP_ASSERT1(pxudp->pmhdl.data = (void *)pxudp);
LWIP_ASSERT1(pxudp->pmhdl.slot < 0);
status = pollmgr_add(&pxudp->pmhdl, pxudp->sock, POLLIN);
if (status < 0) {
pxudp_schedule_delete(pxudp);
}
return POLLIN;
}
struct fwudp *
fwudp_create(struct fwspec *fwspec)
{
struct fwudp *fwudp;
SOCKET sock;
int status;
sock = proxy_bound_socket(fwspec->sdom, fwspec->stype, &fwspec->src.sa);
if (sock == INVALID_SOCKET) {
perror("socket");
return NULL;
}
fwudp = (struct fwudp *)malloc(sizeof(*fwudp));
if (fwudp == NULL) {
closesocket(sock);
return NULL;
}
fwudp->pmhdl.callback = fwudp_pmgr_pump;
fwudp->pmhdl.data = (void *)fwudp;
fwudp->pmhdl.slot = -1;
fwudp->sock = sock;
fwudp->fwspec = *fwspec; /* struct copy */
/* XXX */
if (fwspec->sdom == PF_INET) {
struct sockaddr_in *dst4 = &fwspec->dst.sin;
memcpy(&fwudp->dst_addr.ip4, &dst4->sin_addr, sizeof(ip_addr_t));
fwudp->dst_port = htons(dst4->sin_port);
}
else { /* PF_INET6 */
struct sockaddr_in6 *dst6 = &fwspec->dst.sin6;
memcpy(&fwudp->dst_addr.ip6, &dst6->sin6_addr, sizeof(ip6_addr_t));
fwudp->dst_port = htons(dst6->sin6_port);
}
fwudp->inbuf.bufsize = 256; /* elements */
fwudp->inbuf.buf
= (struct fwudp_dgram *)calloc(fwudp->inbuf.bufsize,
sizeof(struct fwudp_dgram));
if (fwudp->inbuf.buf == NULL) {
closesocket(sock);
free(fwudp);
return (NULL);
}
fwudp->inbuf.vacant = 0;
fwudp->inbuf.unsent = 0;
#define CALLBACK_MSG(MSG, FUNC) \
do { \
fwudp->MSG.type = TCPIP_MSG_CALLBACK_STATIC; \
fwudp->MSG.sem = NULL; \
fwudp->MSG.msg.cb.function = FUNC; \
fwudp->MSG.msg.cb.ctx = (void *)fwudp; \
} while (0)
CALLBACK_MSG(msg_send, fwudp_pcb_send);
CALLBACK_MSG(msg_delete, fwudp_pcb_delete);
#undef CALLBACK_MSG
status = pollmgr_add(&fwudp->pmhdl, fwudp->sock, POLLIN);
if (status < 0) {
closesocket(sock);
free(fwudp->inbuf.buf);
free(fwudp);
return NULL;
}
fwudp->next = fwudp_list;
fwudp_list = fwudp;
return fwudp;
}
err_t
pxdns_init(struct netif *proxy_netif)
{
struct pxdns *pxdns = &g_pxdns;
err_t error;
LWIP_UNUSED_ARG(proxy_netif);
pxdns->pmhdl4.callback = pxdns_pmgr_pump;
pxdns->pmhdl4.data = (void *)pxdns;
pxdns->pmhdl4.slot = -1;
pxdns->pmhdl6.callback = pxdns_pmgr_pump;
pxdns->pmhdl6.data = (void *)pxdns;
pxdns->pmhdl6.slot = -1;
pxdns->pcb4 = udp_new();
if (pxdns->pcb4 == NULL) {
error = ERR_MEM;
goto err_cleanup_pcb;
}
pxdns->pcb6 = udp_new_ip6();
if (pxdns->pcb6 == NULL) {
error = ERR_MEM;
goto err_cleanup_pcb;
}
error = udp_bind(pxdns->pcb4, IP_ADDR_ANY, 53);
if (error != ERR_OK) {
goto err_cleanup_pcb;
}
error = udp_bind_ip6(pxdns->pcb6, IP6_ADDR_ANY, 53);
if (error != ERR_OK) {
goto err_cleanup_pcb;
}
udp_recv(pxdns->pcb4, pxdns_recv4, pxdns);
udp_recv_ip6(pxdns->pcb6, pxdns_recv6, pxdns);
pxdns->sock4 = socket(AF_INET, SOCK_DGRAM, 0);
if (pxdns->sock4 == INVALID_SOCKET) {
goto err_cleanup_pcb;
}
pxdns->sock6 = socket(AF_INET6, SOCK_DGRAM, 0);
if (pxdns->sock6 == INVALID_SOCKET) {
/* it's ok if the host doesn't support IPv6 */
/* XXX: TODO: log */
}
pxdns->generation = 0;
pxdns->nresolvers = 0;
pxdns->resolvers = NULL;
pxdns_create_resolver_sockaddrs(pxdns, g_proxy_options->nameservers);
sys_mutex_new(&pxdns->lock);
pxdns->timeout_slot = 0;
pxdns->timeout_mask = 0;
/* NB: assumes pollmgr thread is not running yet */
pollmgr_add(&pxdns->pmhdl4, pxdns->sock4, POLLIN);
if (pxdns->sock6 != INVALID_SOCKET) {
pollmgr_add(&pxdns->pmhdl6, pxdns->sock6, POLLIN);
}
return ERR_OK;
err_cleanup_pcb:
if (pxdns->pcb4 != NULL) {
udp_remove(pxdns->pcb4);
pxdns->pcb4 = NULL;
}
if (pxdns->pcb6 != NULL) {
udp_remove(pxdns->pcb6);
pxdns->pcb4 = NULL;
}
return error;
}
