Merge branch 'master' of ssh://git.karchnu.fr:2202/Karchnu/perfectos-junk
commit
6b2e6d6135
|
|
@ -1,4 +1,6 @@
|
|||
#include "communication.h"
|
||||
#include <stdio.h>
|
||||
#include <time.h>
|
||||
|
||||
int service_path (char *buf, const char *sname)
|
||||
{
|
||||
|
|
@ -70,17 +72,29 @@ int service_close (const char *fifopath)
|
|||
return 0;
|
||||
}
|
||||
|
||||
// FIXME only works for a single process
|
||||
void service_get_new_processes (struct process **proc, int *nproc, int sfifo)
|
||||
int service_get_new_process (struct process *proc, const char * spath)
|
||||
{
|
||||
if (spath == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
char buf[BUFSIZ];
|
||||
bzero (buf, BUFSIZ);
|
||||
read (sfifo, buf, BUFSIZ);
|
||||
|
||||
//proc[0] = malloc(sizeof(struct process*) * 1); // FIXME
|
||||
proc[0] = malloc(sizeof(struct process) * 1); // FIXME
|
||||
// read the pipe, get a process to work on
|
||||
struct timespec ts = { 0 };
|
||||
struct timespec ts2 = { 0 };
|
||||
|
||||
// unsigned long long int val = strtoul(s, NULL, 10);
|
||||
FILE * f = fopen (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, *saveptr;
|
||||
char *str;
|
||||
|
|
@ -91,27 +105,71 @@ void service_get_new_processes (struct process **proc, int *nproc, int sfifo)
|
|||
if (token == NULL)
|
||||
break;
|
||||
|
||||
printf ("token : %s\n", token);
|
||||
|
||||
// do something
|
||||
if (i == 1) {
|
||||
int index = strchr (token, '-') - token;
|
||||
char * buf_pid = strndup (token, index);
|
||||
proc[0]->pid = strtoul(buf_pid, NULL, 10);
|
||||
proc[0]->index = strtoul(token + index +1, NULL, 10);
|
||||
|
||||
printf ("buf_pid : %s\n", buf_pid);
|
||||
printf ("pid : %d\n", proc[0]->pid);
|
||||
printf ("index : %d\n", proc[0]->index);
|
||||
proc->pid = strtoul(token, NULL, 10);
|
||||
}
|
||||
else if (i == 2) {
|
||||
// FIXME
|
||||
proc[0]->version = strtoul(token, NULL, 10);
|
||||
proc->index = strtoul(token, NULL, 10);
|
||||
}
|
||||
else if (i == 3) {
|
||||
proc->version = strtoul(token, NULL, 10);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
*nproc = 1;
|
||||
return 1;
|
||||
}
|
||||
|
||||
// FIXME only works for a single process
|
||||
void service_get_new_processes (struct process ***proc, int *nproc, char * spath)
|
||||
{
|
||||
if (proc == NULL || spath == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
char buf[BUFSIZ];
|
||||
bzero (buf, BUFSIZ);
|
||||
|
||||
// read the pipe, get a process to work on
|
||||
FILE * f = fopen (spath, "rb");
|
||||
fgets (buf, BUFSIZ, f);
|
||||
fclose (f);
|
||||
|
||||
char *token, *line, *saveptr, *saveptr2;
|
||||
char *str, *str2;
|
||||
int i, j;
|
||||
|
||||
*nproc = 0;
|
||||
proc[0] = malloc(sizeof(struct process**));
|
||||
|
||||
for (str2 = buf, j = 1; ; str2 = NULL, j++) {
|
||||
line = strtok_r(str2, "\n", &saveptr2);
|
||||
if (line == NULL)
|
||||
break;
|
||||
|
||||
printf ("line : %s\n", line);
|
||||
|
||||
*nproc = *nproc +1;
|
||||
|
||||
proc[0] = realloc(proc[0], sizeof(struct process*) * (*nproc));
|
||||
proc[0][*nproc -1] = malloc(sizeof(struct process));
|
||||
|
||||
for (str = line, i = 1; ; str = NULL, i++) {
|
||||
token = strtok_r(str, " ", &saveptr);
|
||||
if (token == NULL)
|
||||
break;
|
||||
|
||||
if (i == 1) {
|
||||
proc[0][*nproc -1]->pid = strtoul(token, NULL, 10);
|
||||
}
|
||||
else if (i == 2) {
|
||||
proc[0][*nproc -1]->index = strtoul(token, NULL, 10);
|
||||
}
|
||||
else if (i == 3) {
|
||||
proc[0][*nproc -1]->version = strtoul(token, NULL, 10);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void struct_process_free (struct process * p)
|
||||
|
|
@ -121,7 +179,10 @@ void struct_process_free (struct process * p)
|
|||
|
||||
void service_free_processes (struct process **procs, int nproc)
|
||||
{
|
||||
while (--nproc != -1) {
|
||||
printf ("free processes\n");
|
||||
while (nproc--) {
|
||||
printf ("free process %d\n", nproc);
|
||||
|
||||
struct_process_free (procs[nproc]);
|
||||
}
|
||||
}
|
||||
|
|
@ -135,7 +196,8 @@ void gen_process_structure (struct process *p
|
|||
}
|
||||
|
||||
|
||||
void process_print (struct process *p) {
|
||||
void process_print (struct process *p)
|
||||
{
|
||||
printf ("process %d : index %d\n", p->pid, p->index);
|
||||
}
|
||||
|
||||
|
|
@ -238,6 +300,44 @@ int process_open_in (struct process *proc)
|
|||
|
||||
printf ("opening in %s\n", fifopathin);
|
||||
proc->in = fopen (fifopathin, "rb");
|
||||
if (proc->in == NULL) {
|
||||
fprintf (stderr, "\033[31mnot opened\033[00m\n");
|
||||
return -1;
|
||||
}
|
||||
printf ("opened : %d\n", proc->in);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int service_proc_open_in (struct process *proc)
|
||||
{
|
||||
char fifopathin[PATH_MAX];
|
||||
char fifopathout[PATH_MAX];
|
||||
process_paths (fifopathin, fifopathout, proc->pid, proc->index);
|
||||
|
||||
printf ("opening in %s\n", fifopathin);
|
||||
proc->in = fopen (fifopathin, "wb");
|
||||
if (proc->in == NULL) {
|
||||
fprintf (stderr, "\033[31mnot opened\033[00m\n");
|
||||
return -1;
|
||||
}
|
||||
printf ("opened : %d\n", proc->in);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int service_proc_open_out (struct process *proc)
|
||||
{
|
||||
char fifopathin[PATH_MAX];
|
||||
char fifopathout[PATH_MAX];
|
||||
process_paths (fifopathin, fifopathout, proc->pid, proc->index);
|
||||
|
||||
printf ("opening out %s\n", fifopathout);
|
||||
proc->out = fopen (fifopathout, "rb");
|
||||
if (proc->out == NULL) {
|
||||
fprintf (stderr, "\033[31mnot opened\033[00m\n");
|
||||
return -1;
|
||||
}
|
||||
printf ("opened\n");
|
||||
|
||||
return 0;
|
||||
|
|
@ -251,22 +351,10 @@ int process_open_out (struct process *proc)
|
|||
|
||||
printf ("opening out %s\n", fifopathout);
|
||||
proc->out = fopen (fifopathout, "wb");
|
||||
printf ("opened\n");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int process_open (struct process *proc)
|
||||
{
|
||||
char fifopathin[PATH_MAX];
|
||||
char fifopathout[PATH_MAX];
|
||||
process_paths (fifopathin, fifopathout, proc->pid, proc->index);
|
||||
|
||||
printf ("opening %s\n", fifopathin);
|
||||
proc->in = fopen (fifopathin, "rb");
|
||||
printf ("opening %s\n", fifopathout);
|
||||
proc->out = fopen (fifopathout, "wb");
|
||||
if (proc->out == NULL) {
|
||||
fprintf (stderr, "\033[31mnot opened\033[00m\n");
|
||||
return -1;
|
||||
}
|
||||
printf ("opened\n");
|
||||
|
||||
return 0;
|
||||
|
|
@ -276,7 +364,9 @@ int process_close_in (struct process *proc)
|
|||
{
|
||||
printf ("closing in\n");
|
||||
if (proc->in != 0) {
|
||||
printf ("before fclose in\n");
|
||||
fclose (proc->in);
|
||||
printf ("after fclose in\n");
|
||||
proc->in = 0;
|
||||
}
|
||||
return 0;
|
||||
|
|
@ -297,15 +387,14 @@ int process_read (struct process *proc, void * buf, size_t * msize)
|
|||
{
|
||||
int ret;
|
||||
if ((ret = process_open_in (proc))) {
|
||||
fprintf(stdout, "error process_create %d\n", ret);
|
||||
exit (1);
|
||||
return 1;
|
||||
}
|
||||
|
||||
*msize = fread (buf, 1, *msize, proc->in); // FIXME check errors
|
||||
// printf ("DEBUG read, size %ld : %s\n", *msize, buf);
|
||||
|
||||
if ((ret = process_close_in (proc))) {
|
||||
fprintf(stdout, "error process_close_in %d\n", ret);
|
||||
exit (1);
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
|
@ -315,31 +404,45 @@ int process_write (struct process *proc, void * buf, size_t msize)
|
|||
{
|
||||
int ret;
|
||||
if ((ret = process_open_out (proc))) {
|
||||
fprintf(stdout, "error process_create %d\n", ret);
|
||||
exit (1);
|
||||
return 1;
|
||||
}
|
||||
|
||||
fwrite (buf, 1, msize, proc->out); // FIXME check errors
|
||||
|
||||
if ((ret = process_close_out (proc))) {
|
||||
fprintf(stdout, "error process_close_out %d\n", ret);
|
||||
exit (1);
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int service_read (struct process *proc, void * buf, size_t * msize)
|
||||
{
|
||||
if ((*msize = fread (buf, 1, *msize, proc->out)))
|
||||
return *msize;
|
||||
int ret;
|
||||
if ((ret = service_proc_open_out (proc))) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
*msize = fread (buf, 1, *msize, proc->out); // FIXME check errors
|
||||
// printf ("DEBUG read, size %ld : %s\n", *msize, buf);
|
||||
|
||||
if ((ret = process_close_out (proc))) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int service_write (struct process *proc, void * buf, size_t msize)
|
||||
{
|
||||
if ((msize = fwrite (buf, 1, msize, proc->in)))
|
||||
return msize;
|
||||
int ret;
|
||||
if ((ret = service_proc_open_in (proc))) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
fwrite (buf, 1, msize, proc->in); // FIXME check errors
|
||||
|
||||
if ((ret = process_close_in (proc))) {
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@
|
|||
|
||||
#include <errno.h> // error numbers
|
||||
|
||||
#define TMPDIR "/tmp/"
|
||||
#define TMPDIR "/tmp/ipc/"
|
||||
|
||||
#define COMMUNICATION_VERSION 1
|
||||
|
||||
|
|
@ -27,6 +27,11 @@ struct process {
|
|||
FILE *in, *out;
|
||||
};
|
||||
|
||||
struct service {
|
||||
unsigned int version;
|
||||
unsigned int index;
|
||||
};
|
||||
|
||||
// TODO create the service process structure
|
||||
|
||||
int service_path (char *buf, const char *sname);
|
||||
|
|
@ -44,17 +49,18 @@ void gen_process_structure (struct process *p
|
|||
int service_create (const char *sname);
|
||||
int service_close (const char *sname);
|
||||
|
||||
void service_get_new_processes (struct process **, int *nproc, int sfifo);
|
||||
int service_get_new_process (struct process *proc, const char * spath);
|
||||
void service_get_new_processes (struct process ***, int *nproc, char *spath);
|
||||
void service_free_processes (struct process **, int nproc);
|
||||
|
||||
void process_print (struct process *);
|
||||
int process_create (struct process *, int index); // called by the application
|
||||
int process_destroy (struct process *); // called by the application
|
||||
|
||||
int process_open (struct process *); // called by the service & application
|
||||
int process_close (struct process *); // called by the service & application
|
||||
|
||||
int process_read (struct process *, void * buf, size_t *);
|
||||
int process_write (struct process *, void * buf, size_t);
|
||||
|
||||
int service_read (struct process *, void * buf, size_t *);
|
||||
int service_write (struct process *, void * buf, size_t);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -0,0 +1,22 @@
|
|||
CC=gcc
|
||||
CFLAGS=-Wall -g
|
||||
LDFLAGS=
|
||||
CFILES=$(wildcard *.c) # CFILES => recompiles everything on a C file change
|
||||
EXEC=$(basename $(wildcard *.c))
|
||||
SOURCES=$(wildcard ../lib/*.c)
|
||||
OBJECTS=$(SOURCES:.c=.o)
|
||||
TESTS=$(addsuffix .test, $(EXEC))
|
||||
|
||||
all: $(SOURCES) $(EXEC)
|
||||
|
||||
$(EXEC): $(OBJECTS) $(CFILES)
|
||||
$(CC) $(CFLAGS) $(LDFLAGS) $(OBJECTS) $@.c -o $@
|
||||
|
||||
.c.o:
|
||||
$(CC) -c $(CFLAGS) $< -o $@
|
||||
|
||||
clean:
|
||||
-rm $(OBJECTS)
|
||||
|
||||
mrproper: clean
|
||||
rm $(EXEC)
|
||||
|
|
@ -0,0 +1,31 @@
|
|||
# Service ping-pong
|
||||
|
||||
This service is a brain-dead application. It is only to a pedagogic end.
|
||||
|
||||
The purpose is only to communicate with an application once, the application
|
||||
sends a message and the service answer with the same message.
|
||||
|
||||
# How it works
|
||||
|
||||
* **S**: service
|
||||
* **A**: application
|
||||
|
||||
1. **S** creates the named pipe /tmp/pingpong, then listens
|
||||
2. **S** opens the named pipes in & out
|
||||
3. **A** talks with the test program *pingpong.sh*
|
||||
4. **S** closes the test program named pipes
|
||||
5. **S** removes the named pipe /tmp/pingpong after 10 served applications
|
||||
|
||||
# pingpong.sh
|
||||
|
||||
The script *pingpong.sh* lets you test the service.
|
||||
|
||||
Usage :
|
||||
|
||||
pingpong.sh [NB]
|
||||
# NB is the number of exchanged messages
|
||||
|
||||
or
|
||||
|
||||
pingpong.sh clean
|
||||
# it is to clean the /tmp/ipc/ directory
|
||||
|
|
@ -0,0 +1,88 @@
|
|||
#include "../lib/communication.h"
|
||||
|
||||
/*
|
||||
* main loop
|
||||
*
|
||||
* opens the application pipes,
|
||||
* reads then writes the same message,
|
||||
* then closes the pipes
|
||||
*/
|
||||
|
||||
void main_loop (const char *spath)
|
||||
{
|
||||
int ret;
|
||||
struct process proc;
|
||||
|
||||
int cnt = 10;
|
||||
|
||||
while (cnt--) {
|
||||
// -1 : error, 0 = no new process, 1 = new process
|
||||
ret = service_get_new_process (&proc, spath);
|
||||
if (ret == -1) {
|
||||
fprintf (stderr, "error service_get_new_process\n");
|
||||
continue;
|
||||
} else if (ret == 0) { // that should not happen
|
||||
continue;
|
||||
}
|
||||
|
||||
// printf ("before print\n");
|
||||
process_print (&proc);
|
||||
// printf ("after print\n");
|
||||
|
||||
// about the message
|
||||
size_t msize = BUFSIZ;
|
||||
char buf[BUFSIZ];
|
||||
bzero(buf, BUFSIZ);
|
||||
|
||||
// printf ("before read\n");
|
||||
if ((ret = service_read (&proc, &buf, &msize))) {
|
||||
fprintf(stdout, "error service_read %d\n", ret);
|
||||
continue;
|
||||
}
|
||||
// printf ("after read\n");
|
||||
printf ("read, size %ld : %s\n", msize, buf);
|
||||
|
||||
// printf ("before proc write\n");
|
||||
if ((ret = service_write (&proc, &buf, msize))) {
|
||||
fprintf(stdout, "error service_write %d\n", ret);
|
||||
continue;
|
||||
}
|
||||
// printf ("after proc write\n");
|
||||
printf ("\033[32mStill \033[31m%d\033[32m applications to serve\n",cnt);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* service ping-pong
|
||||
*
|
||||
* 1. creates the named pipe /tmp/<service>, then listens
|
||||
* 2. opens the named pipes in & out
|
||||
* 3. talks with the (test) program
|
||||
* 4. closes the test program named pipes
|
||||
* 5. removes the named pipe /tmp/<service>
|
||||
*/
|
||||
|
||||
int main(int argc, char * argv[])
|
||||
{
|
||||
// gets the service path, such as /tmp/<service>
|
||||
char spath[PATH_MAX];
|
||||
service_path (spath, "pingpong");
|
||||
|
||||
// creates the service named pipe, that listens to client applications
|
||||
int ret;
|
||||
if ((ret = service_create (spath))) {
|
||||
fprintf(stdout, "error service_create %d\n", ret);
|
||||
exit (1);
|
||||
}
|
||||
|
||||
// the service will loop until the end of time, a specific message, a signal
|
||||
main_loop (spath);
|
||||
|
||||
// the application will shut down, and remove the service named pipe
|
||||
if ((ret = service_close (spath))) {
|
||||
fprintf(stdout, "error service_close %d\n", ret);
|
||||
exit (1);
|
||||
}
|
||||
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
|
@ -0,0 +1,37 @@
|
|||
#!/bin/dash
|
||||
|
||||
REP=/tmp/ipc/
|
||||
SERVICE="pingpong"
|
||||
NB=3
|
||||
|
||||
# CLEAN UP !
|
||||
if [ $# -ne 0 ] && [ "$1" = clean ]
|
||||
then
|
||||
echo "clean rep ${REP}"
|
||||
rm ${REP}/${SERVICE}
|
||||
rm ${REP}/*-in
|
||||
rm ${REP}/*-out
|
||||
|
||||
exit 0
|
||||
fi
|
||||
|
||||
if [ $# -ne 0 ]
|
||||
then
|
||||
NB=$1
|
||||
fi
|
||||
|
||||
for pid in `seq 1 ${NB}`
|
||||
do
|
||||
# we make the application pipes
|
||||
mkfifo ${REP}/${pid}-1-in 2>/dev/null
|
||||
mkfifo ${REP}/${pid}-1-out 2>/dev/null
|
||||
|
||||
# pid index version
|
||||
echo "${pid} 1 1" > ${REP}/${SERVICE}
|
||||
|
||||
# the purpose is to send something in the pipe
|
||||
cat /dev/urandom | base64 | head -n 1 > ${REP}/${pid}-1-out
|
||||
|
||||
# the the service will answer with our message
|
||||
cat ${REP}/${pid}-1-in
|
||||
done
|
||||
|
|
@ -1,84 +0,0 @@
|
|||
#include "lib/communication.h"
|
||||
|
||||
/*
|
||||
* main loop
|
||||
*
|
||||
* opens the application pipes,
|
||||
* reads then writes the same message,
|
||||
* then closes the pipes
|
||||
*/
|
||||
|
||||
void main_loop (const char *spath)
|
||||
{
|
||||
int ret;
|
||||
int sfifo = open (spath, S_IRUSR); // opens the service named pipe
|
||||
|
||||
struct process *proc;
|
||||
int nproc = 0;
|
||||
|
||||
do {
|
||||
service_get_new_processes (&proc, &nproc, sfifo);
|
||||
|
||||
printf ("nb proc : %d\n", nproc);
|
||||
|
||||
// for each process : open, read, write, close
|
||||
for (int i = 0 ; i < nproc ; i++) {
|
||||
process_print (&proc[i]);
|
||||
|
||||
// about the message
|
||||
size_t msize = BUFSIZ;
|
||||
char buf[BUFSIZ];
|
||||
|
||||
if ((ret = process_read (&proc[i], &buf, &msize))) {
|
||||
fprintf(stdout, "error process_read %d\n", ret);
|
||||
exit (1);
|
||||
}
|
||||
|
||||
printf ("read, size %ld : %s\n", msize, buf);
|
||||
|
||||
if ((ret = process_write (&proc[i], &buf, msize))) {
|
||||
fprintf(stdout, "error process_read %d\n", ret);
|
||||
exit (1);
|
||||
}
|
||||
}
|
||||
|
||||
service_free_processes (&proc, nproc);
|
||||
} while (0); // it's a test, we only do it once
|
||||
|
||||
close (sfifo); // closes the service named pipe
|
||||
}
|
||||
|
||||
/*
|
||||
* service test
|
||||
*
|
||||
* 1. creates the named pipe /tmp/<service>, then listens
|
||||
* 2. opens the named pipes in & out
|
||||
* 3. talks with the (test) program
|
||||
* 4. closes the test program named pipes
|
||||
* 5. removes the named pipe /tmp/<service>
|
||||
*/
|
||||
|
||||
int main(int argc, char * argv[])
|
||||
{
|
||||
// gets the service path, such as /tmp/<service>
|
||||
char spath[PATH_MAX];
|
||||
service_path (spath, "windows");
|
||||
|
||||
// creates the service named pipe, that listens to client applications
|
||||
int ret;
|
||||
if ((ret = service_create (spath))) {
|
||||
fprintf(stdout, "error service_create %d\n", ret);
|
||||
exit (1);
|
||||
}
|
||||
|
||||
// the service will loop until the end of time, a specific message, a signal
|
||||
main_loop (spath);
|
||||
|
||||
// the application will shut down, and remove the service named pipe
|
||||
if ((ret = service_close (spath))) {
|
||||
fprintf(stdout, "error service_close %d\n", ret);
|
||||
exit (1);
|
||||
}
|
||||
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
Reference in New Issue