365 lines
8.7 KiB
C
365 lines
8.7 KiB
C
#include "communication.h"
|
|
#include <stdio.h>
|
|
#include <time.h>
|
|
|
|
int file_open (FILE **f, const char *path, const char *mode)
|
|
{
|
|
printf ("opening %s\n", path);
|
|
if (*f != NULL) {
|
|
printf ("f != NULL : %p\n", *f);
|
|
fclose (*f);
|
|
}
|
|
*f = fopen (path, mode);
|
|
if (*f == NULL) {
|
|
fprintf (stderr, "\033[31mnot opened\033[00m\n");
|
|
return -1;
|
|
}
|
|
printf ("opened : %ld\n", (long) *f);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int file_close (FILE *f)
|
|
{
|
|
if (f != 0) {
|
|
printf ("before fclosing\n");
|
|
fclose (f);
|
|
printf ("after fclosing\n");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void srv_init (struct service *srv, const char *sname)
|
|
{
|
|
if (srv == NULL)
|
|
return;
|
|
|
|
// gets the service path, such as /tmp/<service>
|
|
bzero (srv->spath, PATH_MAX);
|
|
strncat (srv->spath, TMPDIR, PATH_MAX);
|
|
strncat (srv->spath, sname, PATH_MAX);
|
|
|
|
srv->version = COMMUNICATION_VERSION;
|
|
srv->index = 0; // TODO
|
|
}
|
|
|
|
// SERVICE
|
|
|
|
int srv_create (struct service *srv)
|
|
{
|
|
int ret;
|
|
if ((ret = mkfifo (srv->spath, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH))) {
|
|
switch (errno) {
|
|
case EACCES :
|
|
printf ("file %s : EACCES\n", srv->spath);
|
|
return 1;
|
|
case EEXIST :
|
|
printf ("file %s : EEXIST\n", srv->spath);
|
|
break;
|
|
case ENAMETOOLONG :
|
|
printf ("file %s : ENAMETOOLONG\n", srv->spath);
|
|
return 2;
|
|
case ENOENT :
|
|
printf ("file %s : ENOENT\n", srv->spath);
|
|
return 3;
|
|
case ENOSPC :
|
|
printf ("file %s : ENOSPC\n", srv->spath);
|
|
return 4;
|
|
case ENOTDIR :
|
|
printf ("file %s : ENOTDIR\n", srv->spath);
|
|
return 5;
|
|
case EROFS :
|
|
printf ("file %s : EROFS\n", srv->spath);
|
|
return 6;
|
|
default :
|
|
printf ("err file %s unknown\n", srv->spath);
|
|
return 7;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int srv_close (struct service *srv)
|
|
{
|
|
if (unlink (srv->spath)) {
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
// only get a raw line from TMPDIR/<service>
|
|
int srv_get_listen_raw (const struct service *srv, char **buf, size_t *msize)
|
|
{
|
|
*buf = malloc(BUFSIZ);
|
|
bzero (*buf, BUFSIZ);
|
|
|
|
FILE * f = fopen (srv->spath, "r");
|
|
fgets (*buf, BUFSIZ, f);
|
|
fclose (f);
|
|
|
|
*msize = strlen (*buf);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int srv_get_new_process (const struct service *srv, struct process *p)
|
|
{
|
|
if (srv->spath == NULL) {
|
|
return -1;
|
|
}
|
|
|
|
char buf[BUFSIZ];
|
|
bzero (buf, BUFSIZ);
|
|
|
|
// read the pipe, get a process to work on
|
|
struct timespec ts = { 0 };
|
|
struct timespec ts2 = { 0 };
|
|
|
|
FILE * f = fopen (srv->spath, "r");
|
|
clock_gettime(CLOCK_REALTIME, &ts);
|
|
fgets (buf, BUFSIZ, f);
|
|
clock_gettime(CLOCK_REALTIME, &ts2);
|
|
fclose (f);
|
|
|
|
printf("sec: %ld nsec: %ld\n", ts.tv_sec, ts.tv_nsec);
|
|
printf("sec: %ld nsec: %ld\n", ts2.tv_sec, ts2.tv_nsec);
|
|
|
|
printf("diff nsec: %ld\n", ts2.tv_nsec - ts.tv_nsec);
|
|
|
|
char *token = NULL, *saveptr = NULL;
|
|
char *str = NULL;
|
|
int i = 0;
|
|
|
|
pid_t pid = 0;
|
|
int index = 0;
|
|
int version = 0;
|
|
|
|
for (str = buf, i = 1; ; str = NULL, i++) {
|
|
token = strtok_r(str, " ", &saveptr);
|
|
if (token == NULL)
|
|
break;
|
|
|
|
if (i == 1) {
|
|
pid = strtoul(token, NULL, 10);
|
|
}
|
|
else if (i == 2) {
|
|
index = strtoul(token, NULL, 10);
|
|
}
|
|
else if (i == 3) {
|
|
version = strtoul(token, NULL, 10);
|
|
}
|
|
}
|
|
|
|
srv_process_gen (p, pid, index, version);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int srv_read_cb (struct process *p, char ** buf, size_t * msize
|
|
, int (*cb)(FILE *f, char ** buf, size_t * msize))
|
|
{
|
|
if (file_open (&p->out, p->path_out, "rb")) {
|
|
fprintf (stderr, "\033[31merr: srv_read_cb, file_open\033[00m\n");
|
|
file_close (p->out);
|
|
return 1;
|
|
}
|
|
|
|
if (cb != NULL)
|
|
(*cb) (p->out, buf, msize);
|
|
else
|
|
*msize = fread (*buf, 1, *msize, p->out); // FIXME check errors
|
|
// printf ("DEBUG read, size %ld : %s\n", *msize, *buf);
|
|
|
|
if (file_close (p->out))
|
|
return 1;
|
|
p->out = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int srv_read (struct process *p, char ** buf, size_t * msize)
|
|
{
|
|
if (file_open (&p->out, p->path_out, "rb"))
|
|
return 1;
|
|
|
|
*msize = fread (*buf, 1, *msize, p->out); // FIXME check errors
|
|
// printf ("DEBUG read, size %ld : %s\n", *msize, buf);
|
|
|
|
if (file_close (p->out))
|
|
return 1;
|
|
p->out = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int srv_write (struct process *p, void * buf, size_t msize)
|
|
{
|
|
if (file_open (&p->in, p->path_in, "wb"))
|
|
return 1;
|
|
|
|
fwrite (buf, 1, msize, p->in); // FIXME check errors
|
|
|
|
if (file_close (p->in))
|
|
return 1;
|
|
p->in = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
// APPLICATION
|
|
|
|
// send the connection string to $TMP/<service>
|
|
int app_srv_connection (struct service *srv, const char *connectionstr, size_t msize)
|
|
{
|
|
if (srv == NULL) {
|
|
return 1;
|
|
}
|
|
|
|
FILE * f = NULL;
|
|
if (file_open (&f, srv->spath, "wb"))
|
|
return 2;
|
|
|
|
fwrite (connectionstr, msize, 1, f); // FIXME check errors
|
|
|
|
if (file_close (f))
|
|
return 3;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int app_create (struct process *p, int index)
|
|
{
|
|
pid_t pid = getpid();
|
|
|
|
// then creates the structure
|
|
srv_process_gen (p, pid, index, COMMUNICATION_VERSION);
|
|
|
|
// creates the pipes
|
|
int ret;
|
|
if ((ret = mkfifo (p->path_in, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)))
|
|
{
|
|
switch (errno) {
|
|
case EACCES :
|
|
printf ("file %s : EACCES\n", p->path_in);
|
|
return 1;
|
|
case EEXIST :
|
|
printf ("file %s : EEXIST\n", p->path_in);
|
|
break;
|
|
case ENAMETOOLONG :
|
|
printf ("file %s : ENAMETOOLONG\n", p->path_in);
|
|
return 2;
|
|
case ENOENT :
|
|
printf ("file %s : ENOENT\n", p->path_in);
|
|
return 3;
|
|
case ENOSPC :
|
|
printf ("file %s : ENOSPC\n", p->path_in);
|
|
return 4;
|
|
case ENOTDIR :
|
|
printf ("file %s : ENOTDIR\n", p->path_in);
|
|
return 5;
|
|
case EROFS :
|
|
printf ("file %s : EROFS\n", p->path_in);
|
|
return 6;
|
|
default :
|
|
printf ("err file %s unknown\n", p->path_in);
|
|
return 7;
|
|
}
|
|
}
|
|
|
|
if ((ret = mkfifo (p->path_out, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH))) {
|
|
switch (errno) {
|
|
case EACCES :
|
|
printf ("file %s : EACCES\n", p->path_out);
|
|
return 1;
|
|
case EEXIST :
|
|
printf ("file %s : EEXIST\n", p->path_out);
|
|
break;
|
|
case ENAMETOOLONG :
|
|
printf ("file %s : ENAMETOOLONG\n", p->path_out);
|
|
return 2;
|
|
case ENOENT :
|
|
printf ("file %s : ENOENT\n", p->path_out);
|
|
return 3;
|
|
case ENOSPC :
|
|
printf ("file %s : ENOSPC\n", p->path_out);
|
|
return 4;
|
|
case ENOTDIR :
|
|
printf ("file %s : ENOTDIR\n", p->path_out);
|
|
return 5;
|
|
case EROFS :
|
|
printf ("file %s : EROFS\n", p->path_out);
|
|
return 6;
|
|
default :
|
|
printf ("err file %s unknown\n", p->path_out);
|
|
return 7;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int app_destroy (struct process *p)
|
|
{
|
|
if (unlink (p->path_in)) {
|
|
return 1;
|
|
}
|
|
|
|
if (unlink (p->path_out)) {
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
int app_read_cb (struct process *p, char ** buf, size_t * msize
|
|
, int (*cb)(FILE *f, char ** buf, size_t * msize))
|
|
{
|
|
if (file_open (&p->in, p->path_in, "rb")) {
|
|
fprintf (stderr, "\033[31merr: srv_read_cb, file_open\033[00m\n");
|
|
file_close (p->in);
|
|
return 1;
|
|
}
|
|
|
|
if (cb != NULL)
|
|
(*cb) (p->in, buf, msize);
|
|
else
|
|
*msize = fread (*buf, 1, *msize, p->in); // FIXME check errors
|
|
|
|
if (file_close (p->in))
|
|
return 1;
|
|
p->in = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int app_read (struct process *p, void * buf, size_t * msize)
|
|
{
|
|
if (file_open (&p->in, p->path_in, "rb"))
|
|
return 1;
|
|
|
|
*msize = fread (buf, 1, *msize, p->in); // FIXME check errors
|
|
// printf ("DEBUG read, size %ld : %s\n", *msize, buf);
|
|
|
|
if (file_close (p->in))
|
|
return 1;
|
|
p->in = NULL;
|
|
|
|
return 0;
|
|
}
|
|
|
|
int app_write (struct process *p, void * buf, size_t msize)
|
|
{
|
|
if (file_open (&p->out, p->path_out, "wb"))
|
|
return 1;
|
|
|
|
fwrite (buf, 1, msize, p->out); // FIXME check errors
|
|
|
|
if (file_close (p->out))
|
|
return 1;
|
|
p->out = NULL;
|
|
|
|
return 0;
|
|
}
|