rohrpost

net.c (6386B)

---

 /*
  * Copy me if you can.
  * by 20h
  */
 
 #include <unistd.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdarg.h>
 #include <string.h>
 #include <strings.h>
 #include <poll.h>
 #include <arpa/inet.h>
 #include <netinet/in.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netdb.h>
 
 #include <tls.h>
 
 #include "ind.h"
 #include "net.h"
 
 /*
  * net format:
  *	net!addr!service
  */
 enum {
 	NET_NET = 0x00,
 	NET_TCP,
 	NET_TCPS
 };
 static char *netnames[] = {
 	[NET_NET] = "net",
 	[NET_TCP] = "tcp",
 	[NET_TCPS] = "tcps"
 };
 
 int
 net_gettype(char *str)
 {
 	int i;
 
 	for (i = 0; i < nelem(netnames); i++)
 		if (!strcmp(netnames[i], str))
 			return i;
 	return -1;
 }
 
 net_t *
 net_new(char *desc)
 {
 	net_t *ret;
 	int state;
 	char *tok, *buf, *toks;
 
 	state = -1;
 	toks = NULL;
 	ret = NULL;
 	buf = memdup(desc, strlen(desc)+1);
 
 	tok = strtok_r(buf, "!", &toks);
 	if (tok == NULL)
 		goto netnewerror;
 
 	ret = mallocz(sizeof(net_t), 2);
 	do {
 		state++;
 		switch(state) {
 		case 0:
 			ret->net = memdup(tok, strlen(tok)+1);
 			ret->type = net_gettype(ret->net);
 			break;
 		case 1:
 			ret->addr = memdup(tok, strlen(tok)+1);
 			break;
 		case 2:
 			ret->service = memdup(tok, strlen(tok)+1);
 			break;
 		case 3:
 			ret->options = memdup(tok, strlen(tok)+1);
 			break;
 		default:
 			break;
 		}
 	} while ((tok = strtok_r(NULL, "!", &toks)) != NULL);
 	if (state < 2)
 		goto netnewerror;
 	free(buf);
 
 	return ret;
 netnewerror:
 	if (buf != NULL)
 		free(buf);
 
 	switch (state) {
 	case 1:
 		free(ret->addr);
 	case 0:
 		free(ret->net);
 	default:
 		break;
 	}
 	if (ret != NULL)
 		free(ret);
 
 	return NULL;
 }
 
 void
 net_free(net_t *net)
 {
 	switch (net->type) {
 	case NET_TCPS:
 		tls_free((struct tls *)net->data[0]);
 		tls_config_free((struct tls_config *)net->data[1]);
 	}
 
 	if (net->net != NULL)
 		free(net->net);
 	if (net->addr != NULL)
 		free(net->addr);
 	if (net->service != NULL)
 		free(net->service);
 	free(net);
 }
 
 int
 net_connecttcp(net_t *net)
 {
 	struct addrinfo hints, *ai, *rp;
 
 	memset(&hints, 0, sizeof(hints));
 	/*
 	 * Anyone knowing a real check for IPv6, instead of failing
 	 * everything, should contact me.
 	 */
 	hints.ai_family = AF_UNSPEC;
 	hints.ai_socktype = SOCK_STREAM;
 	hints.ai_protocol = IPPROTO_TCP;
 	if (getaddrinfo(net->addr, net->service, &hints, &ai))
 		return 1;
 	if (ai == NULL)
 		return 1;
 
 	for (rp = ai; rp != NULL; rp = rp->ai_next) {
 		net->fd = socket(rp->ai_family, rp->ai_socktype,
 				rp->ai_protocol);
 		if (net->fd < 0)
 			continue;
 		if (!connect(net->fd, rp->ai_addr, rp->ai_addrlen))
 			break;
 		close(net->fd);
 	}
 	if (rp == NULL)
 		return 1;
 	freeaddrinfo(ai);
 
 	return 0;
 }
 
 int
 net_addssl(net_t *net)
 {
 	struct tls *tls = NULL;
 	struct tls_config *config = NULL;
 
 	if (tls_init() < 0)
 		return 1;
 	if ((tls = tls_client()) == NULL)
 		return 1;
 	if ((config = tls_config_new()) == NULL) {
 		tls_free(tls);
 		return 1;
 	}
 
 	if (net->options != NULL) {
 		if (strstr(net->options, "tlscertverify=off"))
 			tls_config_insecure_noverifycert(config);
 		if (strstr(net->options, "tlsnameverify=off"))
 			tls_config_insecure_noverifyname(config);
 	}
 
 	if (tls_configure(tls, config) < 0) {
 		fprintf(stderr, "tls_configure: %s\n", tls_error(tls));
 		tls_free(tls);
 		tls_config_free(config);
 		return 1;
 	}
 
 	if (tls_connect_socket(tls, net->fd, net->addr) < 0) {
 		fprintf(stderr, "tls_connect_socket: %s\n", tls_error(tls));
 		tls_free(tls);
 		tls_config_free(config);
 		return 1;
 	}
 
 	switch (net->type) {
 	case NET_NET:
 	case NET_TCP:
 		free(net->net);
 		net->net = memdup("tcps", 5);
 		net->type = net_gettype(net->net);
 	case NET_TCPS:
 	default:
 		break;
 	}
 
 	net->data[0] = tls;
 	net->data[1] = config;
 
 	return 0;
 }
 
 int
 net_connecttcps(net_t *net)
 {
 	if (net_connecttcp(net))
 		return 1;
 	if (net_addssl(net))
 		return 1;
 
 	return 0;
 }
 
 int
 net_connect(net_t *net)
 {
 	switch (net->type) {
 	case NET_NET:
 	case NET_TCP:
 		return net_connecttcp(net);
 	case NET_TCPS:
 		return net_connecttcps(net);
 	default:
 		return 1;
 	}
 	return 0;
 }
 
 void
 net_closetcp(net_t *net)
 {
 	shutdown(net->fd, SHUT_RDWR);
 	close(net->fd);
 }
 
 void
 net_closetcps(net_t *net)
 {
 	tls_close((struct tls *)net->data[0]);
 }
 
 void
 net_close(net_t *net)
 {
 	switch (net->type) {
 	case NET_NET:
 	case NET_TCP:
 		net_closetcp(net);
 	case NET_TCPS:
 		net_closetcps(net);
 	default:
 		break;
 	}
 }
 
 int
 net_writetcp(net_t *net, char *buf, int len)
 {
 	return send(net->fd, buf, len, MSG_NOSIGNAL);
 }
 
 int
 net_writetcps(net_t *net, char *buf, int len)
 {
 	int r = TLS_WANT_POLLIN;
 
 	while (r == TLS_WANT_POLLIN || r == TLS_WANT_POLLOUT)
 		r = tls_write((struct tls *)net->data[0], buf, len);
 
 	return r;
 }
 
 int
 net_write(net_t *net, char *buf, int len)
 {
 	switch (net->type) {
 	case NET_NET:
 	case NET_TCP:
 		return net_writetcp(net, buf, len);
 	case NET_TCPS:
 		return net_writetcps(net, buf, len);
 	default:
 		return -1;
 	}
 	return -1;
 }
 
 int
 net_writeall(net_t *net, char *buf, int len)
 {
 	int olen, nlen;
 
 	for (olen = 0;
 			(nlen = net_write(net, &buf[olen], len-olen)) >= 0
 			&& olen < len;
 			olen += nlen);
 
 	return 0;
 }
 
 int
 net_printf(net_t *net, char *fmt, ...)
 {
 	va_list fmtargs;
 	char *buf;
 	int len;
 
 	va_start(fmtargs, fmt);
 	len = vsnprintf(NULL, 0, fmt, fmtargs);
 	va_end(fmtargs);
 
 	va_start(fmtargs, fmt);
 	buf = vsmprintf(fmt, fmtargs, len);
 	va_end(fmtargs);
 
 	len = net_writeall(net, buf, strlen(buf));
 	free(buf);
 	return len;
 }
 
 int
 net_readtcp(net_t *net, char *buf, int len)
 {
 	return recv(net->fd, buf, len, 0);
 }
 
 int
 net_readtcps(net_t *net, char *buf, int len)
 {
 	int r = TLS_WANT_POLLIN;
 
 	while (r == TLS_WANT_POLLIN || r == TLS_WANT_POLLOUT)
 		r = tls_read((struct tls *)net->data[0], buf, len);
 
 	return r;
 }
 
 int
 net_read(net_t *net, char *buf, int len)
 {
 	switch (net->type) {
 	case NET_NET:
 	case NET_TCP:
 		return net_readtcp(net, buf, len);
 	case NET_TCPS:
 		return net_readtcps(net, buf, len);
 	default:
 		return -1;
 	}
 	return -1;
 }
 
 int
 net_readall(net_t *net, char *buf, int len)
 {
 	int olen, nlen;
 
 	for (olen = 0;
 			(nlen = net_read(net, &buf[olen], len-olen))
 			&& olen < len;
 			olen += nlen);
 
 	return 0;
 }
 
 char *
 net_gets(net_t *net)
 {
 	char *ret;
 	int len;
 
 	len = 1;
 	ret = mallocz(len, 2);
 	while (net_read(net, &ret[len-1], 1) > 0 && ret[len-1] != '\n'
 			&& len < MAXLINESIZE)
 		ret = reallocz(ret, ++len + 1, 0);
 	/*
 	if (ret[len-1] != '\n') {
 		free(ret);
 		return NULL;
 	}
 	ret[len-1] = '\0';
 	*/
 	ret[len] = '\0';
 
 	return ret;
 }