enlightenment/express
enlightenment
/
express
6
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Add ability to resolv server actual name (from IP address). This is 

going to be used so we can send messages to specific channels, but the
messages come in with the actual server name (ie: not irc.freenode.net
but the Actual name), so we need to resolv the IP address from
ecore_con into a real server name.

Signed-off-by: Chris Michael <cp.michael@samsung.com>
This commit is contained in:
Chris Michael 2014-12-11 14:12:42 -05:00
parent ef33c33479
commit f063c61121
5 changed files with 84 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
src/lib/Express.h
View File

@ -128,27 +128,23 @@ typedef struct _Express_Callbacks
EXAPI int express_init(void);
EXAPI int express_shutdown(void);
/* Public network functions */
EXAPI Express_Network *express_network_find(const char *name);
EXAPI Express_Network *express_network_create(Express_Callbacks *callbacks, const char *name);
EXAPI void express_network_destroy(Express_Network *net);
EXAPI void express_network_name_set(Express_Network *net, const char *name);
EXAPI const char *express_network_name_get(Express_Network *net);
EXAPI void express_network_username_set(Express_Network *net, const char *name);
EXAPI const char *express_network_username_get(Express_Network *net);
EXAPI void express_network_username_send(Express_Network *net);
EXAPI void express_network_nickname_set(Express_Network *net, const char *name);
EXAPI const char *express_network_nickname_get(Express_Network *net);
EXAPI void express_network_nickname_send(Express_Network *net);
EXAPI void express_network_nick_password_set(Express_Network *net, const char *passwd);
EXAPI void express_network_nick_password_send(Express_Network *net);
EXAPI void express_network_nick_strip(const char *buff, char *nick, size_t size);
EXAPI void express_network_server_password_set(Express_Network *net, const char *passwd);
EXAPI void express_network_server_password_send(Express_Network *net);
EXAPI void express_network_autoconnect_set(Express_Network *net, Eina_Bool autoconnect);
EXAPI Eina_Bool express_network_autoconnect_get(Express_Network *net);
EXAPI void express_network_bypass_proxy_set(Express_Network *net, Eina_Bool bypass);
@ -159,12 +155,13 @@ EXAPI Eina_Bool express_network_connecting_get(Express_Network *net);
EXAPI Eina_Bool express_network_connected_get(Express_Network *net);
EXAPI void express_network_connect(Express_Network *net);
EXAPI void express_network_disconnect(Express_Network *net);
EXAPI Express_Server *express_network_server_find(Express_Network *net, const char *server_name);
EXAPI Express_Server *express_network_server_add(Express_Network *net, const char *server_name, int port);
EXAPI void express_network_server_del(Express_Network *net, const char *server_name);
EXAPI Express_Server *express_network_server_connected_get(Express_Network *net);
EXAPI void express_network_data_send(Express_Network *net, const char *data, int len);
EXAPI const char *express_network_server_name_get(Express_Server *srv);
EXAPI const char *express_network_server_realname_get(Express_Server *srv);
/* # ifdef __cplusplus */
/* } */

52
src/lib/main.c
View File

