@@ -15,6 +15,14 @@

 #include <signal.h>

 #include <time.h>

 #include <sys/time.h>

+#include <sys/socket.h>  /* unix domain socket support */

+#include <sys/un.h> /* unix domain socket support */

+#include <sys/types.h> /* getpwuid() */

+#include <pwd.h> /* getpwuid() */

+#include <fcntl.h>

+#include <sys/select.h>

+#include <stdarg.h>

+#include <sys/stat.h>

 #include "re_data.h"

 #include "re_plugin_unsaved.h"

@@ -31,7 +39,11 @@

 #define COMMANDBUFSIZE 1024

 #define DEFAULTFONTHEIGHT 14

 #define SELECTBUFBLOCK 16384

-#define SIZEBLOCKPRINTS 32

+#define PRINTSBLOCKSIZE 32

+#define COMMBUFSIZE 16384

+#define COMMCLIENTSBLOCKSIZE 32

+#define SOCKETFILENAMESIZE 1024

+#define LISTENBACKLOG 5

 #define VIEWONLYPROGNAME "review"

@@ -167,6 +179,26 @@ typedef struct theme_t {

         char color_curline[5];

 } theme_t;

+typedef struct commclient_t {

+        int fd;

+        int sizebufin;

+        int usedbufin;

+        int gotbufin;

+        char bufin[COMMBUFSIZE];

+        int sizebufout;

+        int usedbufout;

+        int gotbufout;

+        char bufout[COMMBUFSIZE];

+} commclient_t;

+

+typedef struct comms_t {

+        int serverfd;

+        char socketfilename[SOCKETFILENAMESIZE];

+        int sizeclients;

+        int usedclients;

+        commclient_t **clients;

+} comms_t;

+

 typedef struct re_t {

         redata_t *data;

         reui_t *ui;

@@ -210,6 +242,7 @@ typedef struct re_t {

         int originlinefunclisting;

         int curlinefunclisting;

         struct timeval lastwheel;

+        comms_t comms;

 } re_t;

 volatile int flag_sigint;

@@ -259,7 +292,16 @@ redata_t *re_getfunclisting(re_t *re);

 int re_funclistingxy2line(re_t *re,int mx,int my);

 int re_wheelaccel(re_t *re, int rawamount);

 int re_themeset(re_t *re, int ntheme);

-

+int re_socketinit(re_t *re, char *filename);

+void re_socketfree(re_t *re);

+int re_socketnewclient(re_t *re);

+int re_socketstep(re_t *re);

+int re_socketin(re_t *re, int nclient, char *line);

+#ifndef __GNUC__

+int re_socketout(re_t *re, int nclient, char *format, ...);

+#else

+        int re_socketout(re_t *re, int nclient, char *format, ...) __attribute__((format(printf,3,4)));

+#endif

 int

 main(int argc, char *argv[])

@@ -341,6 +383,9 @@ fprintf(stderr,"QUESTION INIT: %s: %s\n",re->question->title,re->question->body)

                                         re->commandbuf[sizeof(re->commandbuf)-1]='\0';

                                         redata_needssaving_reset(re->data);

                                 }

+                                if(re_socketinit(re,re->filename)!=0) {

+                                        fprintf(stderr,"WARNING: Couldn't init communication socket; there will be no integration with other tools\n");

+                                }

                         }

                 }

                 /* workaround for some nvidia linux drivers, that show old data on partial updates */

@@ -396,6 +441,7 @@ fprintf(stderr,"RENDER\n");

                                 reui_present(re->prints[i].ui);

                 }

                 sselect_wait(ssel,(flag_had_events)?10:100);

+                re_socketstep(re);

                 flag_had_events=(flag_had_events>0)?flag_had_events-1:0;

                 SDL_PumpEvents();

                 while(SDL_PeepEvents(&event,1,SDL_GETEVENT,SDL_FIRSTEVENT,SDL_LASTEVENT)>0) {

@@ -874,6 +920,7 @@ re_free(re_t *re)

                 redata_free(re->data),re->data=NULL;

         if(re->selectbuf!=NULL)

                 free(re->selectbuf),re->selectbuf=NULL,re->usedselectbuf=re->sizeselectbuf=0;

+        re_socketfree(re);

         free(re),re=NULL;

         return;

 }

