c-utils/tcp_utils.c at main · vfjpl/c-utils · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
#include "tcp_utils.h"
#include <stdlib.h>
#include <stdio.h>
#include <fcntl.h>

///https://en.wikipedia.org/wiki/Berkeley_sockets

int tcp_client_connect(const char* host, const char* port)
{
	struct addrinfo* list = NULL;
	struct addrinfo hints = {0};
	hints.ai_flags = 0;
	hints.ai_family = PF_INET;
	hints.ai_socktype = SOCK_STREAM;
	hints.ai_protocol = IPPROTO_TCP;

	int retval = getaddrinfo(host, port, &hints, &list);
	if(retval != 0)
	{
		return -abs(retval);
	}

	for(struct addrinfo* ptr = list; ptr != NULL; ptr = ptr->ai_next)
	{
		retval = socket(ptr->ai_family, ptr->ai_socktype, ptr->ai_protocol);
		if(retval < 0)
		{
			continue;
		}
		if(fcntl(retval, F_SETFD, FD_CLOEXEC) < 0)
		{
			close(retval);
			continue;
		}
		if(connect(retval, ptr->ai_addr, ptr->ai_addrlen) < 0)
		{
			close(retval);
			continue;
		}

		freeaddrinfo(list);
		return retval;
	}

	freeaddrinfo(list);
	return -abs(EAI_SYSTEM);
}

int tcp_client_connect_u16(const char* host, uint16_t port)
{
	char buff[16];
	sprintf(buff, "%hu", port);
	return tcp_client_connect(host, buff);
}


int tcp_server_create(uint16_t port, bool set_O_NONBLOCK)
{
	int opt = 1;
	struct sockaddr_in addr = {0};
	addr.sin_family = AF_INET;
	addr.sin_port = htons(port);
	addr.sin_addr.s_addr = htonl(INADDR_ANY);

	int server_fd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
	if(server_fd < 0)
	{
		return -1;
	}
	if(fcntl(server_fd, F_SETFD, FD_CLOEXEC) < 0)
	{
		close(server_fd);
		return -1;
	}
	if(setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0)
	{
		close(server_fd);
		return -1;
	}
	if(bind(server_fd, (struct sockaddr*)&addr, sizeof(addr)) < 0)
	{
		close(server_fd);
		return -1;
	}
	if(listen(server_fd, 1) < 0)
	{
		close(server_fd);
		return -1;
	}
	if(set_O_NONBLOCK && fcntl(server_fd, F_SETFL, O_NDELAY) < 0)
	{
		close(server_fd);
		return -1;
	}

	return server_fd;
}

int tcp_server_accept(int server_fd, struct sockaddr* addr, socklen_t* addrlen, bool set_O_NONBLOCK)
{
	int client_fd = accept(server_fd, addr, addrlen);
	if(client_fd < 0)
	{
		return -1;
	}
	if(fcntl(client_fd, F_SETFD, FD_CLOEXEC) < 0)
	{
		close(client_fd);
		return -1;
	}
	if(set_O_NONBLOCK && fcntl(client_fd, F_SETFL, O_NDELAY) < 0)
	{
		close(client_fd);
		return -1;
	}

	return client_fd;
}