@ -1,4 +1,7 @@
#include "private.h"
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
/* local variables */
static int_least8_t _init_count = 0;
@ -27,36 +30,64 @@ _cb_networks_free(void *data)
free(net);
}
static char *
_server_name_get(char *hostname)
{
struct hostent *hent;
struct in_addr addr;
if (!inet_aton(hostname, &addr)) return hostname;
if ((hent =
gethostbyaddr((char *)&(addr.s_addr), sizeof(addr.s_addr), AF_INET)))
{
strcpy(hostname, hent->h_name);
}
return hostname;
}
static Eina_Bool
_cb_server_add(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
{
Ecore_Con_Event_Server_Add *ev;
Express_Network *net;
const char *server;
const char *server, *ip;
char *name;
ev = event;
if (!(net = ecore_con_server_data_get(ev->server)))
return ECORE_CALLBACK_RENEW;
server = ecore_con_server_name_get(ev->server);
DBG("Server Added %s %s", net->name, server);
ip = ecore_con_server_ip_get(ev->server);
name = _server_name_get(strdup(ip));
DBG("Server Added %s %s", server, ip);
DBG("\tResolved Name: %s", name);
net->connecting = EINA_FALSE;
net->connected = ecore_con_server_connected_get(ev->server);
if (net->connected)
{
Express_Server *srv;
if ((srv = express_network_server_find(net, server)))
{
srv->skip = EINA_FALSE;
srv->connected = EINA_TRUE;
eina_stringshare_replace(&srv->realname, name);
}
if (net->callbacks.connect)
(*net->callbacks.connect)(net, "CONNECT", server, NULL, 0,
net->callbacks.data);
/* NB: RFC says send Pass, Nick, User to register */
/* express_network_server_password_send(net); */
/* express_network_nick_password_send(net); */
/* express_network_nickname_send(net); */
/* express_network_username_send(net); */
}
free(name);
return ECORE_CALLBACK_RENEW;
}
@ -89,7 +120,10 @@ _cb_server_del(void *data EINA_UNUSED, int type EINA_UNUSED, void *event)
/* find this server in the network list */
if ((srv = express_network_server_find(net, server_name)))
srv->skip = EINA_TRUE;
{
srv->skip = EINA_TRUE;
srv->connected = EINA_FALSE;
}
/* try the next server
* NB: This function will iterate existing servers and ignore

35
src/lib/network.c
View File

@ -7,6 +7,7 @@ _cb_server_free(void *data)
if (!(srv = data)) return;
if (srv->name) eina_stringshare_del(srv->name);
if (srv->realname) eina_stringshare_del(srv->realname);
free(srv);
}
@ -655,6 +656,40 @@ express_network_server_find(Express_Network *net, const char *server_name)
return eina_hash_find(net->servers, server_name);
}
EXAPI const char *
express_network_server_name_get(Express_Server *srv)
{
return srv->name;
}
EXAPI const char *
express_network_server_realname_get(Express_Server *srv)
{
return srv->realname;
}
EXAPI Express_Server *
express_network_server_connected_get(Express_Network *net)
{
Eina_Iterator *iter;
Express_Server *srv = NULL;
Eina_Bool found = EINA_FALSE;
iter = eina_hash_iterator_data_new(net->servers);
EINA_ITERATOR_FOREACH(iter, srv)
{
if (srv->connected)
{
found = EINA_TRUE;
break;
}
}
eina_iterator_free(iter);
if (found) return srv;
return NULL;
}
EXAPI Express_Server *
express_network_server_add(Express_Network *net, const char *server_name, int port)
{

2
src/lib/private.h
View File

@ -80,9 +80,11 @@ struct _Express_Network
struct _Express_Server
{
const char *name;
const char *realname;
int port;
Eina_Bool skip : 1;
Eina_Bool connected : 1;
};
extern Eina_Hash *_networks;

119
src/lib/server.c
View File

@ -1,119 +0,0 @@
#include "private.h"
void
_server_pass_send(Express_Server *server)
{
char buff[512];
int len = 0;
len = snprintf(buff, sizeof(buff), "PASS %s\r\n", server->pass);
ecore_con_server_send(server->conn, buff, len);
}
void
_server_user_send(Express_Server *server)
{
char buff[512], host[64];
int len = 0;
gethostname(host, 63);
len = snprintf(buff, sizeof(buff), "USER %s %s %s :%s\r\n",
server->nick, host, server->name, server->user);
ecore_con_server_send(server->conn, buff, len);
}
void
_server_nick_send(Express_Server *server)
{
char buff[512];
int len = 0;
len = snprintf(buff, sizeof(buff), "NICK %s\r\n", server->nick);
ecore_con_server_send(server->conn, buff, len);
}
EXAPI Express_Server *
express_server_find(const char *name)
{
if (!name) return NULL;
return eina_hash_find(_servers, name);
}
EXAPI Express_Server *
express_server_create(const char *name, const char *nick, const char *user, const char *pass, int port, Eina_Bool use_ssl, Eina_Bool bypass_proxy)
{
Express_Server *srv;
if (!(srv = calloc(1, sizeof(Express_Server)))) return NULL;
if (name) srv->name = eina_stringshare_add(name);
if (nick) srv->nick = eina_stringshare_add(nick);
if (user) srv->user = eina_stringshare_add(user);
if (pass) srv->pass = eina_stringshare_add(pass);
srv->port = port;
srv->use_ssl = use_ssl;
srv->bypass_proxy = bypass_proxy;
srv->connecting = EINA_FALSE;
srv->connected = EINA_FALSE;
eina_hash_direct_add(_servers, srv->name, srv);
return srv;
}
EXAPI void
express_server_destroy(Express_Server *server)
{
if (!server) return;
eina_hash_del_by_key(_servers, server->name);
}
EXAPI void
express_server_connect(Express_Server *server)
{
int flags = 0;
if (!server) return;
server->connecting = EINA_TRUE;
flags = ECORE_CON_REMOTE_SYSTEM;
if (server->use_ssl) flags |= ECORE_CON_USE_MIXED;
if (server->bypass_proxy) flags |= ECORE_CON_NO_PROXY;
server->conn =
ecore_con_server_connect(flags,
server->name, server->port, server);
}
EXAPI void
express_server_disconnect(Express_Server *server)
{
if (!server) return;
server->connecting = EINA_FALSE;
if (ecore_con_server_connected_get(server->conn))
{
char buff[512];
int len = 0;
len = snprintf(buff, sizeof(buff), "QUIT\r\n");
ecore_con_server_send(server->conn, buff, len);
ecore_con_server_flush(server->conn);
ecore_con_server_del(server->conn);
}
}
EXAPI Eina_Bool
express_server_connecting_get(Express_Server *server)
{
if (!server) return EINA_FALSE;
return server->connecting;
}
EXAPI Eina_Bool
express_server_connected_get(Express_Server *server)
{
if (!server) return EINA_FALSE;
return server->connected;
}