kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
efl/src/lib/ecore_con/efl_net_server_tcp.c

290 lines
7.8 KiB
C
Raw Normal View History

efl.net: socket, server and dialer for TCP. Efl.Net.Server defines how to accept new connections, doing the bind(), listen() and accept() for protocols such as TCP. Efl.Net.Dialer defines to to reach a server. Both are based on Efl.Net.Socket as communication interface that is based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being usable with code such as Efl.Io.Copier. The Server will emit an event "client,add" with the established Socket, which is a child and can be closed by both the server or the user. The Dialer extends the Socket and allows for creating one given an address, that will be resolved and connected. TCP is the initial implementation so we an validate the interfaces. UDP, Unix-Local and SSL will come later as derivate classes. The examples are documented and should cover the basic principles: - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a "netcat", can send data from socket, file or stdin to a socket, file, stdout or stderr. - efl_net_server_example listens for connections and can either reply "Hello World!" and take some data or work as an echo-server, looping back all received data to the user. More complex interactions that require a "chat" between client and server will be covered with new classes later, such as a queue that empties itself once data is read.
2016-08-17 21:53:16 -07:00
#define EFL_NET_SERVER_TCP_PROTECTED 1
#define EFL_NET_SERVER_FD_PROTECTED 1
#define EFL_NET_SERVER_PROTECTED 1
#define EFL_LOOP_FD_PROTECTED 1
#ifdef HAVE_CONFIG_H
# include <config.h>
#endif
#include "Ecore.h"
#include "Ecore_Con.h"
#include "ecore_con_private.h"
#ifdef HAVE_SYS_SOCKET_H
# include <sys/socket.h>
#endif
#ifdef HAVE_NETINET_TCP_H
# include <netinet/tcp.h>
#endif
#ifdef HAVE_NETINET_IN_H
# include <netinet/in.h>
#endif
#ifdef HAVE_ARPA_INET_H
# include <arpa/inet.h>
#endif
#ifdef HAVE_EVIL
# include <Evil.h>
#endif
#define MY_CLASS EFL_NET_SERVER_TCP_CLASS
efl_net_server_tcp: allow IPv4 over IPv6 sockets. Sometimes we want to handle both IPv4 and IPv6 in the same socket, instead of spawning 2 servers, one for each protocol. That is achieved by means of disabling IPV6_V6ONLY socket option, present in most recent platforms.
2016-10-18 16:24:16 -07:00
typedef struct _Efl_Net_Server_Tcp_Data
{
efl_net_server_tcp: use async getaddrinfo() to resolve server name. this allows nicer usage such as 'localhost:http' as the address, which will resolve to [::1]:80 (if IPv6 is enabled) or 127.0.0.1:80 if only IPv4 exists.
2016-10-20 19:15:09 -07:00
Ecore_Thread *resolver;
efl_net_server_tcp: allow IPv4 over IPv6 sockets. Sometimes we want to handle both IPv4 and IPv6 in the same socket, instead of spawning 2 servers, one for each protocol. That is achieved by means of disabling IPV6_V6ONLY socket option, present in most recent platforms.
2016-10-18 16:24:16 -07:00
Eina_Bool ipv6_only;
} Efl_Net_Server_Tcp_Data;
ipv6_only: use system default if unset. only apply the value if IPv6 && set. If unset (now 0xff), then call the getter so the property is in sync with the kernel default.
2016-10-20 15:43:02 -07:00
EOLIAN Efl_Object *
_efl_net_server_tcp_efl_object_constructor(Eo *o, Efl_Net_Server_Tcp_Data *pd)
{
pd->ipv6_only = 0xff;
return efl_constructor(efl_super(o, MY_CLASS));
}
efl_net_server_tcp: use async getaddrinfo() to resolve server name. this allows nicer usage such as 'localhost:http' as the address, which will resolve to [::1]:80 (if IPv6 is enabled) or 127.0.0.1:80 if only IPv4 exists.
2016-10-20 19:15:09 -07:00
EOLIAN void
_efl_net_server_tcp_efl_object_destructor(Eo *o, Efl_Net_Server_Tcp_Data *pd)
efl.net: socket, server and dialer for TCP. Efl.Net.Server defines how to accept new connections, doing the bind(), listen() and accept() for protocols such as TCP. Efl.Net.Dialer defines to to reach a server. Both are based on Efl.Net.Socket as communication interface that is based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being usable with code such as Efl.Io.Copier. The Server will emit an event "client,add" with the established Socket, which is a child and can be closed by both the server or the user. The Dialer extends the Socket and allows for creating one given an address, that will be resolved and connected. TCP is the initial implementation so we an validate the interfaces. UDP, Unix-Local and SSL will come later as derivate classes. The examples are documented and should cover the basic principles: - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a "netcat", can send data from socket, file or stdin to a socket, file, stdout or stderr. - efl_net_server_example listens for connections and can either reply "Hello World!" and take some data or work as an echo-server, looping back all received data to the user. More complex interactions that require a "chat" between client and server will be covered with new classes later, such as a queue that empties itself once data is read.
2016-08-17 21:53:16 -07:00
{
efl_net_server_tcp: use async getaddrinfo() to resolve server name. this allows nicer usage such as 'localhost:http' as the address, which will resolve to [::1]:80 (if IPv6 is enabled) or 127.0.0.1:80 if only IPv4 exists.
2016-10-20 19:15:09 -07:00
if (pd->resolver)
efl.net: socket, server and dialer for TCP. Efl.Net.Server defines how to accept new connections, doing the bind(), listen() and accept() for protocols such as TCP. Efl.Net.Dialer defines to to reach a server. Both are based on Efl.Net.Socket as communication interface that is based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being usable with code such as Efl.Io.Copier. The Server will emit an event "client,add" with the established Socket, which is a child and can be closed by both the server or the user. The Dialer extends the Socket and allows for creating one given an address, that will be resolved and connected. TCP is the initial implementation so we an validate the interfaces. UDP, Unix-Local and SSL will come later as derivate classes. The examples are documented and should cover the basic principles: - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a "netcat", can send data from socket, file or stdin to a socket, file, stdout or stderr. - efl_net_server_example listens for connections and can either reply "Hello World!" and take some data or work as an echo-server, looping back all received data to the user. More complex interactions that require a "chat" between client and server will be covered with new classes later, such as a queue that empties itself once data is read.
2016-08-17 21:53:16 -07:00
{
efl_net_server_tcp: use async getaddrinfo() to resolve server name. this allows nicer usage such as 'localhost:http' as the address, which will resolve to [::1]:80 (if IPv6 is enabled) or 127.0.0.1:80 if only IPv4 exists.
2016-10-20 19:15:09 -07:00
ecore_thread_cancel(pd->resolver);
pd->resolver = NULL;
efl.net: socket, server and dialer for TCP. Efl.Net.Server defines how to accept new connections, doing the bind(), listen() and accept() for protocols such as TCP. Efl.Net.Dialer defines to to reach a server. Both are based on Efl.Net.Socket as communication interface that is based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being usable with code such as Efl.Io.Copier. The Server will emit an event "client,add" with the established Socket, which is a child and can be closed by both the server or the user. The Dialer extends the Socket and allows for creating one given an address, that will be resolved and connected. TCP is the initial implementation so we an validate the interfaces. UDP, Unix-Local and SSL will come later as derivate classes. The examples are documented and should cover the basic principles: - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a "netcat", can send data from socket, file or stdin to a socket, file, stdout or stderr. - efl_net_server_example listens for connections and can either reply "Hello World!" and take some data or work as an echo-server, looping back all received data to the user. More complex interactions that require a "chat" between client and server will be covered with new classes later, such as a queue that empties itself once data is read.
2016-08-17 21:53:16 -07:00
}
efl_net_server_tcp: use async getaddrinfo() to resolve server name. this allows nicer usage such as 'localhost:http' as the address, which will resolve to [::1]:80 (if IPv6 is enabled) or 127.0.0.1:80 if only IPv4 exists.
2016-10-20 19:15:09 -07:00
efl_destructor(efl_super(o, MY_CLASS));
}
efl.net: socket, server and dialer for TCP. Efl.Net.Server defines how to accept new connections, doing the bind(), listen() and accept() for protocols such as TCP. Efl.Net.Dialer defines to to reach a server. Both are based on Efl.Net.Socket as communication interface that is based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being usable with code such as Efl.Io.Copier. The Server will emit an event "client,add" with the established Socket, which is a child and can be closed by both the server or the user. The Dialer extends the Socket and allows for creating one given an address, that will be resolved and connected. TCP is the initial implementation so we an validate the interfaces. UDP, Unix-Local and SSL will come later as derivate classes. The examples are documented and should cover the basic principles: - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a "netcat", can send data from socket, file or stdin to a socket, file, stdout or stderr. - efl_net_server_example listens for connections and can either reply "Hello World!" and take some data or work as an echo-server, looping back all received data to the user. More complex interactions that require a "chat" between client and server will be covered with new classes later, such as a queue that empties itself once data is read.
2016-08-17 21:53:16 -07:00
efl_net_server_tcp: use async getaddrinfo() to resolve server name. this allows nicer usage such as 'localhost:http' as the address, which will resolve to [::1]:80 (if IPv6 is enabled) or 127.0.0.1:80 if only IPv4 exists.
2016-10-20 19:15:09 -07:00
static Eina_Error
_efl_net_server_tcp_resolved_bind(Eo *o, Efl_Net_Server_Tcp_Data *pd, const struct addrinfo *addr)
{
Eina_Error err = 0;
char buf[INET6_ADDRSTRLEN + sizeof("[]:65536")];
socklen_t addrlen = addr->ai_addrlen;
int fd, r;
efl.net: socket, server and dialer for TCP. Efl.Net.Server defines how to accept new connections, doing the bind(), listen() and accept() for protocols such as TCP. Efl.Net.Dialer defines to to reach a server. Both are based on Efl.Net.Socket as communication interface that is based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being usable with code such as Efl.Io.Copier. The Server will emit an event "client,add" with the established Socket, which is a child and can be closed by both the server or the user. The Dialer extends the Socket and allows for creating one given an address, that will be resolved and connected. TCP is the initial implementation so we an validate the interfaces. UDP, Unix-Local and SSL will come later as derivate classes. The examples are documented and should cover the basic principles: - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a "netcat", can send data from socket, file or stdin to a socket, file, stdout or stderr. - efl_net_server_example listens for connections and can either reply "Hello World!" and take some data or work as an echo-server, looping back all received data to the user. More complex interactions that require a "chat" between client and server will be covered with new classes later, such as a queue that empties itself once data is read.
2016-08-17 21:53:16 -07:00
efl_net_server_tcp: use async getaddrinfo() to resolve server name. this allows nicer usage such as 'localhost:http' as the address, which will resolve to [::1]:80 (if IPv6 is enabled) or 127.0.0.1:80 if only IPv4 exists.
2016-10-20 19:15:09 -07:00
efl_net_server_fd_family_set(o, addr->ai_family);
efl.net: socket, server and dialer for TCP. Efl.Net.Server defines how to accept new connections, doing the bind(), listen() and accept() for protocols such as TCP. Efl.Net.Dialer defines to to reach a server. Both are based on Efl.Net.Socket as communication interface that is based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being usable with code such as Efl.Io.Copier. The Server will emit an event "client,add" with the established Socket, which is a child and can be closed by both the server or the user. The Dialer extends the Socket and allows for creating one given an address, that will be resolved and connected. TCP is the initial implementation so we an validate the interfaces. UDP, Unix-Local and SSL will come later as derivate classes. The examples are documented and should cover the basic principles: - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a "netcat", can send data from socket, file or stdin to a socket, file, stdout or stderr. - efl_net_server_example listens for connections and can either reply "Hello World!" and take some data or work as an echo-server, looping back all received data to the user. More complex interactions that require a "chat" between client and server will be covered with new classes later, such as a queue that empties itself once data is read.
2016-08-17 21:53:16 -07:00
efl_net_server_tcp: use async getaddrinfo() to resolve server name. this allows nicer usage such as 'localhost:http' as the address, which will resolve to [::1]:80 (if IPv6 is enabled) or 127.0.0.1:80 if only IPv4 exists.
2016-10-20 19:15:09 -07:00
fd = efl_net_socket4(addr->ai_family, addr->ai_socktype, addr->ai_protocol,
efl_net: better handling for SOCK_CLOEXEC. On systems where SOCK_CLOEXEC is supported, give it to socket() and if accept4() is supported, then use it as well. Otherwise revert to fcntl().
2016-08-24 08:34:59 -07:00
efl_net_server_fd_close_on_exec_get(o));
efl.net: socket, server and dialer for TCP. Efl.Net.Server defines how to accept new connections, doing the bind(), listen() and accept() for protocols such as TCP. Efl.Net.Dialer defines to to reach a server. Both are based on Efl.Net.Socket as communication interface that is based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being usable with code such as Efl.Io.Copier. The Server will emit an event "client,add" with the established Socket, which is a child and can be closed by both the server or the user. The Dialer extends the Socket and allows for creating one given an address, that will be resolved and connected. TCP is the initial implementation so we an validate the interfaces. UDP, Unix-Local and SSL will come later as derivate classes. The examples are documented and should cover the basic principles: - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a "netcat", can send data from socket, file or stdin to a socket, file, stdout or stderr. - efl_net_server_example listens for connections and can either reply "Hello World!" and take some data or work as an echo-server, looping back all received data to the user. More complex interactions that require a "chat" between client and server will be covered with new classes later, such as a queue that empties itself once data is read.
2016-08-17 21:53:16 -07:00
if (fd < 0)
{
efl_net_server_tcp: use async getaddrinfo() to resolve server name. this allows nicer usage such as 'localhost:http' as the address, which will resolve to [::1]:80 (if IPv6 is enabled) or 127.0.0.1:80 if only IPv4 exists.
2016-10-20 19:15:09 -07:00
ERR("socket(%d, %d, %d): %s",
addr->ai_family, addr->ai_socktype, addr->ai_protocol,
strerror(errno));
return errno;
efl.net: socket, server and dialer for TCP. Efl.Net.Server defines how to accept new connections, doing the bind(), listen() and accept() for protocols such as TCP. Efl.Net.Dialer defines to to reach a server. Both are based on Efl.Net.Socket as communication interface that is based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being usable with code such as Efl.Io.Copier. The Server will emit an event "client,add" with the established Socket, which is a child and can be closed by both the server or the user. The Dialer extends the Socket and allows for creating one given an address, that will be resolved and connected. TCP is the initial implementation so we an validate the interfaces. UDP, Unix-Local and SSL will come later as derivate classes. The examples are documented and should cover the basic principles: - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a "netcat", can send data from socket, file or stdin to a socket, file, stdout or stderr. - efl_net_server_example listens for connections and can either reply "Hello World!" and take some data or work as an echo-server, looping back all received data to the user. More complex interactions that require a "chat" between client and server will be covered with new classes later, such as a queue that empties itself once data is read.
2016-08-17 21:53:16 -07:00
}
efl_loop_fd_set(o, fd);
efl_net_server_tcp: allow IPv4 over IPv6 sockets. Sometimes we want to handle both IPv4 and IPv6 in the same socket, instead of spawning 2 servers, one for each protocol. That is achieved by means of disabling IPV6_V6ONLY socket option, present in most recent platforms.
2016-10-18 16:24:16 -07:00
/* apply pending value BEFORE bind() */
efl_net_server_tcp: use async getaddrinfo() to resolve server name. this allows nicer usage such as 'localhost:http' as the address, which will resolve to [::1]:80 (if IPv6 is enabled) or 127.0.0.1:80 if only IPv4 exists.
2016-10-20 19:15:09 -07:00
if (addr->ai_family == AF_INET6)
ipv6_only: use system default if unset. only apply the value if IPv6 && set. If unset (now 0xff), then call the getter so the property is in sync with the kernel default.
2016-10-20 15:43:02 -07:00
{
if (pd->ipv6_only == 0xff)
efl_net_server_tcp_ipv6_only_get(o); /* fetch & sync */
else
efl_net_server_tcp_ipv6_only_set(o, pd->ipv6_only);
}
efl_net_server_tcp: allow IPv4 over IPv6 sockets. Sometimes we want to handle both IPv4 and IPv6 in the same socket, instead of spawning 2 servers, one for each protocol. That is achieved by means of disabling IPV6_V6ONLY socket option, present in most recent platforms.
2016-10-18 16:24:16 -07:00
efl_net_server_tcp: use async getaddrinfo() to resolve server name. this allows nicer usage such as 'localhost:http' as the address, which will resolve to [::1]:80 (if IPv6 is enabled) or 127.0.0.1:80 if only IPv4 exists.
2016-10-20 19:15:09 -07:00
r = bind(fd, addr->ai_addr, addrlen);
efl.net: socket, server and dialer for TCP. Efl.Net.Server defines how to accept new connections, doing the bind(), listen() and accept() for protocols such as TCP. Efl.Net.Dialer defines to to reach a server. Both are based on Efl.Net.Socket as communication interface that is based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being usable with code such as Efl.Io.Copier. The Server will emit an event "client,add" with the established Socket, which is a child and can be closed by both the server or the user. The Dialer extends the Socket and allows for creating one given an address, that will be resolved and connected. TCP is the initial implementation so we an validate the interfaces. UDP, Unix-Local and SSL will come later as derivate classes. The examples are documented and should cover the basic principles: - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a "netcat", can send data from socket, file or stdin to a socket, file, stdout or stderr. - efl_net_server_example listens for connections and can either reply "Hello World!" and take some data or work as an echo-server, looping back all received data to the user. More complex interactions that require a "chat" between client and server will be covered with new classes later, such as a queue that empties itself once data is read.
2016-08-17 21:53:16 -07:00
if (r < 0)
{
err = errno;
efl_net_server_tcp: use async getaddrinfo() to resolve server name. this allows nicer usage such as 'localhost:http' as the address, which will resolve to [::1]:80 (if IPv6 is enabled) or 127.0.0.1:80 if only IPv4 exists.
2016-10-20 19:15:09 -07:00
efl_net_ip_port_fmt(buf, sizeof(buf), addr->ai_addr);
DBG("bind(%d, %s): %s", fd, buf, strerror(errno));
goto error;
efl_net_server_tcp: allow IPv4 over IPv6 sockets. Sometimes we want to handle both IPv4 and IPv6 in the same socket, instead of spawning 2 servers, one for each protocol. That is achieved by means of disabling IPV6_V6ONLY socket option, present in most recent platforms.
2016-10-18 16:24:16 -07:00
}
efl.net: socket, server and dialer for TCP. Efl.Net.Server defines how to accept new connections, doing the bind(), listen() and accept() for protocols such as TCP. Efl.Net.Dialer defines to to reach a server. Both are based on Efl.Net.Socket as communication interface that is based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being usable with code such as Efl.Io.Copier. The Server will emit an event "client,add" with the established Socket, which is a child and can be closed by both the server or the user. The Dialer extends the Socket and allows for creating one given an address, that will be resolved and connected. TCP is the initial implementation so we an validate the interfaces. UDP, Unix-Local and SSL will come later as derivate classes. The examples are documented and should cover the basic principles: - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a "netcat", can send data from socket, file or stdin to a socket, file, stdout or stderr. - efl_net_server_example listens for connections and can either reply "Hello World!" and take some data or work as an echo-server, looping back all received data to the user. More complex interactions that require a "chat" between client and server will be covered with new classes later, such as a queue that empties itself once data is read.
2016-08-17 21:53:16 -07:00
r = listen(fd, 0);
if (r < 0)
{
err = errno;
efl_net_server_tcp: use async getaddrinfo() to resolve server name. this allows nicer usage such as 'localhost:http' as the address, which will resolve to [::1]:80 (if IPv6 is enabled) or 127.0.0.1:80 if only IPv4 exists.
2016-10-20 19:15:09 -07:00
DBG("listen(%d): %s", fd, strerror(errno));
goto error;
efl.net: socket, server and dialer for TCP. Efl.Net.Server defines how to accept new connections, doing the bind(), listen() and accept() for protocols such as TCP. Efl.Net.Dialer defines to to reach a server. Both are based on Efl.Net.Socket as communication interface that is based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being usable with code such as Efl.Io.Copier. The Server will emit an event "client,add" with the established Socket, which is a child and can be closed by both the server or the user. The Dialer extends the Socket and allows for creating one given an address, that will be resolved and connected. TCP is the initial implementation so we an validate the interfaces. UDP, Unix-Local and SSL will come later as derivate classes. The examples are documented and should cover the basic principles: - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a "netcat", can send data from socket, file or stdin to a socket, file, stdout or stderr. - efl_net_server_example listens for connections and can either reply "Hello World!" and take some data or work as an echo-server, looping back all received data to the user. More complex interactions that require a "chat" between client and server will be covered with new classes later, such as a queue that empties itself once data is read.
2016-08-17 21:53:16 -07:00
}
efl_net_server_tcp: use async getaddrinfo() to resolve server name. this allows nicer usage such as 'localhost:http' as the address, which will resolve to [::1]:80 (if IPv6 is enabled) or 127.0.0.1:80 if only IPv4 exists.
2016-10-20 19:15:09 -07:00
if (getsockname(fd, addr->ai_addr, &addrlen) != 0)
{
ERR("getsockname(%d): %s", fd, strerror(errno));
goto error;
}
else if (efl_net_ip_port_fmt(buf, sizeof(buf), addr->ai_addr))
efl_net_server_address_set(o, buf);
DBG("fd=%d serving at %s", fd, buf);
efl.net: socket, server and dialer for TCP. Efl.Net.Server defines how to accept new connections, doing the bind(), listen() and accept() for protocols such as TCP. Efl.Net.Dialer defines to to reach a server. Both are based on Efl.Net.Socket as communication interface that is based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being usable with code such as Efl.Io.Copier. The Server will emit an event "client,add" with the established Socket, which is a child and can be closed by both the server or the user. The Dialer extends the Socket and allows for creating one given an address, that will be resolved and connected. TCP is the initial implementation so we an validate the interfaces. UDP, Unix-Local and SSL will come later as derivate classes. The examples are documented and should cover the basic principles: - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a "netcat", can send data from socket, file or stdin to a socket, file, stdout or stderr. - efl_net_server_example listens for connections and can either reply "Hello World!" and take some data or work as an echo-server, looping back all received data to the user. More complex interactions that require a "chat" between client and server will be covered with new classes later, such as a queue that empties itself once data is read.
2016-08-17 21:53:16 -07:00
efl_net_server_serving_set(o, EINA_TRUE);
return 0;
efl_net_server_tcp: use async getaddrinfo() to resolve server name. this allows nicer usage such as 'localhost:http' as the address, which will resolve to [::1]:80 (if IPv6 is enabled) or 127.0.0.1:80 if only IPv4 exists.
2016-10-20 19:15:09 -07:00
error:
efl_net_server_fd_family_set(o, AF_UNSPEC);
efl_loop_fd_set(o, -1);
efl.net: socket, server and dialer for TCP. Efl.Net.Server defines how to accept new connections, doing the bind(), listen() and accept() for protocols such as TCP. Efl.Net.Dialer defines to to reach a server. Both are based on Efl.Net.Socket as communication interface that is based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being usable with code such as Efl.Io.Copier. The Server will emit an event "client,add" with the established Socket, which is a child and can be closed by both the server or the user. The Dialer extends the Socket and allows for creating one given an address, that will be resolved and connected. TCP is the initial implementation so we an validate the interfaces. UDP, Unix-Local and SSL will come later as derivate classes. The examples are documented and should cover the basic principles: - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a "netcat", can send data from socket, file or stdin to a socket, file, stdout or stderr. - efl_net_server_example listens for connections and can either reply "Hello World!" and take some data or work as an echo-server, looping back all received data to the user. More complex interactions that require a "chat" between client and server will be covered with new classes later, such as a queue that empties itself once data is read.
2016-08-17 21:53:16 -07:00
close(fd);
return err;
}
efl_net_server_tcp: use async getaddrinfo() to resolve server name. this allows nicer usage such as 'localhost:http' as the address, which will resolve to [::1]:80 (if IPv6 is enabled) or 127.0.0.1:80 if only IPv4 exists.
2016-10-20 19:15:09 -07:00
static void
_efl_net_server_tcp_resolved(void *data, const char *host EINA_UNUSED, const char *port EINA_UNUSED, const struct addrinfo *hints EINA_UNUSED, struct addrinfo *result, int gai_error)
{
Eo *o = data;
Efl_Net_Server_Tcp_Data *pd = efl_data_scope_get(o, MY_CLASS);
const struct addrinfo *addr;
Eina_Error err;
pd->resolver = NULL;
efl_ref(o); /* we're emitting callbacks then continuing the workflow */
if (gai_error)
{
err = EFL_NET_SERVER_ERROR_COULDNT_RESOLVE_HOST;
goto end;
}
for (addr = result; addr != NULL; addr = addr->ai_next)
{
err = _efl_net_server_tcp_resolved_bind(o, pd, addr);
if (err == 0) break;
}
freeaddrinfo(result);
end:
if (err) efl_event_callback_call(o, EFL_NET_SERVER_EVENT_ERROR, &err);
efl_unref(o);
}
EOLIAN static Eina_Error
_efl_net_server_tcp_efl_net_server_serve(Eo *o, Efl_Net_Server_Tcp_Data *pd, const char *address)
{
char *str;
const char *host, *port;
struct addrinfo hints = {
.ai_socktype = SOCK_STREAM,
.ai_protocol = IPPROTO_TCP,
.ai_family = AF_UNSPEC,
};
EINA_SAFETY_ON_NULL_RETURN_VAL(address, EINVAL);
str = strdup(address);
if (!efl_net_ip_port_split(str, &host, &port))
{
free(str);
return EINVAL;
}
if (!port) port = "0";
if (strchr(host, ':')) hints.ai_family = AF_INET6;
pd->resolver = efl_net_ip_resolve_async_new(host, port, &hints,
_efl_net_server_tcp_resolved, o);
free(str);
EINA_SAFETY_ON_NULL_RETURN_VAL(pd->resolver, EINVAL);
return 0;
}
efl.net: socket, server and dialer for TCP. Efl.Net.Server defines how to accept new connections, doing the bind(), listen() and accept() for protocols such as TCP. Efl.Net.Dialer defines to to reach a server. Both are based on Efl.Net.Socket as communication interface that is based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being usable with code such as Efl.Io.Copier. The Server will emit an event "client,add" with the established Socket, which is a child and can be closed by both the server or the user. The Dialer extends the Socket and allows for creating one given an address, that will be resolved and connected. TCP is the initial implementation so we an validate the interfaces. UDP, Unix-Local and SSL will come later as derivate classes. The examples are documented and should cover the basic principles: - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a "netcat", can send data from socket, file or stdin to a socket, file, stdout or stderr. - efl_net_server_example listens for connections and can either reply "Hello World!" and take some data or work as an echo-server, looping back all received data to the user. More complex interactions that require a "chat" between client and server will be covered with new classes later, such as a queue that empties itself once data is read.
2016-08-17 21:53:16 -07:00
static Efl_Callback_Array_Item *_efl_net_server_tcp_client_cbs(void);
static void
Efl object: Rename Eo_Event -> Efl_Event. This is the last step of the Eo renaming efforts.
2016-08-30 05:34:10 -07:00
_efl_net_server_tcp_client_event_closed(void *data, const Efl_Event *event)
efl.net: socket, server and dialer for TCP. Efl.Net.Server defines how to accept new connections, doing the bind(), listen() and accept() for protocols such as TCP. Efl.Net.Dialer defines to to reach a server. Both are based on Efl.Net.Socket as communication interface that is based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being usable with code such as Efl.Io.Copier. The Server will emit an event "client,add" with the established Socket, which is a child and can be closed by both the server or the user. The Dialer extends the Socket and allows for creating one given an address, that will be resolved and connected. TCP is the initial implementation so we an validate the interfaces. UDP, Unix-Local and SSL will come later as derivate classes. The examples are documented and should cover the basic principles: - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a "netcat", can send data from socket, file or stdin to a socket, file, stdout or stderr. - efl_net_server_example listens for connections and can either reply "Hello World!" and take some data or work as an echo-server, looping back all received data to the user. More complex interactions that require a "chat" between client and server will be covered with new classes later, such as a queue that empties itself once data is read.
2016-08-17 21:53:16 -07:00
{
Eo *server = data;
Eo *client = event->object;
efl_event_callback_array_del(client, _efl_net_server_tcp_client_cbs(), server);
if (efl_parent_get(client) == server)
efl_parent_set(client, NULL);
efl_net_server_clients_count_set(server, efl_net_server_clients_count_get(server) - 1);
}
EFL_CALLBACKS_ARRAY_DEFINE(_efl_net_server_tcp_client_cbs,
{ EFL_IO_CLOSER_EVENT_CLOSED, _efl_net_server_tcp_client_event_closed });
static void
efl_net_server_tcp: allow IPv4 over IPv6 sockets. Sometimes we want to handle both IPv4 and IPv6 in the same socket, instead of spawning 2 servers, one for each protocol. That is achieved by means of disabling IPV6_V6ONLY socket option, present in most recent platforms.
2016-10-18 16:24:16 -07:00
_efl_net_server_tcp_efl_net_server_fd_client_add(Eo *o, Efl_Net_Server_Tcp_Data *pd EINA_UNUSED, int client_fd)
efl.net: socket, server and dialer for TCP. Efl.Net.Server defines how to accept new connections, doing the bind(), listen() and accept() for protocols such as TCP. Efl.Net.Dialer defines to to reach a server. Both are based on Efl.Net.Socket as communication interface that is based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being usable with code such as Efl.Io.Copier. The Server will emit an event "client,add" with the established Socket, which is a child and can be closed by both the server or the user. The Dialer extends the Socket and allows for creating one given an address, that will be resolved and connected. TCP is the initial implementation so we an validate the interfaces. UDP, Unix-Local and SSL will come later as derivate classes. The examples are documented and should cover the basic principles: - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a "netcat", can send data from socket, file or stdin to a socket, file, stdout or stderr. - efl_net_server_example listens for connections and can either reply "Hello World!" and take some data or work as an echo-server, looping back all received data to the user. More complex interactions that require a "chat" between client and server will be covered with new classes later, such as a queue that empties itself once data is read.
2016-08-17 21:53:16 -07:00
{
Eo *client = efl_add(EFL_NET_SOCKET_TCP_CLASS, o,
Rename efl_self to efl_added It has been discussed on the ML (thread: "[RFC] rename efl_self") and IRC, and has been decided we should rename it to this in order to avoid confusion with the already established meaning of self which is very similar to what we were using it for, but didn't have complete overlap. Kudos to Marcel Hollerbach for initiating the discussion and fighting for it until he convinced a significant mass. :) This commit breaks API, and depending on compiler potentially ABI. @feature
2016-09-05 08:57:35 -07:00
efl_event_callback_array_add(efl_added, _efl_net_server_tcp_client_cbs(), o),
efl_io_closer: add close_on_exec and close_on_destructor properties. the purpose of these properties are to make it more uniform the handling of these auto-close behavior.
2016-09-12 08:23:29 -07:00
efl_io_closer_close_on_exec_set(efl_added, efl_net_server_fd_close_on_exec_get(o)),
efl_io_closer_close_on_destructor_set(efl_added, EINA_TRUE),
Rename efl_self to efl_added It has been discussed on the ML (thread: "[RFC] rename efl_self") and IRC, and has been decided we should rename it to this in order to avoid confusion with the already established meaning of self which is very similar to what we were using it for, but didn't have complete overlap. Kudos to Marcel Hollerbach for initiating the discussion and fighting for it until he convinced a significant mass. :) This commit breaks API, and depending on compiler potentially ABI. @feature
2016-09-05 08:57:35 -07:00
efl_loop_fd_set(efl_added, client_fd));
efl.net: socket, server and dialer for TCP. Efl.Net.Server defines how to accept new connections, doing the bind(), listen() and accept() for protocols such as TCP. Efl.Net.Dialer defines to to reach a server. Both are based on Efl.Net.Socket as communication interface that is based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being usable with code such as Efl.Io.Copier. The Server will emit an event "client,add" with the established Socket, which is a child and can be closed by both the server or the user. The Dialer extends the Socket and allows for creating one given an address, that will be resolved and connected. TCP is the initial implementation so we an validate the interfaces. UDP, Unix-Local and SSL will come later as derivate classes. The examples are documented and should cover the basic principles: - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a "netcat", can send data from socket, file or stdin to a socket, file, stdout or stderr. - efl_net_server_example listens for connections and can either reply "Hello World!" and take some data or work as an echo-server, looping back all received data to the user. More complex interactions that require a "chat" between client and server will be covered with new classes later, such as a queue that empties itself once data is read.
2016-08-17 21:53:16 -07:00
if (!client)
{
ERR("could not create client object fd=%d", client_fd);
close(client_fd);
return;
}
efl_net_server_clients_count_set(o, efl_net_server_clients_count_get(o) + 1);
efl callbacks: update some events calls to no longer trigger legacy callbacks
2016-08-29 16:13:22 -07:00
efl_event_callback_call(o, EFL_NET_SERVER_EVENT_CLIENT_ADD, client);
efl.net: socket, server and dialer for TCP. Efl.Net.Server defines how to accept new connections, doing the bind(), listen() and accept() for protocols such as TCP. Efl.Net.Dialer defines to to reach a server. Both are based on Efl.Net.Socket as communication interface that is based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being usable with code such as Efl.Io.Copier. The Server will emit an event "client,add" with the established Socket, which is a child and can be closed by both the server or the user. The Dialer extends the Socket and allows for creating one given an address, that will be resolved and connected. TCP is the initial implementation so we an validate the interfaces. UDP, Unix-Local and SSL will come later as derivate classes. The examples are documented and should cover the basic principles: - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a "netcat", can send data from socket, file or stdin to a socket, file, stdout or stderr. - efl_net_server_example listens for connections and can either reply "Hello World!" and take some data or work as an echo-server, looping back all received data to the user. More complex interactions that require a "chat" between client and server will be covered with new classes later, such as a queue that empties itself once data is read.
2016-08-17 21:53:16 -07:00
if (efl_ref_get(client) == 1) /* users must take a reference themselves */
{
DBG("client %s was not handled, closing it...",
efl_net_socket_address_remote_get(client));
efl_io_closer: add close_on_exec and close_on_destructor properties. the purpose of these properties are to make it more uniform the handling of these auto-close behavior.
2016-09-12 08:23:29 -07:00
efl_del(client);
efl.net: socket, server and dialer for TCP. Efl.Net.Server defines how to accept new connections, doing the bind(), listen() and accept() for protocols such as TCP. Efl.Net.Dialer defines to to reach a server. Both are based on Efl.Net.Socket as communication interface that is based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being usable with code such as Efl.Io.Copier. The Server will emit an event "client,add" with the established Socket, which is a child and can be closed by both the server or the user. The Dialer extends the Socket and allows for creating one given an address, that will be resolved and connected. TCP is the initial implementation so we an validate the interfaces. UDP, Unix-Local and SSL will come later as derivate classes. The examples are documented and should cover the basic principles: - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a "netcat", can send data from socket, file or stdin to a socket, file, stdout or stderr. - efl_net_server_example listens for connections and can either reply "Hello World!" and take some data or work as an echo-server, looping back all received data to the user. More complex interactions that require a "chat" between client and server will be covered with new classes later, such as a queue that empties itself once data is read.
2016-08-17 21:53:16 -07:00
}
}
static void
efl_net_server_tcp: allow IPv4 over IPv6 sockets. Sometimes we want to handle both IPv4 and IPv6 in the same socket, instead of spawning 2 servers, one for each protocol. That is achieved by means of disabling IPV6_V6ONLY socket option, present in most recent platforms.
2016-10-18 16:24:16 -07:00
_efl_net_server_tcp_efl_net_server_fd_client_reject(Eo *o, Efl_Net_Server_Tcp_Data *pd EINA_UNUSED, int client_fd)
efl.net: socket, server and dialer for TCP. Efl.Net.Server defines how to accept new connections, doing the bind(), listen() and accept() for protocols such as TCP. Efl.Net.Dialer defines to to reach a server. Both are based on Efl.Net.Socket as communication interface that is based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being usable with code such as Efl.Io.Copier. The Server will emit an event "client,add" with the established Socket, which is a child and can be closed by both the server or the user. The Dialer extends the Socket and allows for creating one given an address, that will be resolved and connected. TCP is the initial implementation so we an validate the interfaces. UDP, Unix-Local and SSL will come later as derivate classes. The examples are documented and should cover the basic principles: - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a "netcat", can send data from socket, file or stdin to a socket, file, stdout or stderr. - efl_net_server_example listens for connections and can either reply "Hello World!" and take some data or work as an echo-server, looping back all received data to the user. More complex interactions that require a "chat" between client and server will be covered with new classes later, such as a queue that empties itself once data is read.
2016-08-17 21:53:16 -07:00
{
struct sockaddr_storage addr;
socklen_t addrlen;
char str[INET6_ADDRSTRLEN + sizeof("[]:65536")] = "";
addrlen = sizeof(addr);
if (getpeername(client_fd, (struct sockaddr *)&addr, &addrlen) < 0)
ERR("getpeername(%d): %s", client_fd, strerror(errno));
else
efl_net_ip_port_fmt(str, sizeof(str), (struct sockaddr *)&addr);
close(client_fd);
efl callbacks: update some events calls to no longer trigger legacy callbacks
2016-08-29 16:13:22 -07:00
efl_event_callback_call(o, EFL_NET_SERVER_EVENT_CLIENT_REJECTED, str);
efl.net: socket, server and dialer for TCP. Efl.Net.Server defines how to accept new connections, doing the bind(), listen() and accept() for protocols such as TCP. Efl.Net.Dialer defines to to reach a server. Both are based on Efl.Net.Socket as communication interface that is based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being usable with code such as Efl.Io.Copier. The Server will emit an event "client,add" with the established Socket, which is a child and can be closed by both the server or the user. The Dialer extends the Socket and allows for creating one given an address, that will be resolved and connected. TCP is the initial implementation so we an validate the interfaces. UDP, Unix-Local and SSL will come later as derivate classes. The examples are documented and should cover the basic principles: - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a "netcat", can send data from socket, file or stdin to a socket, file, stdout or stderr. - efl_net_server_example listens for connections and can either reply "Hello World!" and take some data or work as an echo-server, looping back all received data to the user. More complex interactions that require a "chat" between client and server will be covered with new classes later, such as a queue that empties itself once data is read.
2016-08-17 21:53:16 -07:00
}
efl_net_server_tcp: allow IPv4 over IPv6 sockets. Sometimes we want to handle both IPv4 and IPv6 in the same socket, instead of spawning 2 servers, one for each protocol. That is achieved by means of disabling IPV6_V6ONLY socket option, present in most recent platforms.
2016-10-18 16:24:16 -07:00
EOLIAN void
_efl_net_server_tcp_ipv6_only_set(Eo *o, Efl_Net_Server_Tcp_Data *pd, Eina_Bool ipv6_only)
{
Eina_Bool old = pd->ipv6_only;
int fd = efl_loop_fd_get(o);
int value = ipv6_only;
pd->ipv6_only = ipv6_only;
if (fd < 0) return;
if (efl_net_server_fd_family_get(o) != AF_INET6) return;
#ifdef IPV6_V6ONLY
if (setsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &value, sizeof(value)) < 0)
{
ERR("could not set socket=%d IPV6_V6ONLY=%d: %s", fd, value, strerror(errno));
pd->ipv6_only = old;
}
#endif
}
EOLIAN Eina_Bool
_efl_net_server_tcp_ipv6_only_get(Eo *o EINA_UNUSED, Efl_Net_Server_Tcp_Data *pd)
{
#ifdef IPV6_V6ONLY
int fd = efl_loop_fd_get(o);
int value = 0;
socklen_t size = sizeof(value);
if (fd < 0) goto end;
if (efl_net_server_fd_family_get(o) != AF_INET6) goto end;
if (getsockopt(fd, IPPROTO_IPV6, IPV6_V6ONLY, &value, &size) < 0)
{
WRN("getsockopt(%d, IPPROTO_IPV6, IPV6_V6ONLY): %s", fd, strerror(errno));
goto end;
}
pd->ipv6_only = !!value;
end:
#endif
return pd->ipv6_only;
}
efl.net: socket, server and dialer for TCP. Efl.Net.Server defines how to accept new connections, doing the bind(), listen() and accept() for protocols such as TCP. Efl.Net.Dialer defines to to reach a server. Both are based on Efl.Net.Socket as communication interface that is based on Efl.Io.Reader, Efl.Io.Writer and Efl.Io.Closer, thus being usable with code such as Efl.Io.Copier. The Server will emit an event "client,add" with the established Socket, which is a child and can be closed by both the server or the user. The Dialer extends the Socket and allows for creating one given an address, that will be resolved and connected. TCP is the initial implementation so we an validate the interfaces. UDP, Unix-Local and SSL will come later as derivate classes. The examples are documented and should cover the basic principles: - efl_io_copier_example can accept "tcp://IP:PORT" and will work as a "netcat", can send data from socket, file or stdin to a socket, file, stdout or stderr. - efl_net_server_example listens for connections and can either reply "Hello World!" and take some data or work as an echo-server, looping back all received data to the user. More complex interactions that require a "chat" between client and server will be covered with new classes later, such as a queue that empties itself once data is read.
2016-08-17 21:53:16 -07:00
#include "efl_net_server_tcp.eo.c"