@@ -2172,11 +2219,11 @@ re_addprint(re_t *re)

         /* ensure space for the new printout */

         if(re->usedprints==re->sizeprints) {

                 printout_t *newprints;

-                if((newprints=realloc(re->prints,sizeof(printout_t)*(re->sizeprints+SIZEBLOCKPRINTS)))==NULL)

+                if((newprints=realloc(re->prints,sizeof(printout_t)*(re->sizeprints+PRINTSBLOCKSIZE)))==NULL)

                         return(-1); /* insuf. mem. */

                 re->prints=newprints;

-                memset(re->prints+re->sizeprints,0,sizeof(printout_t)*SIZEBLOCKPRINTS);

-                re->sizeprints+=SIZEBLOCKPRINTS;

+                memset(re->prints+re->sizeprints,0,sizeof(printout_t)*PRINTSBLOCKSIZE);

+                re->sizeprints+=PRINTSBLOCKSIZE;

         }

         for(i=0;i<re->sizeprints;i++) {

                 if(re->prints[i].ui==NULL)

@@ -2897,3 +2944,297 @@ re_themeset(re_t *re, int ntheme)

         return(0);

 }

+int

+re_socketinit(re_t *re,char *filename)

+{

+        int i;

+        comms_t *comms;

+        commclient_t *client;

+        struct sockaddr_un addr;

+        char *ptr;

+        struct passwd *passwd;

+        char *username;

+        int oldfd;

+        char *errstr;

+        if(re==NULL)

+                return(-1);

+        comms=&(re->comms);

+        /* close all current comms */

+        if(comms->serverfd!=-1) {

+                close(comms->serverfd),comms->serverfd=-1;

+                if(comms->socketfilename[0]!='\0')

+                        unlink(comms->socketfilename),comms->socketfilename[0]='\0';

+        }

+        if(re->comms.clients!=NULL) {

+                for(i=0;i<re->comms.sizeclients;i++) {

+                        if((client=re->comms.clients[i])==NULL)

+                                continue;

+                        if(client->fd!=-1)

+                                close(client->fd),client->fd=-1;

+                }

+                re->comms.usedclients=0;

+        }

+        /* prepare the new filepath for the socket */

+        if((passwd=getpwuid(getuid()))==NULL || (username=passwd->pw_name)==NULL) {

+                fprintf(stderr,"WARNING: Couldn't get username\n");

+                return(-1);

+        }

+        ptr=strrchr(filename,'/');

+        ptr=(ptr!=NULL)?ptr+1:filename;

+        snprintf(comms->socketfilename,sizeof(comms->socketfilename),"/tmp/.re_%s",username);

+        comms->socketfilename[sizeof(comms->socketfilename)-1]='\0';

+        mkdir(comms->socketfilename,0700);

+        snprintf(comms->socketfilename,sizeof(comms->socketfilename),"/tmp/.re_%s/%s",username,ptr);

+        comms->socketfilename[sizeof(comms->socketfilename)-1]='\0';

+        if(strlen(comms->socketfilename)>=(sizeof(addr.sun_path))) {

+                comms->socketfilename[0]='\0';

+                fprintf(stderr,"WARNING: Socket path filename too long\n");

+                return(-1);

+        }

+        /* detect if there is a stale socket */

+        if((oldfd=open(comms->socketfilename, O_WRONLY|O_APPEND))!=-1) {

+                fd_set writeset;

+                struct timeval tv;

+                FD_ZERO(&writeset);

+                FD_SET(oldfd,&writeset);

+                tv.tv_sec=tv.tv_usec=0;

+                if(select(oldfd+1,NULL,&writeset,NULL,&tv)>0) {

+                        comms->socketfilename[0]='\0';

+                        fprintf(stderr,"WARNING: There is a process using the communication socket for the file\n");

+                        return(-1);

+                }

+                close(oldfd),oldfd=-1;

+        }

+        unlink(comms->socketfilename);

+        /* create and bind socket */

+        if((errstr="create")==NULL

+          || (comms->serverfd=socket(AF_UNIX,SOCK_STREAM,0))==-1

+          || (errstr="assing")==NULL /* this one never fails, just for completion */

+          || (memset(&addr,0,sizeof(struct sockaddr_un)))==NULL

+          || (addr.sun_family=AF_UNIX)!=AF_UNIX

+          || strncpy(addr.sun_path,comms->socketfilename,sizeof(addr.sun_path))==NULL

+          || (errstr="bind")==NULL

+          || bind(comms->serverfd,(struct sockaddr *)&addr,sizeof(addr))==-1

+          || (errstr="listen")==NULL

+          || listen(comms->serverfd,LISTENBACKLOG)==-1

+          ) {

+                comms->socketfilename[0]='\0';

+                if(comms->serverfd!=-1)

+                        close(comms->serverfd),comms->serverfd=-1;

+                fprintf(stderr,"WARNING: Couldn't %s unix domain socket\n",errstr);

+                return(-1);

+        }

+#if 1

+fprintf(stderr,"Server registered.\n");

+#endif

+        return(0);

+}

