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_dialer_tcp.c

362 lines
10 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_DIALER_TCP_PROTECTED 1
#define EFL_NET_DIALER_PROTECTED 1
#define EFL_NET_SOCKET_FD_PROTECTED 1
#define EFL_NET_SOCKET_PROTECTED 1
efl_net_dialer_tcp: emit EOS on errors. I/O copier and others may depend on end-of-stream to stop processing, then emit the EOS on failures.
2016-09-12 09:21:20 -07:00
#define EFL_IO_READER_PROTECTED 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
#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_DIALER_TCP_CLASS
typedef struct _Efl_Net_Dialer_Tcp_Data
{
efl_net_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
struct {
Ecore_Thread *thread;
struct addrinfo *names;
struct addrinfo *current;
} resolve;
struct {
Ecore_Thread *thread;
ecore_con: migrate use of Eina_Promise to Efl_Future.
2016-09-15 21:48:42 -07:00
Efl_Future *timeout;
efl_net_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
} connect;
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
Eina_Stringshare *address_dial;
fixup: efl-net
2016-08-22 14:51:19 -07:00
Eina_Stringshare *proxy;
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
Eina_Bool connected;
efl_net_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
Eina_Bool closed;
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
double timeout_dial;
} Efl_Net_Dialer_Tcp_Data;
efl_net_dialer_tcp: add connect timeout.
2016-09-12 10:48:03 -07:00
EOLIAN static Eo*
_efl_net_dialer_tcp_efl_object_constructor(Eo *o, Efl_Net_Dialer_Tcp_Data *pd EINA_UNUSED)
{
o = efl_constructor(efl_super(o, MY_CLASS));
if (!o) return NULL;
efl_net_dialer_timeout_dial_set(o, 30.0);
return 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
EOLIAN static void
_efl_net_dialer_tcp_efl_object_destructor(Eo *o, Efl_Net_Dialer_Tcp_Data *pd)
{
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
if (efl_io_closer_close_on_destructor_get(o) &&
(!efl_io_closer_closed_get(o)))
efl_io_closer_close(o);
efl_net_dialer_* use timeout promise instead of timer object. i wasn't aware of efl_loop_timeout for one-shot timeout promises, then use it instead of a full object.
2016-09-13 12:08:25 -07:00
if (pd->connect.timeout)
ecore,ecore_con: fix migration to efl_future. Efl_Future actually work with weak reference. So you do not need to set things to NULL, but you actually need to register the memory location of the future with efl_future_use.
2016-09-16 18:21:11 -07:00
efl_future_cancel(pd->connect.timeout);
efl_net_dialer_tcp: add connect timeout.
2016-09-12 10:48:03 -07:00
efl_net_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
if (pd->connect.thread)
{
ecore_thread_cancel(pd->connect.thread);
pd->connect.thread = NULL;
}
if (pd->resolve.thread)
{
ecore_thread_cancel(pd->resolve.thread);
pd->resolve.thread = NULL;
}
pd->resolve.current = NULL;
if (pd->resolve.names)
{
freeaddrinfo(pd->resolve.names);
pd->resolve.names = 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_destructor(efl_super(o, MY_CLASS));
eina_stringshare_replace(&pd->address_dial, NULL);
fixup: efl-net
2016-08-22 14:51:19 -07:00
eina_stringshare_replace(&pd->proxy, 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_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
static void
_efl_net_dialer_tcp_connected(void *data, const struct sockaddr *addr EINA_UNUSED, socklen_t addrlen EINA_UNUSED, int fd, Eina_Error err)
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_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
Eo *o = data;
Efl_Net_Dialer_Tcp_Data *pd = efl_data_scope_get(o, MY_CLASS);
const struct addrinfo *addrinfo;
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_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
pd->connect.thread = 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_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
if (!err)
{
freeaddrinfo(pd->resolve.names);
pd->resolve.names = NULL;
pd->resolve.current = NULL;
efl_loop_fd_set(o, fd);
efl_net_dialer_connected_set(o, EINA_TRUE);
return;
}
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_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
if (!pd->resolve.current) return;
pd->resolve.current = pd->resolve.current->ai_next;
if (!pd->resolve.current)
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_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
freeaddrinfo(pd->resolve.names);
pd->resolve.names = NULL;
efl_net_dialer_tcp: emit EOS on errors. I/O copier and others may depend on end-of-stream to stop processing, then emit the EOS on failures.
2016-09-12 09:21:20 -07:00
efl_io_reader_eos_set(o, EINA_TRUE);
efl_net_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
if (err)
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
else
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_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
err = EFL_NET_DIALER_ERROR_COULDNT_CONNECT;
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
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_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
return;
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_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
addrinfo = pd->resolve.current;
pd->connect.thread = efl_net_connect_async_new(addrinfo->ai_addr,
addrinfo->ai_addrlen,
SOCK_STREAM,
IPPROTO_TCP,
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_get(o),
efl_net_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
_efl_net_dialer_tcp_connected,
o);
}
static void
_efl_net_dialer_tcp_connect(Eo *o, Efl_Net_Dialer_Tcp_Data *pd)
{
char buf[INET6_ADDRSTRLEN + sizeof("[]:65536")];
const struct addrinfo *addrinfo;
if (pd->closed || !pd->resolve.current) return;
efl_ref(o); /* we're emitting callbacks then continuing the workflow */
addrinfo = pd->resolve.current;
efl_net_socket_fd_family_set(o, addrinfo->ai_family);
if (efl_net_ip_port_fmt(buf, sizeof(buf), addrinfo->ai_addr))
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_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
efl_net_socket_address_remote_set(o, buf);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_RESOLVED, 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_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
if (pd->closed) goto end; /* maybe closed from resolved event callback */
if (pd->connect.thread)
ecore_thread_cancel(pd->connect.thread);
pd->connect.thread = efl_net_connect_async_new(addrinfo->ai_addr,
addrinfo->ai_addrlen,
SOCK_STREAM,
IPPROTO_TCP,
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_get(o),
efl_net_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
_efl_net_dialer_tcp_connected,
o);
end:
efl_unref(o);
}
static void
_efl_net_dialer_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_Dialer_Tcp_Data *pd = efl_data_scope_get(o, MY_CLASS);
pd->resolve.thread = NULL;
if (gai_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_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
Eina_Error err = EFL_NET_DIALER_ERROR_COULDNT_RESOLVE_HOST;
efl_net_dialer_tcp: emit EOS on errors. I/O copier and others may depend on end-of-stream to stop processing, then emit the EOS on failures.
2016-09-12 09:21:20 -07:00
efl_io_reader_eos_set(o, EINA_TRUE);
efl_net_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
if (result) freeaddrinfo(result);
return;
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_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
if (pd->resolve.names) freeaddrinfo(pd->resolve.names);
pd->resolve.names = result;
pd->resolve.current = result;
_efl_net_dialer_tcp_connect(o, pd);
}
efl_net_dialer_tcp: add connect timeout.
2016-09-12 10:48:03 -07:00
static void
ecore_con: migrate use of Eina_Promise to Efl_Future.
2016-09-15 21:48:42 -07:00
_efl_net_dialer_tcp_connect_timeout(void *data, const Efl_Event *ev EINA_UNUSED)
efl_net_dialer_tcp: add connect timeout.
2016-09-12 10:48:03 -07:00
{
Eo *o = data;
Efl_Net_Dialer_Tcp_Data *pd = efl_data_scope_get(o, MY_CLASS);
Eina_Error err = ETIMEDOUT;
if (pd->resolve.thread)
{
ecore_thread_cancel(pd->resolve.thread);
pd->resolve.thread = NULL;
}
if (pd->resolve.names)
{
freeaddrinfo(pd->resolve.names);
pd->resolve.names = NULL;
}
pd->resolve.current = NULL;
if (pd->connect.thread)
{
ecore_thread_cancel(pd->connect.thread);
pd->connect.thread = NULL;
}
efl_ref(o);
efl_io_reader_eos_set(o, EINA_TRUE);
efl_event_callback_call(o, EFL_NET_DIALER_EVENT_ERROR, &err);
efl_unref(o);
}
efl_net_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
EOLIAN static Eina_Error
_efl_net_dialer_tcp_efl_net_dialer_dial(Eo *o, Efl_Net_Dialer_Tcp_Data *pd EINA_UNUSED, const char *address)
{
const char *host, *port;
struct addrinfo hints = {
.ai_socktype = SOCK_STREAM,
.ai_protocol = IPPROTO_TCP,
};
char *str;
EINA_SAFETY_ON_NULL_RETURN_VAL(address, EINVAL);
EINA_SAFETY_ON_TRUE_RETURN_VAL(efl_net_dialer_connected_get(o), EISCONN);
EINA_SAFETY_ON_TRUE_RETURN_VAL(efl_io_closer_closed_get(o), EBADF);
EINA_SAFETY_ON_TRUE_RETURN_VAL(efl_loop_fd_get(o) >= 0, EALREADY);
str = strdup(address);
EINA_SAFETY_ON_NULL_RETURN_VAL(str, ENOMEM);
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_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
if (!efl_net_ip_port_split(str, &host, &port))
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_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
ERR("could not parse IP:PORT '%s'", address);
free(str);
return EINVAL;
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_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
if (strchr(host, ':')) hints.ai_family = AF_INET6;
if (!port) port = "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
efl_net_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
if (pd->connect.thread)
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_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
ecore_thread_cancel(pd->connect.thread);
pd->connect.thread = 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_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
if (pd->resolve.names)
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_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
freeaddrinfo(pd->resolve.names);
pd->resolve.names = 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_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
pd->resolve.current = 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_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
if (pd->resolve.thread)
ecore_thread_cancel(pd->resolve.thread);
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_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
pd->resolve.thread = efl_net_resolve_async_new(host, port, &hints, _efl_net_dialer_tcp_resolved, 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
free(str);
efl_net_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
EINA_SAFETY_ON_NULL_RETURN_VAL(pd->resolve.thread, EINVAL);
efl_net_dialer_address_dial_set(o, address);
efl_net_dialer_* use timeout promise instead of timer object. i wasn't aware of efl_loop_timeout for one-shot timeout promises, then use it instead of a full object.
2016-09-13 12:08:25 -07:00
if (pd->connect.timeout)
ecore,ecore_con: fix migration to efl_future. Efl_Future actually work with weak reference. So you do not need to set things to NULL, but you actually need to register the memory location of the future with efl_future_use.
2016-09-16 18:21:11 -07:00
efl_future_cancel(pd->connect.timeout);
efl_net_dialer_tcp: add connect timeout.
2016-09-12 10:48:03 -07:00
if (pd->timeout_dial > 0.0)
{
ecore,ecore_con: fix migration to efl_future. Efl_Future actually work with weak reference. So you do not need to set things to NULL, but you actually need to register the memory location of the future with efl_future_use.
2016-09-16 18:21:11 -07:00
efl_future_use(&pd->connect.timeout, efl_loop_timeout(efl_loop_user_loop_get(o), pd->timeout_dial, o));
ecore_con: migrate use of Eina_Promise to Efl_Future.
2016-09-15 21:48:42 -07:00
efl_future_then(pd->connect.timeout, _efl_net_dialer_tcp_connect_timeout, NULL, NULL, o);
efl_net_dialer_tcp: add connect timeout.
2016-09-12 10:48:03 -07:00
}
efl_net_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
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
}
EOLIAN static void
_efl_net_dialer_tcp_efl_net_dialer_address_dial_set(Eo *o EINA_UNUSED, Efl_Net_Dialer_Tcp_Data *pd, const char *address)
{
eina_stringshare_replace(&pd->address_dial, address);
}
EOLIAN static const char *
_efl_net_dialer_tcp_efl_net_dialer_address_dial_get(Eo *o EINA_UNUSED, Efl_Net_Dialer_Tcp_Data *pd)
{
return pd->address_dial;
}
fixup: efl-net
2016-08-22 14:51:19 -07:00
EOLIAN static void
_efl_net_dialer_tcp_efl_net_dialer_proxy_set(Eo *o EINA_UNUSED, Efl_Net_Dialer_Tcp_Data *pd, const char *proxy_url)
{
// TODO: apply proxy
eina_stringshare_replace(&pd->proxy, proxy_url);
}
EOLIAN static const char *
_efl_net_dialer_tcp_efl_net_dialer_proxy_get(Eo *o EINA_UNUSED, Efl_Net_Dialer_Tcp_Data *pd)
{
return pd->proxy;
}
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
EOLIAN static void
_efl_net_dialer_tcp_efl_net_dialer_timeout_dial_set(Eo *o EINA_UNUSED, Efl_Net_Dialer_Tcp_Data *pd, double seconds)
{
pd->timeout_dial = seconds;
efl_net_dialer_* use timeout promise instead of timer object. i wasn't aware of efl_loop_timeout for one-shot timeout promises, then use it instead of a full object.
2016-09-13 12:08:25 -07:00
if (pd->connect.timeout)
ecore,ecore_con: fix migration to efl_future. Efl_Future actually work with weak reference. So you do not need to set things to NULL, but you actually need to register the memory location of the future with efl_future_use.
2016-09-16 18:21:11 -07:00
efl_future_cancel(pd->connect.timeout);
efl_net_dialer_tcp: add connect timeout.
2016-09-12 10:48:03 -07:00
if (pd->timeout_dial > 0.0)
{
ecore,ecore_con: fix migration to efl_future. Efl_Future actually work with weak reference. So you do not need to set things to NULL, but you actually need to register the memory location of the future with efl_future_use.
2016-09-16 18:21:11 -07:00
efl_future_use(&pd->connect.timeout, efl_loop_timeout(efl_loop_user_loop_get(o), pd->timeout_dial, o));
ecore_con: migrate use of Eina_Promise to Efl_Future.
2016-09-15 21:48:42 -07:00
efl_future_then(pd->connect.timeout, _efl_net_dialer_tcp_connect_timeout, NULL, NULL, o);
efl_net_dialer_tcp: add connect timeout.
2016-09-12 10:48:03 -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
}
EOLIAN static double
_efl_net_dialer_tcp_efl_net_dialer_timeout_dial_get(Eo *o EINA_UNUSED, Efl_Net_Dialer_Tcp_Data *pd)
{
return pd->timeout_dial;
}
EOLIAN static void
_efl_net_dialer_tcp_efl_net_dialer_connected_set(Eo *o, Efl_Net_Dialer_Tcp_Data *pd, Eina_Bool connected)
{
efl_net_dialer_* use timeout promise instead of timer object. i wasn't aware of efl_loop_timeout for one-shot timeout promises, then use it instead of a full object.
2016-09-13 12:08:25 -07:00
if (pd->connect.timeout)
ecore,ecore_con: fix migration to efl_future. Efl_Future actually work with weak reference. So you do not need to set things to NULL, but you actually need to register the memory location of the future with efl_future_use.
2016-09-16 18:21:11 -07:00
efl_future_cancel(pd->connect.timeout);
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 (pd->connected == connected) return;
pd->connected = connected;
efl callbacks: update some events calls to no longer trigger legacy callbacks
2016-08-29 16:13:22 -07:00
if (connected) efl_event_callback_call(o, EFL_NET_DIALER_EVENT_CONNECTED, 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
}
EOLIAN static Eina_Bool
_efl_net_dialer_tcp_efl_net_dialer_connected_get(Eo *o EINA_UNUSED, Efl_Net_Dialer_Tcp_Data *pd)
{
return pd->connected;
}
EOLIAN static Eina_Error
efl_net_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
_efl_net_dialer_tcp_efl_io_closer_close(Eo *o, Efl_Net_Dialer_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_dialer_tcp: make asynchronous resolve and connect. both resolve (getaddrinfo()) and connect() are now done in Ecore_Thread, avoid to block the main loop. My plan is to always use the threaded connect() using a blocking socket, only set it to non-blocking after the socket is returned to the main thread and before it's accessible to the user. It will make the connect behavior more uniform. Some errors were moved from HTTP to Dialer as they are more generic.
2016-09-09 16:09:51 -07:00
pd->closed = EINA_TRUE;
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_dialer_connected_set(o, EINA_FALSE);
return efl_io_closer_close(efl_super(o, MY_CLASS));
}
#include "efl_net_dialer_tcp.eo.c"