Obsolete
/
libipc-old
Archived
3
0
Fork 0
This repository has been archived on 2024-06-18. You can view files and clone it, but cannot push or open issues/pull-requests.
libipc-old/lib/communication.c

506 lines
12 KiB
C
Raw Normal View History

2016-05-26 18:27:59 +02:00
#include "communication.h"
#include <stdio.h>
#include <time.h>
2016-05-26 18:27:59 +02:00
2016-06-05 03:19:36 +02:00
int file_open (FILE **f, const char *path, const char *mode)
{
printf ("opening %s\n", path);
if (*f != NULL) {
printf ("f != NULL : %p\n", (void*) *f);
2016-06-12 12:38:43 +02:00
if (file_close (*f)) {
return ER_FILE_CLOSE;
}
}
2016-06-05 03:19:36 +02:00
*f = fopen (path, mode);
if (*f == NULL) {
fprintf (stderr, "\033[31mnot opened\033[00m\n");
2016-06-12 12:38:43 +02:00
return ER_FILE_OPEN;
2016-06-05 03:19:36 +02:00
}
printf ("opened : %ld\n", (long) *f);
return 0;
}
int file_close (FILE *f)
{
if (f != 0) {
printf ("before fclosing\n");
2016-06-12 12:38:43 +02:00
if (fclose (f)) {
return ER_FILE_CLOSE;
}
2016-06-05 03:19:36 +02:00
printf ("after fclosing\n");
}
return 0;
}
2016-06-12 12:38:43 +02:00
int file_read (FILE *f, char **buf, size_t *msize) {
if (*msize == 0) {
*msize = BUFSIZ; // default value
}
if (*buf == NULL) {
*buf = malloc (*msize);
if (*buf == NULL) {
fprintf (stderr, "err can't allocate enough memory (%ld)\n", *msize);
int ret = file_close (f);
if (ret != 0)
return ret;
}
}
*msize = fread (*buf, *msize, 1, f);
if (*msize == 0) {
fprintf (stderr, "err can't read a file\n");
if (ER_FILE_CLOSE == file_close (f)) {
fprintf (stderr, "err closing the file\n");
return ER_FILE_CLOSE;
}
return ER_FILE_READ;
}
return 0;
}
int file_write (FILE *f, const char *buf, size_t msize)
{
if (0 == fwrite (buf, msize, 1, f)) {
fprintf (stderr, "err writing in the file\n");
if (ER_FILE_CLOSE == file_close (f)) {
fprintf (stderr, "err closing the file\n");
return ER_FILE_CLOSE;
}
return ER_FILE_WRITE;
}
return 0;
}
2016-06-05 20:48:13 +02:00
void srv_init (struct service *srv, const char *sname)
2016-05-26 18:27:59 +02:00
{
2016-06-05 20:48:13 +02:00
if (srv == NULL)
return;
2016-05-26 18:27:59 +02:00
2016-06-05 20:48:13 +02:00
// gets the service path, such as /tmp/<service>
memset (srv->spath, 0, PATH_MAX);
2016-06-12 12:38:43 +02:00
strncat (srv->spath, TMPDIR, PATH_MAX -1);
strncat (srv->spath, sname, PATH_MAX -1);
2016-05-26 18:27:59 +02:00
2016-06-05 20:48:13 +02:00
srv->version = COMMUNICATION_VERSION;
srv->index = 0; // TODO
2016-05-26 18:27:59 +02:00
}
2016-06-05 20:48:13 +02:00
// SERVICE
int srv_create (struct service *srv)
2016-05-26 18:27:59 +02:00
{
int ret;
2016-06-05 20:48:13 +02:00
if ((ret = mkfifo (srv->spath, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH))) {
switch (errno) {
case EACCES :
2016-06-05 20:48:13 +02:00
printf ("file %s : EACCES\n", srv->spath);
return 1;
case EEXIST :
2016-06-05 20:48:13 +02:00
printf ("file %s : EEXIST\n", srv->spath);
break;
case ENAMETOOLONG :
2016-06-05 20:48:13 +02:00
printf ("file %s : ENAMETOOLONG\n", srv->spath);
return 2;
case ENOENT :
2016-06-05 20:48:13 +02:00
printf ("file %s : ENOENT\n", srv->spath);
return 3;
case ENOSPC :
2016-06-05 20:48:13 +02:00
printf ("file %s : ENOSPC\n", srv->spath);
return 4;
case ENOTDIR :
2016-06-05 20:48:13 +02:00
printf ("file %s : ENOTDIR\n", srv->spath);
return 5;
case EROFS :
2016-06-05 20:48:13 +02:00
printf ("file %s : EROFS\n", srv->spath);
return 6;
default :
2016-06-05 20:48:13 +02:00
printf ("err file %s unknown\n", srv->spath);
return 7;
}
2016-05-26 18:27:59 +02:00
}
return 0;
}
2016-06-05 20:48:13 +02:00
int srv_close (struct service *srv)
2016-05-26 18:27:59 +02:00
{
2016-06-05 20:48:13 +02:00
if (unlink (srv->spath)) {
2016-05-26 18:27:59 +02:00
return 1;
}
return 0;
}
2016-06-07 11:45:21 +02:00
// 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);
memset (*buf, 0, BUFSIZ);
2016-06-07 11:45:21 +02:00
2016-06-12 12:38:43 +02:00
FILE * f = NULL;
if (file_open (&f, srv->spath, "rb")) {
return ER_FILE_OPEN;
}
char *ret = NULL;
ret = fgets (*buf, BUFSIZ, f);
if (ret == NULL) {
return ER_FILE_READ;
}
buf[0][BUFSIZ -1] = '\0';
if (file_close (f)) {
return ER_FILE_CLOSE;
}
2016-06-07 11:45:21 +02:00
*msize = strlen (*buf);
return 0;
}
int srv_get_new_process (const struct service *srv, struct process *p)
2016-05-26 18:27:59 +02:00
{
2016-06-05 20:48:13 +02:00
if (srv->spath == NULL) {
return -1;
}
2016-05-26 18:27:59 +02:00
char buf[BUFSIZ];
memset (buf, 0, BUFSIZ);
2016-05-26 18:27:59 +02:00
// read the pipe, get a process to work on
struct timespec ts = { 0 };
struct timespec ts2 = { 0 };
2016-06-12 12:38:43 +02:00
FILE * f = NULL;
if (file_open (&f, srv->spath, "rb")) {
return ER_FILE_OPEN;
}
clock_gettime(CLOCK_REALTIME, &ts);
2016-06-12 12:38:43 +02:00
char *ret = NULL;
ret = fgets (buf, BUFSIZ, f);
if (ret == NULL) {
if (file_close (f)) {
return ER_FILE_CLOSE;
}
return ER_FILE_READ;
}
clock_gettime(CLOCK_REALTIME, &ts2);
2016-06-12 12:38:43 +02:00
if (file_close (f)) {
return ER_FILE_CLOSE;
}
2016-05-26 21:56:43 +02:00
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);
2016-05-26 18:27:59 +02:00
char *token = NULL, *saveptr = NULL;
char *str = NULL;
int i = 0;
2016-05-26 18:27:59 +02:00
pid_t pid = 0;
int index = 0;
int version = 0;
2016-06-05 03:19:36 +02:00
2016-05-26 21:56:43 +02:00
for (str = buf, i = 1; ; str = NULL, i++) {
token = strtok_r(str, " ", &saveptr);
2016-05-26 18:27:59 +02:00
if (token == NULL)
break;
2016-05-26 21:56:43 +02:00
if (i == 1) {
2016-06-05 03:19:36 +02:00
pid = strtoul(token, NULL, 10);
2016-05-26 18:27:59 +02:00
}
2016-05-26 21:56:43 +02:00
else if (i == 2) {
2016-06-05 03:19:36 +02:00
index = strtoul(token, NULL, 10);
}
else if (i == 3) {
2016-06-05 03:19:36 +02:00
version = strtoul(token, NULL, 10);
2016-05-26 18:27:59 +02:00
}
}
2016-06-05 03:19:36 +02:00
srv_process_gen (p, pid, index, version);
2016-06-07 11:45:21 +02:00
return 0;
}
int srv_read_cb (struct process *p, char ** buf, size_t * msize
, int (*cb)(FILE *f, char ** buf, size_t * msize))
{
2016-06-08 17:57:05 +02:00
if (file_open (&p->out, p->path_out, "rb")) {
fprintf (stderr, "\033[31merr: srv_read_cb, file_open\033[00m\n");
2016-06-12 12:38:43 +02:00
if (ER_FILE_CLOSE == file_close (p->out)) {
fprintf (stderr, "err closing the file %s\n", p->path_out);
p->out = NULL;
}
return ER_FILE_OPEN;
2016-06-08 17:57:05 +02:00
}
2016-06-07 11:45:21 +02:00
2016-06-12 12:38:43 +02:00
if (cb != NULL) {
int ret = (*cb) (p->out, buf, msize);
if (ret != 0)
return ret;
}
else {
int ret = file_read (p->out, buf, msize);
if (ret != 0) {
return ret;
}
}
2016-06-07 11:45:21 +02:00
// printf ("DEBUG read, size %ld : %s\n", *msize, *buf);
2016-06-12 12:38:43 +02:00
if (ER_FILE_CLOSE == file_close (p->out)) {
fprintf (stderr, "err closing the file %s\n", p->path_out);
p->out = NULL;
}
p->out = NULL;
2016-06-07 11:45:21 +02:00
return 0;
}
2016-05-26 21:56:43 +02:00
2016-06-07 11:45:21 +02:00
int srv_read (struct process *p, char ** buf, size_t * msize)
{
2016-06-12 12:38:43 +02:00
if (ER_FILE_OPEN == file_open (&p->out, p->path_out, "rb")) {
fprintf (stderr, "err opening the file %s\n", p->path_out);
return ER_FILE_OPEN;
}
int ret = file_read (p->out, buf, msize);
if (ret != 0) {
p->out = NULL;
return ret;
}
2016-06-05 03:19:36 +02:00
// printf ("DEBUG read, size %ld : %s\n", *msize, buf);
2016-06-12 12:38:43 +02:00
if (ER_FILE_CLOSE == file_close (p->out)) {
fprintf (stderr, "err closing the file %s\n", p->path_out);
p->out = NULL;
return ER_FILE_CLOSE;
}
p->out = NULL;
2016-06-05 03:19:36 +02:00
return 0;
2016-05-26 21:56:43 +02:00
}
2016-06-12 12:38:43 +02:00
int srv_write (struct process *p, char * buf, size_t msize)
2016-05-26 21:56:43 +02:00
{
2016-06-12 12:38:43 +02:00
if (ER_FILE_OPEN == file_open (&p->in, p->path_in, "wb")) {
fprintf (stderr, "err opening the file %s\n", p->path_in);
return ER_FILE_OPEN;
}
2016-05-26 21:56:43 +02:00
2016-06-12 12:38:43 +02:00
int ret = file_write (p->in, buf, msize);
if (ret != 0) {
fprintf (stderr, "err writing in the file %s\n", p->path_in);
p->in = NULL;
return ret;
}
2016-06-12 12:38:43 +02:00
if (ER_FILE_CLOSE == file_close (p->in)) {
fprintf (stderr, "err closing the file %s\n", p->path_in);
p->in = NULL;
return ER_FILE_CLOSE;
}
p->in = NULL;
2016-05-26 18:27:59 +02:00
2016-06-05 03:19:36 +02:00
return 0;
2016-05-26 18:27:59 +02:00
}
2016-06-05 03:19:36 +02:00
// APPLICATION
2016-05-26 18:27:59 +02:00
// 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;
2016-06-12 12:38:43 +02:00
if (ER_FILE_OPEN == file_open (&f, srv->spath, "wb")) {
fprintf (stderr, "err opening the service file %s\n", srv->spath);
return ER_FILE_OPEN;
}
2016-06-12 12:38:43 +02:00
int ret = file_write (f, connectionstr, msize);
if (ret != 0) {
fprintf (stderr, "err writing in the service file %s\n", srv->spath);
return ret;
}
2016-06-12 12:38:43 +02:00
if (ER_FILE_CLOSE == file_close (f)) {
fprintf (stderr, "err closing the file\n");
return ER_FILE_CLOSE;
}
return 0;
}
2016-06-05 03:19:36 +02:00
int app_create (struct process *p, int index)
2016-05-26 18:27:59 +02:00
{
pid_t pid = getpid();
2016-06-05 03:19:36 +02:00
// then creates the structure
srv_process_gen (p, pid, index, COMMUNICATION_VERSION);
2016-05-26 18:27:59 +02:00
// creates the pipes
int ret;
2016-06-05 03:19:36 +02:00
if ((ret = mkfifo (p->path_in, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)))
{
switch (errno) {
case EACCES :
2016-06-05 03:19:36 +02:00
printf ("file %s : EACCES\n", p->path_in);
return 1;
case EEXIST :
2016-06-05 03:19:36 +02:00
printf ("file %s : EEXIST\n", p->path_in);
break;
case ENAMETOOLONG :
2016-06-05 03:19:36 +02:00
printf ("file %s : ENAMETOOLONG\n", p->path_in);
return 2;
case ENOENT :
2016-06-05 03:19:36 +02:00
printf ("file %s : ENOENT\n", p->path_in);
return 3;
case ENOSPC :
2016-06-05 03:19:36 +02:00
printf ("file %s : ENOSPC\n", p->path_in);
return 4;
case ENOTDIR :
2016-06-05 03:19:36 +02:00
printf ("file %s : ENOTDIR\n", p->path_in);
return 5;
case EROFS :
2016-06-05 03:19:36 +02:00
printf ("file %s : EROFS\n", p->path_in);
return 6;
default :
2016-06-05 03:19:36 +02:00
printf ("err file %s unknown\n", p->path_in);
return 7;
}
2016-05-26 18:27:59 +02:00
}
2016-06-05 03:19:36 +02:00
if ((ret = mkfifo (p->path_out, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH))) {
switch (errno) {
case EACCES :
2016-06-05 03:19:36 +02:00
printf ("file %s : EACCES\n", p->path_out);
return 1;
case EEXIST :
2016-06-05 03:19:36 +02:00
printf ("file %s : EEXIST\n", p->path_out);
break;
case ENAMETOOLONG :
2016-06-05 03:19:36 +02:00
printf ("file %s : ENAMETOOLONG\n", p->path_out);
return 2;
case ENOENT :
2016-06-05 03:19:36 +02:00
printf ("file %s : ENOENT\n", p->path_out);
return 3;
case ENOSPC :
2016-06-05 03:19:36 +02:00
printf ("file %s : ENOSPC\n", p->path_out);
return 4;
case ENOTDIR :
2016-06-05 03:19:36 +02:00
printf ("file %s : ENOTDIR\n", p->path_out);
return 5;
case EROFS :
2016-06-05 03:19:36 +02:00
printf ("file %s : EROFS\n", p->path_out);
return 6;
default :
2016-06-05 03:19:36 +02:00
printf ("err file %s unknown\n", p->path_out);
return 7;
}
2016-05-26 18:27:59 +02:00
}
return 0;
}
2016-06-05 03:19:36 +02:00
int app_destroy (struct process *p)
2016-05-26 18:27:59 +02:00
{
2016-06-05 03:19:36 +02:00
if (unlink (p->path_in)) {
2016-05-26 18:27:59 +02:00
return 1;
}
2016-06-05 03:19:36 +02:00
if (unlink (p->path_out)) {
2016-05-26 18:27:59 +02:00
return 1;
}
return 0;
}
2016-06-08 17:57:05 +02:00
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")) {
2016-06-12 12:38:43 +02:00
fprintf (stderr, "\033[31merr: app_read_cb, file_open\033[00m\n");
p->in = NULL;
2016-06-08 17:57:05 +02:00
return 1;
}
2016-06-12 12:38:43 +02:00
if (cb != NULL) {
int ret = (*cb) (p->in, buf, msize);
if (ret != 0)
return ret;
}
else {
int ret = file_read (p->in, buf, msize);
if (ret != 0) {
p->in = NULL;
return ret;
}
}
2016-06-08 17:57:05 +02:00
2016-06-12 12:38:43 +02:00
if (ER_FILE_CLOSE == file_close (p->in)) {
fprintf (stderr, "err closing the file %s\n", p->path_in);
}
p->in = NULL;
2016-06-08 17:57:05 +02:00
return 0;
}
2016-06-12 12:38:43 +02:00
int app_read (struct process *p, char ** buf, size_t * msize)
{
2016-06-12 12:38:43 +02:00
if (ER_FILE_OPEN == file_open (&p->in, p->path_in, "rb")) {
fprintf (stderr, "err opening the file %s\n", p->path_in);
return ER_FILE_OPEN;
}
2016-06-12 12:38:43 +02:00
int ret = file_read (p->in, buf, msize);
if (ret != 0) {
p->in = NULL;
return ret;
}
2016-06-12 12:38:43 +02:00
if (ER_FILE_CLOSE == file_close (p->in)) {
fprintf (stderr, "err closing the file %s\n", p->path_in);
p->in = NULL;
return ER_FILE_CLOSE;
}
p->in = NULL;
2016-05-26 21:56:43 +02:00
2016-05-26 18:27:59 +02:00
return 0;
}
2016-06-12 12:38:43 +02:00
int app_write (struct process *p, char * buf, size_t msize)
2016-05-26 18:27:59 +02:00
{
2016-06-12 12:38:43 +02:00
if (ER_FILE_OPEN == file_open (&p->out, p->path_out, "wb")) {
fprintf (stderr, "err opening the file %s\n", p->path_out);
return ER_FILE_OPEN;
}
2016-05-26 21:56:43 +02:00
2016-06-12 12:38:43 +02:00
int ret = file_write (p->out, buf, msize);
if (ret != 0) {
fprintf (stderr, "err writing in the file %s\n", p->path_out);
p->out = NULL;
return ret;
}
2016-06-12 12:38:43 +02:00
if (ER_FILE_CLOSE == file_close (p->out)) {
fprintf (stderr, "err closing the file %s\n", p->path_out);
p->out = NULL;
return ER_FILE_CLOSE;
}
p->out = NULL;
2016-05-26 21:56:43 +02:00
2016-05-26 18:27:59 +02:00
return 0;
}