+

+void

+re_socketfree(re_t *re)

+{

+        int i;

+        commclient_t *client;

+        if(re==NULL)

+                return; /* nothing to do */

+        if(re->comms.serverfd!=-1)

+                close(re->comms.serverfd),re->comms.serverfd=-1;

+        if(re->comms.socketfilename[0]!='\0')

+                unlink(re->comms.socketfilename),re->comms.socketfilename[0]='\0';

+        if(re->comms.clients!=NULL) {

+                for(i=0;i<re->comms.sizeclients;i++) {

+                        if((client=re->comms.clients[i])==NULL)

+                                continue;

+                        if(client->fd!=-1)

+                                close(client->fd),client->fd=-1;

+                        free(client),client=NULL;

+                        re->comms.clients[i]=NULL;

+                }

+                re->comms.usedclients=re->comms.sizeclients=0;

+                free(re->comms.clients),re->comms.clients=NULL;

+        }

+        return;

+}

+

+int

+re_socketnewclient(re_t *re)

+{

+        int i;

+        int fd;

+        commclient_t *client;

+        struct sockaddr addr;

+        socklen_t addrlen;

+        addrlen=sizeof(addr);

+        if(re==NULL)

+                return(-1); /* sanity check failed */

+        fd=accept(re->comms.serverfd,&addr,&addrlen);

+        if(re->comms.usedclients==re->comms.sizeclients) {

+                commclient_t **newclients;

+                if((newclients=realloc(re->comms.clients,sizeof(commclient_t *)*(re->comms.sizeclients+COMMCLIENTSBLOCKSIZE)))==NULL) {

+                        close(fd),fd=-1;

+                        return(-1); /* insuf. mem. */

+                }

+                re->comms.clients=newclients;

+                memset(re->comms.clients+re->comms.sizeclients,0,sizeof(commclient_t *)*COMMCLIENTSBLOCKSIZE);

+                re->comms.sizeclients+=COMMCLIENTSBLOCKSIZE;

+        }

+        for(i=0;i<re->comms.sizeclients;i++) {

+                if(re->comms.clients[i]==NULL || re->comms.clients[i]->fd==-1)

+                        break;

+        }

+        if(i>=re->comms.sizeclients) {

+                close(fd),fd=-1;

+                re->comms.usedclients=re->comms.sizeclients;

+                return(-1); /* INTERNAL ERROR */

+        }

+        client=re->comms.clients[i];

+        if(client==NULL) {

+                if((client=malloc(sizeof(commclient_t)))==NULL) {

+                        close(fd),fd=-1;

+                        return(-1); /* INTERNAL ERROR */

+                }

+                re->comms.clients[i]=client;

+                memset(client,0,sizeof(commclient_t));

+                client->fd=-1;

+                client->sizebufin=sizeof(client->bufin);

+                client->sizebufout=sizeof(client->bufout);

+        }

+        client->fd=fd;

+        client->usedbufin=client->gotbufin=0;

+        client->usedbufout=client->gotbufout=0;

+        re->comms.usedclients++;

+        re_socketout(re, i, "OK\n");

+#if 1

+fprintf(stderr,"New client registered (%i).\n",i);

+#endif

+        return(i);

+}

+

+int re_socketstep(re_t *re)

