enlightenment
/
marrakesh
7
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
marrakesh/mrklib_serv.c

462 lines
13 KiB
C
Raw Blame History

#include "mrklib_priv.h"
struct _Mrk_Serve
{
const char *listen;
int port;
const char *repodir;
const char *bldsh;
Ecore_Ipc_Server *server;
Eina_List *handlers;
Eina_Inlist *clients;
Mrk_Repodb *rdb;
};
typedef struct
{
EINA_INLIST;
Mrk_Serve *server;
Ecore_Ipc_Client *client;
const char *uuid;
const char *arch;
const char *version;
const char *file;
const char *dir;
FILE *f;
Ecore_Exe *exe;
} Client;
static void
client_upload_cancel(Client *c)
{
if (c->f) fclose(c->f);
if (c->file) eina_stringshare_del(c->file);
if (c->dir)
{
ecore_file_recursive_rm(c->dir);
eina_stringshare_del(c->dir);
}
c->f = NULL;
c->file = NULL;
c->dir = NULL;
}
static void
client_upload_new(Client *c, const char *file)
{
char tmp[PATH_MAX];
Eina_Tmpstr *s = NULL;
if (c->f) client_upload_cancel(c);
c->file = eina_stringshare_add(file);
if (!c->file) return;
if (eina_file_mkdtemp("marrekesh-up-XXXXXX", &s))
{
c->dir = eina_stringshare_add(s);
eina_tmpstr_del(s);
if (c->dir)
{
snprintf(tmp, sizeof(tmp), "%s/%s", c->dir, c->file);
c->f = fopen(tmp, "wb");
}
}
}
static void
client_upload_data(Client *c, void *data, int size)
{
if (c->f) fwrite(data, size, 1, c->f);
}
static void
client_upload_end(Client *c)
{
char tmp[PATH_MAX];
if (c->f)
{
fclose(c->f);
c->f = NULL;
snprintf(tmp, sizeof(tmp), "%s %s %s",
c->server->bldsh, c->dir, c->server->repodir);
c->exe = ecore_exe_pipe_run(tmp,
ECORE_EXE_TERM_WITH_PARENT |
ECORE_EXE_NOT_LEADER, c);
if (c->exe) ecore_exe_tag_set(c->exe, "-=# mrk serve - build exe #=-");
}
}
static void
client_send(Client *c, const char *subrepo, const char *name, int op_start, int op_data, int op_end)
{
char tmp[PATH_MAX];
char *lnk;
snprintf(tmp, sizeof(tmp), "%s/%s/%s", c->server->repodir, subrepo, name);
lnk = ecore_file_readlink(tmp);
if (!lnk)
ecore_ipc_client_send(c->client, M_OP, op_start, 0, 0, 0,
NULL, 0);
else
{
FILE *f = fopen(tmp, "rb");
if (!f)
ecore_ipc_client_send(c->client, M_OP, op_start, 0, 0, 0,
NULL, 0);
else
{
long sz, pos;
fseek(f, 0, SEEK_END);
sz = ftell(f);
fseek(f, 0, SEEK_SET);
ecore_ipc_client_send(c->client, M_OP, op_start, (int)sz, 0, 0,
lnk, strlen(lnk));
for (pos = 0; pos < sz;)
{
size_t size;
char buf[10000];
size = fread(buf, 1, 10000, f);
if (size <= 0) break;
pos += size;
ecore_ipc_client_send(c->client, M_OP, op_data,
(int)pos, (int)sz, 0,
buf, size);
}
ecore_ipc_client_send(c->client, M_OP, op_end, 0, 0, 0,
NULL, 0);
fclose(f);
}
free(lnk);
}
}
static Eina_Bool
_mrk_id_data(Mrk_Serve *server EINA_UNUSED, Client *c, Ecore_Ipc_Event_Client_Data *e)
{
if (e->minor == M_ID_UUID)
{
char *str = _mrk_util_proto_cli_string(e);
if (str)
{
eina_stringshare_replace(&(c->uuid), str);
free(str);
}
return EINA_TRUE;
}
else if (e->minor == M_ID_VERSION)
{
char *str = _mrk_util_proto_cli_string(e);
if (str)
{
eina_stringshare_replace(&(c->version), str);
free(str);
}
return EINA_TRUE;
}
else if (e->minor == M_ID_ARCH)
{
char *str = _mrk_util_proto_cli_string(e);
if (str)
{
if (_mrk_util_arch_ok(str))
eina_stringshare_replace(&(c->arch), str);
free(str);
}
return EINA_TRUE;
}
return EINA_FALSE;
}
static Eina_Bool
_mrk_upload_data(Mrk_Serve *server EINA_UNUSED, Client *c, Ecore_Ipc_Event_Client_Data *e)
{
if ((!c->uuid) || (!c->version) || (!c->arch)) return EINA_FALSE;
if (e->minor == M_UP_START)
{
char *str = _mrk_util_proto_cli_string(e);
if (str)
{
if (_mrk_util_plain_file_check(str))
client_upload_new(c, str);
free(str);
}
return EINA_TRUE;
}
else if (e->minor == M_UP_DATA)
{
if ((e->data) && (e->size <= 10000))
client_upload_data(c, e->data, e->size);
return EINA_TRUE;
}
else if (e->minor == M_UP_END)
{
client_upload_end(c);
return EINA_TRUE;
}
return EINA_FALSE;
}
static Eina_Bool
_mrk_query_data(Mrk_Serve *server EINA_UNUSED, Client *c, Ecore_Ipc_Event_Client_Data *e)
{
if ((!c->uuid) || (!c->version) || (!c->arch)) return EINA_FALSE;
if (e->minor == M_QRY_LIST)
{
const Eina_List *list = NULL, *l;
ecore_ipc_client_send(c->client, M_OP, M_ANS_START, 0, 0, 0, NULL, 0);
if (!e->data) list = mrk_repodb_category_list(c->server->rdb,
c->arch, NULL);
else
{
char *str = _mrk_util_proto_cli_string(e);
if (str)
{
list = mrk_repodb_category_list(c->server->rdb,
c->arch, str);
free(str);
}
}
if (list)
{
const char *s;
EINA_LIST_FOREACH(list, l, s)
{
ecore_ipc_client_send(c->client, M_OP, M_ANS_DATA,
0, 0, 0,
s, strlen(s));
}
}
ecore_ipc_client_send(c->client, M_OP, M_ANS_END, 0, 0, 0, NULL, 0);
return EINA_TRUE;
}
else if (e->minor == M_QRY_SEARCH)
{
ecore_ipc_client_send(c->client, M_OP, M_ANS_START, 0, 0, 0, NULL, 0);
if (e->data)
{
char *str = _mrk_util_proto_cli_string(e);
if (str)
{
Eina_List *list;
const char *s;
list = mrk_repodb_search(c->server->rdb, c->arch, str);
EINA_LIST_FREE(list, s)
{
ecore_ipc_client_send(c->client, M_OP, M_ANS_DATA,
0, 0, 0,
s, strlen(s));
eina_stringshare_del(s);
}
free(str);
}
}
ecore_ipc_client_send(c->client, M_OP, M_ANS_END, 0, 0, 0, NULL, 0);
return EINA_TRUE;
}
else if (e->minor == M_QRY_GET)
{
char *str = _mrk_util_proto_cli_string(e);
if (str)
{
if (_mrk_util_plain_file_check(str))
client_send(c, c->arch, str,
M_DOWN_START, M_DOWN_DATA, M_DOWN_END);
free(str);
}
return EINA_TRUE;
}
else if (e->minor == M_QRY_GETSRC)
{
char *str = _mrk_util_proto_cli_string(e);
if (str)
{
if (_mrk_util_plain_file_check(str))
client_send(c, "src", str,
M_SRC_START, M_SRC_DATA, M_SRC_END);
free(str);
}
return EINA_TRUE;
}
return EINA_FALSE;
}
static Eina_Bool
_mrk_inf_data(Mrk_Serve *server EINA_UNUSED, Client *c, Ecore_Ipc_Event_Client_Data *e)
{
if ((!c->uuid) || (!c->version) || (!c->arch)) return EINA_FALSE;
if (e->minor == M_INF_GET_IC)
{
char *str = _mrk_util_proto_cli_string(e);
if (str)
{
if (_mrk_util_plain_file_check(str))
{
char *str2 = malloc(strlen(str) + 1 + 8);
if (str2)
{
strcpy(str2, str);
strcat(str2, ".icn.png");
client_send(c, "src", str2,
M_INF_START, M_INF_DATA, M_INF_END);
free(str2);
}
}
free(str);
}
return EINA_TRUE;
}
return EINA_FALSE;
}
static Eina_Bool
_mrk_data_handle(Mrk_Serve *server, Client *c, Ecore_Ipc_Event_Client_Data *e)
{
if ((e->minor > M_UP_B) && (e->minor < M_UP_E))
return _mrk_upload_data(server, c, e);
else if ((e->minor > M_QRY_B) && (e->minor < M_QRY_E))
return _mrk_query_data(server, c, e);
else if ((e->minor > M_ID_B) && (e->minor < M_ID_E))
return _mrk_id_data(server, c, e);
else if ((e->minor > M_INF_B) && (e->minor < M_INF_E))
return _mrk_inf_data(server, c, e);
return EINA_FALSE;
}
static Eina_Bool
_mrk_cb_add(void *data, int type EINA_UNUSED, void *event)
{
Ecore_Ipc_Event_Client_Add *e = event;
Mrk_Serve *server = data;
Client *c;
if (server->server != ecore_ipc_client_server_get(e->client)) return EINA_TRUE;
c = calloc(1, sizeof(Client));
c->server = server;
c->client = e->client;
ecore_ipc_client_data_set(e->client, c);
server->clients = eina_inlist_append(server->clients, EINA_INLIST_GET(c));
return EINA_FALSE;
}
static Eina_Bool
_mrk_cb_del(void *data, int type EINA_UNUSED, void *event)
{
Ecore_Ipc_Event_Client_Del *e = event;
Mrk_Serve *server = data;
Client *c;
if (server->server != ecore_ipc_client_server_get(e->client)) return EINA_TRUE;
c = ecore_ipc_client_data_get(e->client);
if (c)
{
client_upload_cancel(c);
eina_stringshare_del(c->uuid);
eina_stringshare_del(c->arch);
eina_stringshare_del(c->version);
if (c->exe) ecore_exe_free(c->exe);
server->clients = eina_inlist_remove(server->clients,
EINA_INLIST_GET(c));
free(c);
}
return EINA_FALSE;
}
static Eina_Bool
_mrk_cb_data(void *data, int type EINA_UNUSED, void *event)
{
Ecore_Ipc_Event_Client_Data *e = event;
Mrk_Serve *server = data;
Client *c;
if (server->server != ecore_ipc_client_server_get(e->client)) return EINA_TRUE;
c = ecore_ipc_client_data_get(e->client);
if (!c) return EINA_TRUE;
if (e->major != M_OP) return EINA_TRUE;
if (!_mrk_data_handle(server, c, e)) return EINA_TRUE;
return EINA_FALSE;
}
static Eina_Bool
_mrk_cb_exe_del(void *data, int type EINA_UNUSED, void *event)
{
Ecore_Exe_Event_Del *e = event;
Mrk_Serve *server = data;
Client *c;
const char *tag;
if (!e->exe) return EINA_TRUE;
tag = ecore_exe_tag_get(e->exe);
if (!tag) return EINA_TRUE;
if (!strcmp(tag, "-=# mrk serve - build exe #=-"))
{
c = ecore_exe_data_get(e->exe);
if (!c) return EINA_TRUE;
if (c->exe != e->exe) return EINA_TRUE;
c->exe = NULL;
if (e->exit_code == 0)
{
ecore_ipc_client_send(c->client, M_OP, M_UP_OK, 0, 0, 0, NULL, 0);
mrk_repodb_update(server->rdb);
}
else
ecore_ipc_client_send(c->client, M_OP, M_UP_FAIL, 0, 0, 0, NULL, 0);
return EINA_FALSE;
}
return EINA_TRUE;
}
EAPI Mrk_Serve *
mrk_serve(const char *listen, int port, const char *repodir, const char *bldsh)
{
Mrk_Serve *server;
server = calloc(1, sizeof(Mrk_Serve));
if (!server) return server;
if (!listen) listen = "0.0.0.0";
if (port <= 0) port = MRK_SERVER_PORT;
server->listen = eina_stringshare_add(listen);
server->port = port;
server->repodir = eina_stringshare_add(repodir);
server->bldsh = eina_stringshare_add(bldsh);
server->handlers = eina_list_append(server->handlers,
ecore_event_handler_add
(ECORE_IPC_EVENT_CLIENT_ADD,
_mrk_cb_add, server));
server->handlers = eina_list_append(server->handlers,
ecore_event_handler_add
(ECORE_IPC_EVENT_CLIENT_DEL,
_mrk_cb_del, server));
server->handlers = eina_list_append(server->handlers,
ecore_event_handler_add
(ECORE_IPC_EVENT_CLIENT_DATA,
_mrk_cb_data, server));
server->handlers = eina_list_append(server->handlers,
ecore_event_handler_add
(ECORE_EXE_EVENT_DEL,
_mrk_cb_exe_del, server));
server->server = ecore_ipc_server_add(ECORE_IPC_REMOTE_SYSTEM,
server->listen, server->port, server);
server->rdb = mrk_repodb_load(repodir);
return server;
}
EAPI void
mrk_unserve(Mrk_Serve *server)
{
Ecore_Event_Handler *hnd;
mrk_repodb_free(server->rdb);
ecore_ipc_server_del(server->server);
EINA_LIST_FREE(server->handlers, hnd) ecore_event_handler_del(hnd);
eina_stringshare_del(server->listen);
eina_stringshare_del(server->repodir);
eina_stringshare_del(server->bldsh);
if (!server) return;
free(server);
}
Reference in New Issue View Git Blame Copy Permalink