Obsolete
/
libipc-old
Archived
3
0
Fork 0
Code

Merge branch 'dev-remote' of https://git.karchnu.fr/Karchnu/perfectos-junk into dev-remote

more_to_read
Luka Vandervelden 2018-10-04 23:00:05 +02:00
parent fb67c8182b 37a700daa6
commit 2e8a85cdd9
16 changed files with 167 additions and 128 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
core-test/app/array_proc.c
View File

@ -5,8 +5,8 @@
int main() int main()
{ {
int ret; int ret;
struct ipc_client_array clients; struct ipc_clients clients;
memset(&clients, 0, sizeof(struct ipc_client_array)); memset(&clients, 0, sizeof(struct ipc_clients));
struct ipc_client client_tab[5]; struct ipc_client client_tab[5];
memset(&client_tab, 0, sizeof(struct ipc_client) * 5); memset(&client_tab, 0, sizeof(struct ipc_client) * 5);

9
core/client.c
View File

@ -11,6 +11,7 @@ struct ipc_client * ipc_server_client_copy (const struct ipc_client *p)
return NULL; return NULL;
struct ipc_client * copy = malloc (sizeof(struct ipc_client)); struct ipc_client * copy = malloc (sizeof(struct ipc_client));
memset (copy, 0, sizeof (struct ipc_client));
memcpy (copy, p, sizeof (struct ipc_client)); memcpy (copy, p, sizeof (struct ipc_client));
return copy; return copy;
@ -29,7 +30,7 @@ void ipc_server_client_gen (struct ipc_client *p
p->index = index; p->index = index;
} }
int ipc_client_add (struct ipc_client_array *clients, struct ipc_client *p) int ipc_client_add (struct ipc_clients *clients, struct ipc_client *p)
{ {
assert(clients != NULL); assert(clients != NULL);
assert(p != NULL); assert(p != NULL);
@ -45,7 +46,7 @@ int ipc_client_add (struct ipc_client_array *clients, struct ipc_client *p)
return 0; return 0;
} }
int ipc_client_del (struct ipc_client_array *clients, struct ipc_client *p) int ipc_client_del (struct ipc_clients *clients, struct ipc_client *p)
{ {
assert(clients != NULL); assert(clients != NULL);
assert(p != NULL); assert(p != NULL);
@ -86,7 +87,7 @@ void client_print (struct ipc_client *p)
, p->proc_fd, p->index, p->version); , p->proc_fd, p->index, p->version);
} }
void ipc_client_array_print (struct ipc_client_array *ap) void ipc_client_array_print (struct ipc_clients *ap)
{ {
int i; int i;
for (i = 0; i < ap->size; i++) { for (i = 0; i < ap->size; i++) {
@ -95,7 +96,7 @@ void ipc_client_array_print (struct ipc_client_array *ap)
} }
} }
void ipc_client_array_free (struct ipc_client_array *ap) void ipc_client_array_free (struct ipc_clients *ap)
{ {
if (ap->clients != NULL) { if (ap->clients != NULL) {
free (ap->clients); free (ap->clients);

10
core/client.h
View File

@ -7,16 +7,16 @@ struct ipc_client {
int proc_fd; int proc_fd;
}; };
struct ipc_client_array { struct ipc_clients {
struct ipc_client **clients; struct ipc_client **clients;
int size; int size;
}; };
int ipc_client_add (struct ipc_client_array *, struct ipc_client *); int ipc_client_add (struct ipc_clients *, struct ipc_client *);
int ipc_client_del (struct ipc_client_array *clients, struct ipc_client *p); int ipc_client_del (struct ipc_clients *clients, struct ipc_client *p);
void ipc_client_array_print (struct ipc_client_array *); void ipc_client_array_print (struct ipc_clients *);
void ipc_client_array_free (struct ipc_client_array *); void ipc_client_array_free (struct ipc_clients *);
struct ipc_client * ipc_server_client_copy (const struct ipc_client *p); struct ipc_client * ipc_server_client_copy (const struct ipc_client *p);
int ipc_server_client_eq (const struct ipc_client *p1, const struct ipc_client *p2); int ipc_server_client_eq (const struct ipc_client *p1, const struct ipc_client *p2);

87
core/communication.c
View File

@ -159,15 +159,15 @@ int ipc_application_write (struct ipc_service *srv, const struct ipc_message *m)
/*calculer le max filedescriptor*/ /*calculer le max filedescriptor*/
static int getMaxFd(struct ipc_client_array *ap) static int getMaxFd(struct ipc_clients *clients)
{ {
int i; int i;
int max = 0; int max = 0;
for (i = 0; i < ap->size; i++ ) { for (i = 0; i < clients->size; i++ ) {
if (ap->clients[i]->proc_fd > max) { if (clients->clients[i]->proc_fd > max) {
max = ap->clients[i]->proc_fd; max = clients->clients[i]->proc_fd;
} }
} }
@ -180,21 +180,18 @@ static int getMaxFd(struct ipc_client_array *ap)
* * le service qui attend de nouvelles connexions * * le service qui attend de nouvelles connexions
* * un tableau de client qui souhaitent parler * * un tableau de client qui souhaitent parler
* *
* la fonction trouve le clientus/service actif et renvoie * 0 = OK
* un entier correspondant à quel descripteur de fichier il faut lire * -1 = error
* * celui du serveur = nouvelle connexion entrante (CONNECTION)
* * celui d'un ou plusieurs clientus = ils nous parlent (APPLICATION)
* * les deux à la fois (CON_APP)
*/ */
int ipc_server_select (struct ipc_client_array *ap, struct ipc_service *srv int ipc_server_select (struct ipc_clients *clients, struct ipc_service *srv
, struct ipc_client_array *client) , struct ipc_clients *active_clients, int *new_connection)
{ {
assert (ap != NULL); assert (clients != NULL);
assert (client != NULL); assert (active_clients != NULL);
// delete previous read client array // delete previous read active_clients array
ipc_client_array_free (client); ipc_client_array_free (active_clients);
int i, j; int i, j;
/* master file descriptor list */ /* master file descriptor list */
@ -212,44 +209,36 @@ int ipc_server_select (struct ipc_client_array *ap, struct ipc_service *srv
/* add the listener to the master set */ /* add the listener to the master set */
FD_SET(listener, &master); FD_SET(listener, &master);
for (i=0; i < ap->size; i++) { for (i=0; i < clients->size; i++) {
FD_SET(ap->clients[i]->proc_fd, &master); FD_SET(clients->clients[i]->proc_fd, &master);
} }
/* keep track of the biggest file descriptor */ /* keep track of the biggest file descriptor */
fdmax = getMaxFd(ap) > srv->service_fd ? getMaxFd(ap) : srv->service_fd; fdmax = getMaxFd(clients) > srv->service_fd ? getMaxFd(clients) : srv->service_fd;
int is_listener = 0; // printf ("loop ipc_server_select main_loop\n");
readf = master;
if(select(fdmax+1, &readf, NULL, NULL, NULL) == -1) {
perror("select");
return -1;
}
do { /*run through the existing connections looking for data to be read*/
// printf ("loop ipc_server_select main_loop\n"); for (i = 0; i <= fdmax; i++) {
readf = master; // printf ("loop ipc_server_select inner loop\n");
if(select(fdmax+1, &readf, NULL, NULL, NULL) == -1) { if (FD_ISSET(i, &readf)) {
perror("select"); if (i == listener) {
return -1; *new_connection = 1;
} } else {
for(j = 0; j < clients->size; j++) {
// printf ("loop ipc_server_select inner inner loop\n");
if(i == clients->clients[j]->proc_fd ) {
ipc_client_add (active_clients, clients->clients[j]);
}
}
}
}
}
/*run through the existing connections looking for data to be read*/ return 0;
for (i = 0; i <= fdmax; i++) {
// printf ("loop ipc_server_select inner loop\n");
if (FD_ISSET(i, &readf)) {
if (i == listener) {
is_listener = 1;
} else {
for(j = 0; j < ap->size; j++) {
// printf ("loop ipc_server_select inner inner loop\n");
if(i == ap->clients[j]->proc_fd ) {
ipc_client_add (client, ap->clients[j]);
}
}
}
}
}
} while (0);
if (client->size > 0 && is_listener)
return CON_APP;
if (client->size > 0)
return APPLICATION;
return CONNECTION;
} }

10
core/communication.h
View File

@ -18,9 +18,10 @@
#define PATH_MAX 4096 #define PATH_MAX 4096
#define CONNECTION 0 #define IPC_MESSAGE_CONNECTION 0
#define APPLICATION 1 #define IPC_MESSAGE_DATA 1
#define CON_APP 2 #define IPC_MESSAGE_DATA_AND_CONNECTION 2
#define IPC_MESSAGE_SERVICE_STOP 3
struct ipc_service { struct ipc_service {
unsigned int version; unsigned int version;
@ -43,7 +44,8 @@ int ipc_server_accept (struct ipc_service *srv, struct ipc_client *p);
int ipc_server_read (const struct ipc_client *, struct ipc_message *m); int ipc_server_read (const struct ipc_client *, struct ipc_message *m);
int ipc_server_write (const struct ipc_client *, const struct ipc_message *m); int ipc_server_write (const struct ipc_client *, const struct ipc_message *m);
int ipc_server_select (struct ipc_client_array *, struct ipc_service *, struct ipc_client_array *); int ipc_server_select (struct ipc_clients * clients, struct ipc_service *srv
, struct ipc_clients *active_clients, int *new_connection);
// APPLICATION // APPLICATION

30
core/msg.c
View File

@ -22,9 +22,9 @@ int ipc_message_format_read (struct ipc_message *m, const char *buf, size_t msiz
m->type = buf[0]; m->type = buf[0];
memcpy (&m->length, buf+1, 2); memcpy (&m->length, buf+1, 2);
assert (m->length <= BUFSIZ -3); assert (m->length <= BUFSIZ - 3);
// printf ("type %d : msize = %ld, length = %d\n", m->type, msize, m->length); printf ("type %d : msize = %ld, length = %d\n", m->type, msize, m->length);
assert (m->length == msize - 3); assert (m->length == msize - 3 || m->length == 0);
if (m->payload != NULL) if (m->payload != NULL)
free (m->payload), m->payload = NULL; free (m->payload), m->payload = NULL;
@ -55,16 +55,21 @@ int ipc_message_format_write (const struct ipc_message *m, char **buf, size_t *m
if (*buf == NULL) { if (*buf == NULL) {
*buf = malloc (3 + m->length); *buf = malloc (3 + m->length);
memset (*buf, 0, 3 + m->length);
} }
char *buffer = *buf; char *buffer = *buf;
buffer[0] = m->type; buffer[0] = m->type;
memcpy (buffer + 1, &m->length, 2); memcpy (buffer + 1, &m->length, 2);
memcpy (buffer + 3, m->payload, m->length); if (m->payload != NULL) {
memcpy (buffer + 3, m->payload, m->length);
}
*msize = 3 + m->length; *msize = 3 + m->length;
printf ("sending msg: type %u, size %d, msize %ld\n", m->type, m->length, *msize);
return 0; return 0;
} }
@ -125,10 +130,18 @@ int ipc_message_format (struct ipc_message *m, char type, const char *payload, s
m->type = type; m->type = type;
m->length = (short) length; m->length = (short) length;
if (m->payload == NULL) if (payload != NULL) {
if (m->payload != NULL) {
free (m->payload);
}
// FIXME: test malloc
m->payload = malloc (length); m->payload = malloc (length);
memset (m->payload, 0, length);
}
memcpy (m->payload, payload, length); if (payload != NULL) {
memcpy (m->payload, payload, length);
}
return 0; return 0;
} }
@ -147,6 +160,11 @@ int ipc_message_format_ack (struct ipc_message *m, const char *payload, size_t l
return ipc_message_format (m, MSG_TYPE_ACK, payload, length); return ipc_message_format (m, MSG_TYPE_ACK, payload, length);
} }
int ipc_message_format_server_close (struct ipc_message *m)
{
return ipc_message_format (m, MSG_TYPE_SERVER_CLOSE, NULL, 0);
}
int ipc_message_free (struct ipc_message *m) int ipc_message_free (struct ipc_message *m)
{ {
assert (m != NULL); assert (m != NULL);

2
core/msg.h
View File

@ -10,6 +10,7 @@
#define MSG_TYPE_ERR 2 #define MSG_TYPE_ERR 2
#define MSG_TYPE_ACK 3 #define MSG_TYPE_ACK 3
#define MSG_TYPE_DATA 4 #define MSG_TYPE_DATA 4
#define MSG_TYPE_SERVER_CLOSE 5
struct ipc_message { struct ipc_message {
char type; char type;
@ -30,6 +31,7 @@ int ipc_message_write (int fd, const struct ipc_message *m);
int ipc_message_format_con (struct ipc_message *m, const char *payload, size_t length); int ipc_message_format_con (struct ipc_message *m, const char *payload, size_t length);
int ipc_message_format_data (struct ipc_message *m, const char *payload, size_t length); int ipc_message_format_data (struct ipc_message *m, const char *payload, size_t length);
int ipc_message_format_ack (struct ipc_message *m, const char *payload, size_t length); int ipc_message_format_ack (struct ipc_message *m, const char *payload, size_t length);
int ipc_message_format_server_close (struct ipc_message *m);
int ipc_message_free (struct ipc_message *m); int ipc_message_free (struct ipc_message *m);
void ipc_message_print (const struct ipc_message *m); void ipc_message_print (const struct ipc_message *m);

2
man/communication.h.3
View File

@ -14,7 +14,7 @@ communication.h \- all functions explained
.sp .sp
.BI "int ipc_server_close (struct ipc_service *" srv ); .BI "int ipc_server_close (struct ipc_service *" srv );
.BI "int ipc_server_close_client (struct ipc_client *" p ); .BI "int ipc_server_close_client (struct ipc_client *" p );
.BI "int ipc_server_select (struct ipc_client_array *" fds ", struct ipc_service *" srv ", struct ipc_client_array *" readfds ); .BI "int ipc_server_select (struct ipc_clients *" fds ", struct ipc_service *" srv ", struct ipc_clients *" readfds );
.BI "int ipc_application_connection (int " argc ", char **" argv ", char **" env ", struct ipc_service *" srv .BI "int ipc_application_connection (int " argc ", char **" argv ", char **" env ", struct ipc_service *" srv
.BI " , const char *" service_name " .BI " , const char *" service_name "

4
pong/app/Makefile
View File

@ -14,13 +14,13 @@ test:
./pongd.bin ./pongd.bin
$(EXEC): $(OBJECTS) $(CFILES) $(EXEC): $(OBJECTS) $(CFILES)
$(CC) $(CFLAGS) $(LDFLAGS) $(OBJECTS) $@.c -lcbor -o $@.bin $(CC) $(CFLAGS) $(LDFLAGS) $(OBJECTS) $@.c -o $@.bin
.c.o: .c.o:
$(CC) -c $(CFLAGS) $< -o $@ $(CC) -c $(CFLAGS) $< -o $@
$(TESTS): $(TESTS):
valgrind --show-leak-kinds=all --leak-check=full -v --track-origins=yes ./$(basename $@).bin valgrind --show-leak-kinds=all --leak-check=full -v --track-origins=yes ./$(basename $@).bin $(PARAMS)
clean: clean:
@-rm $(OBJECTS) @-rm $(OBJECTS)

17
pong/app/pong.c
View File

@ -62,6 +62,8 @@ void interactive (int argc, char *argv[], char *env[])
memset (buf, 0, BUFSIZ); memset (buf, 0, BUFSIZ);
int n; int n;
int ask_server_to_quit = 0;
// index and version should be filled // index and version should be filled
srv.index = 0; srv.index = 0;
srv.version = 0; srv.version = 0;
@ -80,6 +82,11 @@ void interactive (int argc, char *argv[], char *env[])
if (n == 0 || strncmp (buf, "exit", 4) == 0) if (n == 0 || strncmp (buf, "exit", 4) == 0)
break; break;
if (strncmp(buf, "close server", 12) == 0) {
ask_server_to_quit = 1;
break;
}
ipc_message_format_data (&m, buf, strlen(buf) +1); ipc_message_format_data (&m, buf, strlen(buf) +1);
memset (buf, 0, BUFSIZ); memset (buf, 0, BUFSIZ);
@ -100,7 +107,15 @@ void interactive (int argc, char *argv[], char *env[])
ipc_message_free (&m); ipc_message_free (&m);
} }
if (ipc_application_close (&srv) < 0) { if (ask_server_to_quit) {
ipc_message_format_server_close (&m);
if (ipc_application_write (&srv, &m) < 0) {
handle_err("main", "application_write < 0");
exit (EXIT_FAILURE);
}
ipc_message_free (&m);
} else if (ipc_application_close (&srv) < 0) {
handle_err("main", "application_close < 0"); handle_err("main", "application_close < 0");
exit (EXIT_FAILURE); exit (EXIT_FAILURE);
} }

86
pong/app/pongd.c
View File

@ -10,7 +10,9 @@
int cpt = 0; int cpt = 0;
void handle_new_connection (struct ipc_service *srv, struct ipc_client_array *ap) struct ipc_service *srv = 0;
void handle_new_connection (struct ipc_clients *clients)
{ {
struct ipc_client *p = malloc(sizeof(struct ipc_client)); struct ipc_client *p = malloc(sizeof(struct ipc_client));
memset(p, 0, sizeof(struct ipc_client)); memset(p, 0, sizeof(struct ipc_client));
@ -21,7 +23,7 @@ void handle_new_connection (struct ipc_service *srv, struct ipc_client_array *ap
printf("new connection\n"); printf("new connection\n");
} }
if (ipc_client_add (ap, p) < 0) { if (ipc_client_add (clients, p) < 0) {
handle_error("ipc_client_add < 0"); handle_error("ipc_client_add < 0");
} }
@ -29,14 +31,14 @@ void handle_new_connection (struct ipc_service *srv, struct ipc_client_array *ap
printf ("%d client(s)\n", cpt); printf ("%d client(s)\n", cpt);
} }
void handle_new_msg (struct ipc_client_array *ap, struct ipc_client_array *proc_to_read) void handle_new_msg (struct ipc_clients *clients, struct ipc_clients *clients_talking)
{ {
struct ipc_message m; struct ipc_message m;
memset (&m, 0, sizeof (struct ipc_message)); memset (&m, 0, sizeof (struct ipc_message));
int i; int i;
for (i = 0; i < proc_to_read->size; i++) { for (i = 0; i < clients_talking->size; i++) {
// printf ("loop handle_new_msg\n"); // printf ("loop handle_new_msg\n");
if (ipc_server_read (proc_to_read->clients[i], &m) < 0) { if (ipc_server_read (clients_talking->clients[i], &m) < 0) {
handle_error("server_read < 0"); handle_error("server_read < 0");
} }
@ -45,18 +47,25 @@ void handle_new_msg (struct ipc_client_array *ap, struct ipc_client_array *proc_
cpt--; cpt--;
printf ("disconnection => %d client(s) remaining\n", cpt); printf ("disconnection => %d client(s) remaining\n", cpt);
if (ipc_server_close_client (proc_to_read->clients[i]) < 0) if (ipc_server_close_client (clients_talking->clients[i]) < 0)
handle_err( "handle_new_msg", "server_close_client < 0"); handle_err( "handle_new_msg", "server_close_client < 0");
if (ipc_client_del (ap, proc_to_read->clients[i]) < 0) if (ipc_client_del (clients, clients_talking->clients[i]) < 0)
handle_err( "handle_new_msg", "ipc_client_del < 0"); handle_err( "handle_new_msg", "ipc_client_del < 0");
if (ipc_client_del (proc_to_read, proc_to_read->clients[i]) < 0) if (ipc_client_del (clients_talking, clients_talking->clients[i]) < 0)
handle_err( "handle_new_msg", "ipc_client_del < 0"); handle_err( "handle_new_msg", "ipc_client_del < 0");
i--; i--;
continue; continue;
} }
if (m.type == MSG_TYPE_SERVER_CLOSE) {
if (ipc_server_close (srv) < 0) {
handle_error("server_close < 0");
}
exit (0);
}
printf ("new message : %s", m.payload); printf ("new message : %s", m.payload);
if (ipc_server_write (proc_to_read->clients[i], &m) < 0) { if (ipc_server_write (clients_talking->clients[i], &m) < 0) {
handle_err( "handle_new_msg", "server_write < 0"); handle_err( "handle_new_msg", "server_write < 0");
} }
} }
@ -70,35 +79,35 @@ void handle_new_msg (struct ipc_client_array *ap, struct ipc_client_array *proc_
* close a connection if MSG_TYPE_CLOSE received * close a connection if MSG_TYPE_CLOSE received
*/ */
void main_loop (struct ipc_service *srv) void main_loop ()
{ {
int i, ret = 0; int i, ret = 0;
struct ipc_client_array ap; struct ipc_clients clients;
memset(&ap, 0, sizeof(struct ipc_client_array)); memset(&clients, 0, sizeof(struct ipc_clients));
struct ipc_client_array proc_to_read; struct ipc_clients clients_talking;
memset(&proc_to_read, 0, sizeof(struct ipc_client_array)); memset(&clients_talking, 0, sizeof(struct ipc_clients));
while(1) { while(1) {
ret = ipc_server_select (&ap, srv, &proc_to_read); int new_connection = 0;
// printf ("on peut lire ces client:\n"); ret = ipc_server_select (&clients, srv, &clients_talking, &new_connection);
// ipc_client_array_print (&proc_to_read); if (ret < 0) {
// printf ("-- \n\n"); handle_error("ipc_server_select < 0");
}
if (ret == CONNECTION) { if (new_connection) {
handle_new_connection (srv, &ap); handle_new_connection (&clients);
} else if (ret == APPLICATION) {
handle_new_msg (&ap, &proc_to_read);
} else { // both new connection and new msg from at least one client
handle_new_connection (srv, &ap);
handle_new_msg (&ap, &proc_to_read);
} }
ipc_client_array_free (&proc_to_read);
if (clients_talking.size > 0) {
handle_new_msg (&clients, &clients_talking);
}
ipc_client_array_free (&clients_talking);
} }
for (i = 0; i < ap.size; i++) { for (i = 0; i < clients.size; i++) {
if (ipc_server_close_client (ap.clients[i]) < 0) { if (ipc_server_close_client (clients.clients[i]) < 0) {
handle_error( "server_close_client < 0"); handle_error( "server_close_client < 0");
} }
} }
@ -117,26 +126,29 @@ void main_loop (struct ipc_service *srv)
int main(int argc, char * argv[], char **env) int main(int argc, char * argv[], char **env)
{ {
struct ipc_service srv; srv = malloc (sizeof (struct ipc_service));
memset (&srv, 0, sizeof (struct ipc_service)); if (srv == NULL) {
srv.index = 0; exit (1);
srv.version = 0; }
memset (srv, 0, sizeof (struct ipc_service));
srv->index = 0;
srv->version = 0;
// unlink("/tmp/ipc/pongd-0-0"); // unlink("/tmp/ipc/pongd-0-0");
if (ipc_server_init (argc, argv, env, &srv, PONGD_SERVICE_NAME) < 0) { if (ipc_server_init (argc, argv, env, srv, PONGD_SERVICE_NAME) < 0) {
handle_error("server_init < 0"); handle_error("server_init < 0");
return EXIT_FAILURE; return EXIT_FAILURE;
} }
printf ("Listening on %s.\n", srv.spath); printf ("Listening on %s.\n", srv->spath);
printf("MAIN: server created\n" ); printf("MAIN: server created\n" );
// the service will loop until the end of time, a specific message, a signal // the service will loop until the end of time, a specific message, a signal
main_loop (&srv); main_loop ();
// the application will shut down, and remove the service named pipe // the application will shut down, and remove the service named pipe
if (ipc_server_close (&srv) < 0) { if (ipc_server_close (srv) < 0) {
handle_error("server_close < 0"); handle_error("server_close < 0");
} }

4
pubsub/lib/channels.c
View File

@ -98,8 +98,8 @@ int pubsubd_channel_new (struct channel *c, const char * name)
memcpy (c->chan, name, nlen); memcpy (c->chan, name, nlen);
c->chanlen = nlen; c->chanlen = nlen;
c->subs = malloc (sizeof (struct ipc_client_array)); c->subs = malloc (sizeof (struct ipc_clients));
memset (c->subs, 0, sizeof (struct ipc_client_array)); memset (c->subs, 0, sizeof (struct ipc_clients));
return 0; return 0;
} }

2
pubsub/lib/channels.h
View File

@ -12,7 +12,7 @@ LIST_HEAD(channels, channel);
struct channel { struct channel {
char *chan; char *chan;
size_t chanlen; size_t chanlen;
struct ipc_client_array *subs; struct ipc_clients *subs;
LIST_ENTRY(channel) entries; LIST_ENTRY(channel) entries;
}; };

14
pubsub/lib/pubsubd.c
View File

@ -11,7 +11,7 @@
#include <sys/un.h> #include <sys/un.h>
#include <unistd.h> #include <unistd.h>
void pubsubd_send (const struct ipc_client_array *ap, const struct pubsub_msg * m) void pubsubd_send (const struct ipc_clients *ap, const struct pubsub_msg * m)
{ {
if (ap == NULL) { if (ap == NULL) {
fprintf (stderr, "pubsubd_send: ap == NULL"); fprintf (stderr, "pubsubd_send: ap == NULL");
@ -59,7 +59,7 @@ void pubsubd_send (const struct ipc_client_array *ap, const struct pubsub_msg *
* new connection, once accepted the client is added to the array_proc * new connection, once accepted the client is added to the array_proc
* structure to be checked periodically for new messages * structure to be checked periodically for new messages
*/ */
void handle_new_connection (struct ipc_service *srv, struct ipc_client_array *ap) void handle_new_connection (struct ipc_service *srv, struct ipc_clients *ap)
{ {
struct ipc_client *p = malloc(sizeof(struct ipc_client)); struct ipc_client *p = malloc(sizeof(struct ipc_client));
memset(p, 0, sizeof(struct ipc_client)); memset(p, 0, sizeof(struct ipc_client));
@ -76,7 +76,7 @@ void handle_new_connection (struct ipc_service *srv, struct ipc_client_array *ap
} }
void handle_new_msg (struct channels *chans void handle_new_msg (struct channels *chans
, struct ipc_client_array *ap, struct ipc_client_array *proc_to_read) , struct ipc_clients *ap, struct ipc_clients *proc_to_read)
{ {
struct ipc_message m; struct ipc_message m;
memset (&m, 0, sizeof (struct ipc_message)); memset (&m, 0, sizeof (struct ipc_message));
@ -169,11 +169,11 @@ void pubsubd_main_loop (struct ipc_service *srv, struct channels *chans)
{ {
int i, ret = 0; int i, ret = 0;
struct ipc_client_array ap; struct ipc_clients ap;
memset(&ap, 0, sizeof(struct ipc_client_array)); memset(&ap, 0, sizeof(struct ipc_clients));
struct ipc_client_array proc_to_read; struct ipc_clients proc_to_read;
memset(&proc_to_read, 0, sizeof(struct ipc_client_array)); memset(&proc_to_read, 0, sizeof(struct ipc_clients));
while(1) { while(1) {
ret = ipc_server_select (&ap, srv, &proc_to_read); ret = ipc_server_select (&ap, srv, &proc_to_read);

2
pubsub/lib/pubsubd.h
View File

@ -10,6 +10,6 @@
#define PUBSUBD_SERVICE_NAME "pubsubd" #define PUBSUBD_SERVICE_NAME "pubsubd"
void pubsubd_main_loop (struct ipc_service *srv, struct channels * chans); void pubsubd_main_loop (struct ipc_service *srv, struct channels * chans);
void pubsubd_message_send (const struct ipc_client_array *ap, const struct pubsub_msg * m); void pubsubd_message_send (const struct ipc_clients *ap, const struct pubsub_msg * m);
#endif #endif

12
remote/lib/remoted.c
View File

@ -15,7 +15,7 @@
* new connection, once accepted the client is added to the array_proc * new connection, once accepted the client is added to the array_proc
* structure to be checked periodically for new messages * structure to be checked periodically for new messages
*/ */
void handle_new_connection (struct ipc_service *srv, struct ipc_client_array *ap) void handle_new_connection (struct ipc_service *srv, struct ipc_clients *ap)
{ {
struct ipc_client *p = malloc(sizeof(struct ipc_client)); struct ipc_client *p = malloc(sizeof(struct ipc_client));
memset(p, 0, sizeof(struct ipc_client)); memset(p, 0, sizeof(struct ipc_client));
@ -31,7 +31,7 @@ void handle_new_connection (struct ipc_service *srv, struct ipc_client_array *ap
} }
} }
void handle_new_msg (struct ipc_client_array *ap, struct ipc_client_array *proc_to_read) void handle_new_msg (struct ipc_clients *ap, struct ipc_clients *proc_to_read)
{ {
struct ipc_message m; struct ipc_message m;
memset (&m, 0, sizeof (struct ipc_message)); memset (&m, 0, sizeof (struct ipc_message));
@ -114,11 +114,11 @@ void remoted_main_loop (struct ipc_service *srv, struct remoted_ctx *ctx)
log_debug ("remoted entering main loop"); log_debug ("remoted entering main loop");
int i, ret = 0; int i, ret = 0;
struct ipc_client_array ap; struct ipc_clients ap;
memset(&ap, 0, sizeof(struct ipc_client_array)); memset(&ap, 0, sizeof(struct ipc_clients));
struct ipc_client_array proc_to_read; struct ipc_clients proc_to_read;
memset(&proc_to_read, 0, sizeof(struct ipc_client_array)); memset(&proc_to_read, 0, sizeof(struct ipc_clients));
while(1) { while(1) {
/* TODO: authorizations */ /* TODO: authorizations */