+{

+        int maxfd;

+        fd_set readset,writeset;

+        struct timeval tv;

+        int i;

+        comms_t *comms;

+        commclient_t *client;

+        int avail,queued;

+        int nread,nwritten;

+        char *ptr,*next,*end;

+        if(re==NULL || re->comms.serverfd==-1)

+                return(-1); /* sanity check error */

+        comms=&(re->comms);

+        FD_ZERO(&readset);

+        FD_ZERO(&writeset);

+        maxfd=comms->serverfd;

+        FD_SET(comms->serverfd,&readset);

+        for(i=0;i<comms->sizeclients;i++) {

+                if((client=comms->clients[i])==NULL || client->fd==-1)

+                        continue;

+                if(client->gotbufin>0) {

+                        memmove(client->bufin,client->bufin+client->gotbufin,client->usedbufin-client->gotbufin);

+                        client->usedbufin-=client->gotbufin;

+                        client->gotbufin=0;

+                }

+                if((client->sizebufin-client->usedbufin)>0) {

+                        FD_SET(client->fd,&readset);

+                        maxfd=(maxfd<client->fd)?client->fd:maxfd;

+                }

+                if((client->usedbufout-client->gotbufout)>0) {

+                        FD_SET(client->fd,&writeset);

+                        maxfd=(maxfd<client->fd)?client->fd:maxfd;

+                }

+        }

+        tv.tv_sec=tv.tv_usec=0;

+        if(select(maxfd+1,&readset,&writeset,NULL,&tv)<=0)

+                return(0); /* nothing to do */

+        /* server */

+        if(FD_ISSET(comms->serverfd,&readset))

+                re_socketnewclient(re);

+        /* clients */

+        for(i=0;i<comms->sizeclients;i++) {

+                if((client=comms->clients[i])==NULL || client->fd==-1)

+                        continue;

+                if(FD_ISSET(client->fd,&readset)) {

+                        if((queued=sock_queued(client->fd))<=0) {

+                                /* remote has closed the connection */

+#if 1

+fprintf(stderr,"Unregistering client, remote has closed the connection (%i).\n",i);

+#endif

+                                close(client->fd),client->fd=-1;

+                                continue;

+                        }

+                        avail=(client->sizebufin-client->usedbufin);

+                        queued=(queued>avail)?avail:queued;

+                        if((nread=read(client->fd,client->bufin+client->usedbufin,queued))>0) {

+#if 1

+fprintf(stderr,"Read from client %li bytes (%i).\n",(long)nread,i);

+#endif

+                                client->usedbufin+=nread;

+                                for(ptr=client->bufin+client->gotbufin

+                                   ,end=client->bufin+client->usedbufin

+                                   ,next=memchr(ptr,'\n',end-ptr)

+                                   ,next=(next==NULL)?end:next

+                                  ;client->fd!=-1 && next<end

+                                  ;ptr=(next!=end)?next+1:end

+                                   ,next=memchr(ptr,'\n',end-ptr)

+                                   ,next=(next==NULL)?end:next

+                                  ) {

+                                        *next='\0';

+                                        if(next>ptr && next[-1]=='\r')

+                                                next[-1]='\0';

+                                        re_socketin(re,i,ptr);

+                                }

+                                client->gotbufin=ptr-client->bufin;

+                                if(client->fd==-1)

+                                        continue; /* in case the socket has been closed inside re_socketin() */

+                        }

+                }

+                if(FD_ISSET(client->fd,&writeset)) {

+                        queued=client->usedbufout-client->gotbufout;

+                        if((nwritten=write(client->fd,client->bufout+client->gotbufout,client->usedbufout-client->gotbufout))>0)

+                                client->gotbufout+=nwritten;

+#if 1

+fprintf(stderr,"Write to client %li bytes (%i).\n",(long)nwritten,i);

+#endif

+                }

+        }

+        return(0);

+}

+

+int

+re_socketin(re_t *re, int nclient, char *line)

+{

+        /* note that the '\n' delimiter has been already removed */

+#warning TODO

+#warning Test with "socat - UNIX-CONNECT:/tmp/.re_${USER}/filename.ext"

+#if 1

+

+fprintf(stderr,"Received from client \"%s\" (%i).\n",line,nclient);

+#endif

+        return(0);

+}

+

+int

+re_socketout(re_t *re, int nclient, char *format, ...)

+{

+        /* note that the caller has to output the '\n' delimiter to mark the end of the line */

+        commclient_t *client;

+        va_list mylist;

+        int avail;

+        int res;

+        if(re==NULL || nclient<0 || nclient>=re->comms.sizeclients || re->comms.clients[nclient]==NULL || re->comms.clients[nclient]->fd==-1)

+                return(-1); /* sanity check error */

+        client=re->comms.clients[nclient];

+        memmove(client->bufout,client->bufout+client->gotbufout,client->usedbufout-client->gotbufout);

+        client->usedbufout-=client->gotbufout;

+        client->gotbufout=0;

+        avail=client->sizebufout-client->usedbufout;

+        va_start(mylist,format);

+        res=vsnprintf(client->bufout+client->usedbufout,avail,format,mylist);

+        va_end(mylist);

+        if(res<0 || res>=avail)

+                return(-1); /* doesn't fit or another error */

+        client->usedbufout+=res;

+        return(0);

+}