159 lines
3.6 KiB
C
159 lines
3.6 KiB
C
#include "communication.h"
|
|
#include "usocket.h"
|
|
#include "utils.h"
|
|
#include "error.h"
|
|
|
|
#include <assert.h>
|
|
#include <stdio.h>
|
|
#include <errno.h>
|
|
|
|
void service_path (char *path, const char *sname, int index, int version)
|
|
{
|
|
assert (path != NULL);
|
|
assert (sname != NULL);
|
|
memset (path, 0, PATH_MAX);
|
|
snprintf (path, PATH_MAX, "%s/%s-%d-%d", TMPDIR, sname, index, version);
|
|
}
|
|
|
|
int srv_init (int argc, char **argv, char **env
|
|
, struct service *srv, const char *sname)
|
|
{
|
|
if (srv == NULL)
|
|
return ER_PARAMS;
|
|
|
|
// TODO
|
|
// use the argc, argv and env parameters
|
|
// it will be useful to change some parameters transparently
|
|
// ex: to get resources from other machines, choosing the
|
|
// remote with environment variables
|
|
|
|
argc = argc;
|
|
argv = argv;
|
|
env = env;
|
|
|
|
// gets the service path
|
|
service_path (srv->spath, sname, srv->index, srv->version);
|
|
|
|
usock_init (&srv->service_fd, srv->spath);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int srv_accept (struct service *srv, struct process *p)
|
|
{
|
|
assert (srv != NULL);
|
|
assert (p != NULL);
|
|
|
|
usock_accept (srv->service_fd, &p->proc_fd);
|
|
|
|
struct msg m_con;
|
|
memset (&m_con, 0, sizeof (struct msg));
|
|
srv_read (p, &m_con);
|
|
// TODO: handle the parameters in the first message
|
|
msg_free (&m_con);
|
|
|
|
struct msg m_ack;
|
|
memset (&m_ack, 0, sizeof (struct msg));
|
|
msg_format_ack (&m_ack, NULL, 0);
|
|
srv_write (p, &m_ack);
|
|
msg_free (&m_ack);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int srv_close (struct service *srv)
|
|
{
|
|
usock_close (srv->service_fd);
|
|
return usock_remove (srv->spath);
|
|
}
|
|
|
|
int srv_close_proc (struct process *p)
|
|
{
|
|
struct msg m;
|
|
memset (&m, 0, sizeof (struct msg));
|
|
m.type = MSG_TYPE_DIS;
|
|
if (msg_write (p->proc_fd, &m) < 0) {
|
|
handle_err ("srv_close_proc", "msg_write < 0");
|
|
}
|
|
|
|
return usock_close (p->proc_fd);
|
|
}
|
|
|
|
int srv_read (const struct process *p, struct msg *m)
|
|
{
|
|
return msg_read (p->proc_fd, m);
|
|
}
|
|
|
|
int srv_write (const struct process *p, const struct msg *m)
|
|
{
|
|
return msg_write (p->proc_fd, m);
|
|
}
|
|
|
|
int app_connection (int argc, char **argv, char **env
|
|
, struct service *srv, const char *sname
|
|
, const char *connectionstr, size_t msize)
|
|
{
|
|
argc = argc;
|
|
argv = argv;
|
|
env = env;
|
|
|
|
assert (srv != NULL);
|
|
assert (sname != NULL);
|
|
|
|
if (srv == NULL) {
|
|
return -1;
|
|
}
|
|
|
|
// gets the service path
|
|
service_path (srv->spath, sname, srv->index, srv->version);
|
|
|
|
usock_connect (&srv->service_fd, srv->spath);
|
|
|
|
// send connection string and receive acknowledgement
|
|
struct msg m_con;
|
|
memset (&m_con, 0, sizeof (struct msg));
|
|
|
|
// format the connection msg
|
|
if (msg_format_con (&m_con, connectionstr, msize) < 0) {
|
|
handle_err ("app_connection", "msg_format_con");
|
|
return -1;
|
|
}
|
|
|
|
// send connection msg
|
|
app_write (srv, &m_con);
|
|
msg_free (&m_con);
|
|
|
|
// receive ack msg
|
|
struct msg m_ack;
|
|
memset (&m_ack, 0, sizeof (struct msg));
|
|
app_read (srv, &m_ack);
|
|
|
|
assert (m_ack.type == MSG_TYPE_ACK);
|
|
assert (m_ack.valsize == 0);
|
|
msg_free (&m_ack);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int app_close (struct service *srv)
|
|
{
|
|
struct msg m;
|
|
memset (&m, 0, sizeof (struct msg));
|
|
m.type = MSG_TYPE_DIS;
|
|
if (msg_write (srv->service_fd, &m) < 0) {
|
|
handle_err ("app_close", "msg_write < 0");
|
|
}
|
|
|
|
return usock_close (srv->service_fd);
|
|
}
|
|
|
|
int app_read (struct service *srv, struct msg *m)
|
|
{
|
|
return msg_read (srv->service_fd, m);
|
|
}
|
|
|
|
int app_write (struct service *srv, const struct msg *m)
|
|
{
|
|
return msg_write (srv->service_fd, m);
|
|
}
|