source: BAORadio/libindi/v1.0.1/indiserver.c @ 693

Last change on this file since 693 was 501, checked in by frichard, 14 years ago

-BAOControl : petite interface permettant de contrôler les antennes via le pilote indi_BAO
-Le pilote indi_BAO utilise désormais libindi v 0.7
File size: 48.6 KB
Line 
1/* INDI Server for protocol version 1.7.
2 * Copyright (C) 2007 Elwood C. Downey ecdowney@clearskyinstitute.com
3
4    This library is free software; you can redistribute it and/or
5    modify it under the terms of the GNU Lesser General Public
6    License as published by the Free Software Foundation; either
7    version 2.1 of the License, or (at your option) any later version.
8
9    This library is distributed in the hope that it will be useful,
10    but WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12    Lesser General Public License for more details.
13
14    You should have received a copy of the GNU Lesser General Public
15    License along with this library; if not, write to the Free Software
16    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
17
18 * argv lists names of Driver programs to run or sockets to connect for Devices.
19 * Drivers are restarted if they exit or connection closes.
20 * Each local Driver's stdin/out are assumed to provide INDI traffic and are
21 *   connected here via pipes. Local Drivers' stderr are connected to our
22 *   stderr with date stamp and driver name prepended.
23 * We only support Drivers that advertise support for one Device. The problem
24 *   with multiple Devices in one Driver is without a way to know what they
25 *   _all_ are there is no way to avoid sending all messages to all Drivers.
26 * Outbound messages are limited to Devices and Properties seen inbound.
27 *   Messages to Devices on sockets always include Device so the chained
28 *   indiserver will only pass back info from that Device.
29 * All newXXX() received from one Client are echoed to all other Clients who
30 *   have shown an interest in the same Device and property.
31 *
32 * Implementation notes:
33 *
34 * We fork each driver and open a server socket listening for INDI clients.
35 * Then forever we listen for new clients and pass traffic between clients and
36 * drivers, subject to optimizations based on sniffing messages for matching
37 * Devices and Properties. Since one message might be destined to more than
38 * one client or device, they are queued and only removed after the last
39 * consumer is finished. XMLEle are converted to linear strings before being
40 * sent to optimize write system calls and avoid blocking to slow clients.
41 * Clients that get more than maxqsiz bytes behind are shut down.
42 */
43
44#include <stdio.h>
45#include <stdlib.h>
46#include <stdarg.h>
47#include <signal.h>
48#include <string.h>
49#include <errno.h>
50#include <unistd.h>
51#include <time.h>
52#include <fcntl.h>
53#include <sys/time.h>
54#include <sys/types.h>
55#include <sys/stat.h>
56#include <sys/socket.h>
57#include <netinet/in.h>
58#include <netdb.h>
59#include <arpa/inet.h>
60
61#include "lilxml.h"
62#include "indiapi.h"
63#include "fq.h"
64
65#define INDIPORT        7624            /* default TCP/IP port to listen */
66#define REMOTEDVR       (-1234)         /* invalid PID to flag remote drivers */
67#define MAXRBUF         4096            /* max read buffering here */
68#define MAXWSIZ         4096            /* max bytes/write */
69#define DEFMAXQSIZ      10              /* default max q behind, MB */
70
71/* associate a usage count with queuded client or device message */
72typedef struct {
73    int count;                          /* number of consumers left */
74    unsigned int cl;                    /* content length */
75    char *cp;                           /* content: buf or malloced */
76    char buf[MAXWSIZ];          /* local buf for most messages */
77} Msg;
78
79/* BLOB handling, NEVER is the default */
80typedef enum {B_NEVER=0, B_ALSO, B_ONLY} BLOBHandling;
81
82/* device + property name */
83typedef struct {
84    char dev[MAXINDIDEVICE];
85    char name[MAXINDINAME];
86} Property;
87
88/* record of each snooped property */
89typedef struct {
90    Property prop;
91    BLOBHandling blob;                  /* when to snoop BLOBs */
92} Snoopee;
93
94struct
95{
96    const char *name;                      /* Path to FIFO for dynamic startups & shutdowns of drivers */
97    int fd;
98    FILE *fs;
99} fifo;
100
101/* info for each connected client */
102typedef struct {
103    int active;                         /* 1 when this record is in use */
104    Property *props;                    /* malloced array of props we want */
105    int nprops;                         /* n entries in props[] */
106    int allprops;                       /* saw getProperties w/o device */
107    BLOBHandling blob;                  /* when to send setBLOBs */
108    int s;                              /* socket for this client */
109    LilXML *lp;                         /* XML parsing context */
110    FQ *msgq;                           /* Msg queue */
111    unsigned int nsent;                         /* bytes of current Msg sent so far */
112} ClInfo;
113static ClInfo *clinfo;                  /*  malloced pool of clients */
114static int nclinfo;                     /* n total (not active) */
115
116/* info for each connected driver */
117typedef struct {
118    char name[MAXINDIDEVICE];           /* persistent name */
119    char dev[MAXINDIDEVICE];            /* device served by this driver */
120    int active;                         /* 1 when this record is in use */
121    Snoopee *sprops;                    /* malloced array of props we snoop */
122    int nsprops;                        /* n entries in sprops[] */
123    int pid;                            /* process id or REMOTEDVR if remote */
124    int rfd;                            /* read pipe fd */
125    int wfd;                            /* write pipe fd */
126    int efd;                            /* stderr from driver, if local */
127    int restarts;                       /* times process has been restarted */
128    LilXML *lp;                         /* XML parsing context */
129    FQ *msgq;                           /* Msg queue */
130    unsigned int nsent;                 /* bytes of current Msg sent so far */
131} DvrInfo;
132static DvrInfo *dvrinfo;                /* malloced array of drivers */
133static int ndvrinfo;                    /* n total */
134
135static char *me;                        /* our name */
136static int port = INDIPORT;             /* public INDI port */
137static int verbose;                     /* chattiness */
138static int lsocket;                     /* listen socket */
139static char *ldir;                      /* where to log driver messages */
140static int maxqsiz = (DEFMAXQSIZ*1024*1024); /* kill if these bytes behind */
141
142static void logStartup(int ac, char *av[]);
143static void usage (void);
144static void noZombies (void);
145static void noSIGPIPE (void);
146static void indiFIFO(void);
147static void indiRun (void);
148static void indiListen (void);
149static void newFIFO(void);
150static void newClient (void);
151static int newClSocket (void);
152static void shutdownClient (ClInfo *cp);
153static int readFromClient (ClInfo *cp);
154static void startDvr (DvrInfo *dp);
155static void startLocalDvr (DvrInfo *dp);
156static void startRemoteDvr (DvrInfo *dp);
157static int openINDIServer (char host[], int indi_port);
158static void shutdownDvr (DvrInfo *dp, int restart);
159static void q2RDrivers (const char *dev, Msg *mp, XMLEle *root);
160static void q2SDrivers (int isblob, const char *dev, const char *name, Msg *mp,
161    XMLEle *root);
162static int q2Clients (ClInfo *notme, int isblob, const char *dev, const char *name,
163    Msg *mp, XMLEle *root);
164static void addSDevice (DvrInfo *dp, const char *dev, const char *name);
165static Snoopee *findSDevice (DvrInfo *dp, const char *dev, const char *name);
166static void addClDevice (ClInfo *cp, const char *dev, const char *name);
167static int findClDevice (ClInfo *cp, const char *dev, const char *name);
168static int readFromDriver (DvrInfo *dp);
169static int stderrFromDriver (DvrInfo *dp);
170static int msgQSize (FQ *q);
171static void setMsgXMLEle (Msg *mp, XMLEle *root);
172static void setMsgStr (Msg *mp, char *str);
173static void freeMsg (Msg *mp);
174static Msg *newMsg (void);
175static int sendClientMsg (ClInfo *cp);
176static int sendDriverMsg (DvrInfo *cp);
177static void crackBLOB (char *enableBLOB, BLOBHandling *bp);
178static void traceMsg (XMLEle *root);
179static char *indi_tstamp (char *s);
180static void logDMsg (XMLEle *root, const char *dev);
181static void Bye(void);
182
183int
184main (int ac, char *av[])
185{
186        /* log startup */
187        logStartup(ac, av);
188
189        /* save our name */
190        me = av[0];
191
192        /* crack args */
193        while ((--ac > 0) && ((*++av)[0] == '-')) {
194            char *s;
195            for (s = av[0]+1; *s != '\0'; s++)
196                switch (*s) {
197                case 'l':
198                    if (ac < 2) {
199                        fprintf (stderr, "-l requires log directory\n");
200                        usage();
201                    }
202                    ldir = *++av;
203                    ac--;
204                    break;
205                case 'm':
206                    if (ac < 2) {
207                        fprintf (stderr, "-m requires max MB behind\n");
208                        usage();
209                    }
210                    maxqsiz = 1024*1024*atoi(*++av);
211                    ac--;
212                    break;
213                case 'p':
214                    if (ac < 2) {
215                        fprintf (stderr, "-p requires port value\n");
216                        usage();
217                    }
218                    port = atoi(*++av);
219                    ac--;
220                    break;
221                case 'f':
222                    if (ac < 2) {
223                        fprintf (stderr, "-f requires fifo node\n");
224                        usage();
225                    }
226                    fifo.name = *++av;
227                    ac--;
228                    break;
229                case 'v':
230                    verbose++;
231                    break;
232                default:
233                    usage();
234                }
235        }
236
237        /* at this point there are ac args in av[] to name our drivers */
238        if (ac == 0 && !fifo.name)
239            usage();
240
241        /* take care of some unixisms */
242        noZombies();
243        noSIGPIPE();
244
245        /* realloc seed for client pool */
246        clinfo = (ClInfo *) malloc (1);
247        nclinfo = 0;
248
249        /* create driver info array all at once since size never changes */
250        ndvrinfo = ac;
251        dvrinfo = (DvrInfo *) calloc (ndvrinfo, sizeof(DvrInfo));
252
253        /* start each driver */
254        while (ac-- > 0) {
255            strcpy(dvrinfo[ac].name, *av++);
256            startDvr (&dvrinfo[ac]);
257        }
258
259        /* announce we are online */
260        indiListen();
261
262        /* Load up FIFO, if available */
263        indiFIFO();
264
265        /* handle new clients and all io */
266        while (1)
267            indiRun();
268
269        /* whoa! */
270        fprintf (stderr, "unexpected return from main\n");
271        return (1);
272}
273
274/* record we have started and our args */
275static void
276logStartup(int ac, char *av[])
277{
278        int i;
279
280        fprintf (stderr, "%s: startup: ", indi_tstamp(NULL));
281        for (i = 0; i < ac; i++)
282            fprintf (stderr, "%s ", av[i]);
283        fprintf (stderr, "\n");
284}
285
286/* print usage message and exit (2) */
287static void
288usage(void)
289{
290        fprintf (stderr, "Usage: %s [options] driver [driver ...]\n", me);
291        fprintf (stderr, "Purpose: server for local and remote INDI drivers\n");
292        fprintf (stderr, "Code %s. Protocol %g.\n", "$Revision: 726523 $", INDIV);
293        fprintf (stderr, "Options:\n");
294        fprintf (stderr, " -l d     : log driver messages to <d>/YYYY-MM-DD.islog\n");
295        fprintf (stderr, " -m m     : kill client if gets more than this many MB behind, default %d\n", DEFMAXQSIZ);
296        fprintf (stderr, " -p p     : alternate IP port, default %d\n", INDIPORT);
297        fprintf (stderr, " -f path  : Path to fifo for dynamic startup and shutdown of drivers.\n");
298        fprintf (stderr, " -v       : show key events, no traffic\n");
299        fprintf (stderr, " -vv      : -v + key message content\n");
300        fprintf (stderr, " -vvv     : -vv + complete xml\n");
301        fprintf (stderr, "driver    : executable or device@host[:port]\n");
302
303        exit (2);
304}
305
306/* arrange for no zombies if drivers die */
307static void
308noZombies()
309{
310        struct sigaction sa;
311        sa.sa_handler = SIG_IGN;
312        sigemptyset(&sa.sa_mask);
313#ifdef SA_NOCLDWAIT
314        sa.sa_flags = SA_NOCLDWAIT;
315#else
316        sa.sa_flags = 0;
317#endif
318        (void)sigaction(SIGCHLD, &sa, NULL);
319}
320
321/* turn off SIGPIPE on bad write so we can handle it inline */
322static void
323noSIGPIPE()
324{
325        struct sigaction sa;
326        sa.sa_handler = SIG_IGN;
327        sigemptyset(&sa.sa_mask);
328        (void)sigaction(SIGPIPE, &sa, NULL);
329}
330
331static DvrInfo * allocDvr ()
332{
333    DvrInfo *dp = NULL;
334    int dvi;
335
336/* try to reuse a drivber slot, else add one */
337for (dvi = 0; dvi < ndvrinfo; dvi++)
338    if (!(dp = &dvrinfo[dvi])->active)
339        break;
340if (dvi == ndvrinfo)
341{
342    /* grow dvrinfo */
343    dvrinfo = (DvrInfo *) realloc (dvrinfo, (ndvrinfo+1)*sizeof(DvrInfo));
344    if (!dvrinfo) {
345        fprintf (stderr, "no memory for new drivers\n");
346        Bye();
347    }
348    dp = &dvrinfo[ndvrinfo++];
349}
350
351/* rig up new dvrinfo entry */
352memset (dp, 0, sizeof(*dp));
353dp->active = 1;
354
355return dp;
356
357}
358
359/* start the given INDI driver process or connection.
360 * exit if trouble.
361 */
362static void
363startDvr (DvrInfo *dp)
364{
365        if (strchr (dp->name, '@'))
366            startRemoteDvr (dp);
367        else
368            startLocalDvr (dp);
369}
370
371/* start the given local INDI driver process.
372 * exit if trouble.
373 */
374static void
375startLocalDvr (DvrInfo *dp)
376{
377        Msg *mp;
378        char buf[1024];
379        int rp[2], wp[2], ep[2];
380        int pid;
381
382        /* build three pipes: r, w and error*/
383        if (pipe (rp) < 0) {
384            fprintf (stderr, "%s: read pipe: %s\n", indi_tstamp(NULL),
385                                                            strerror(errno));
386            Bye();
387        }
388        if (pipe (wp) < 0) {
389            fprintf (stderr, "%s: write pipe: %s\n", indi_tstamp(NULL),
390                                                            strerror(errno));
391            Bye();
392        }
393        if (pipe (ep) < 0) {
394            fprintf (stderr, "%s: stderr pipe: %s\n", indi_tstamp(NULL),
395                                                            strerror(errno));
396            Bye();
397        }
398
399        /* fork&exec new process */
400        pid = fork();
401        if (pid < 0) {
402            fprintf (stderr, "%s: fork: %s\n", indi_tstamp(NULL), strerror(errno));
403            Bye();
404        }
405        if (pid == 0) {
406            /* child: exec name */
407            int fd;
408
409            /* rig up pipes */
410            dup2 (wp[0], 0);    /* driver stdin reads from wp[0] */
411            dup2 (rp[1], 1);    /* driver stdout writes to rp[1] */
412            dup2 (ep[1], 2);    /* driver stderr writes to e[]1] */
413            for (fd = 3; fd < 100; fd++)
414                (void) close (fd);
415
416            /* go -- should never return */
417            execlp (dp->name, dp->name, NULL);
418            fprintf (stderr, "%s: Driver %s: execlp: %s\n", indi_tstamp(NULL),
419                                                dp->name, strerror(errno));
420            _exit (1);  /* parent will notice EOF shortly */
421        }
422
423        /* don't need child's side of pipes */
424        close (wp[0]);
425        close (rp[1]);
426        close (ep[1]);
427
428        /* record pid, io channels, init lp and snoop list */
429        dp->pid = pid;
430        dp->rfd = rp[0];
431        dp->wfd = wp[1];
432        dp->efd = ep[0];
433        dp->lp = newLilXML();
434        dp->msgq = newFQ(1);
435        dp->sprops = (Snoopee*) malloc (1);     /* seed for realloc */
436        dp->nsprops = 0;
437        dp->nsent = 0;
438        dp->active = 1;
439
440        /* first message primes driver to report its properties -- dev known
441         * if restarting
442         */
443        mp = newMsg();
444        pushFQ (dp->msgq, mp);
445        if (dp->dev[0])
446            sprintf (buf, "<getProperties device='%s' version='%g'/>\n",
447                                                            dp->dev, INDIV);
448        else
449            sprintf (buf, "<getProperties version='%g'/>\n", INDIV);
450        setMsgStr (mp, buf);
451        mp->count++;
452
453        if (verbose > 0)
454            fprintf (stderr, "%s: Driver %s: pid=%d rfd=%d wfd=%d efd=%d\n",
455                    indi_tstamp(NULL), dp->name, dp->pid, dp->rfd, dp->wfd, dp->efd);
456}
457
458/* start the given remote INDI driver connection.
459 * exit if trouble.
460 */
461static void
462startRemoteDvr (DvrInfo *dp)
463{
464        Msg *mp;
465        char dev[1024];
466        char host[1024];
467        char buf[1024];
468        int indi_port, sockfd;
469
470        /* extract host and port */
471        indi_port = INDIPORT;
472        if (sscanf (dp->name, "%[^@]@%[^:]:%d", dev, host, &indi_port) < 2) {
473            fprintf (stderr, "Bad remote device syntax: %s\n", dp->name);
474            Bye();
475        }
476
477        /* connect */
478        sockfd = openINDIServer (host, indi_port);
479
480        /* record flag pid, io channels, init lp and snoop list */
481        dp->pid = REMOTEDVR;
482        dp->rfd = sockfd;
483        dp->wfd = sockfd;
484        dp->lp = newLilXML();
485        dp->msgq = newFQ(1);
486        dp->sprops = (Snoopee*) malloc (1);     /* seed for realloc */
487        dp->nsprops = 0;
488        dp->nsent = 0;
489        dp->active = 1;
490
491        /* N.B. storing name now is key to limiting outbound traffic to this
492         * dev.
493         */
494        strncpy (dp->dev, dev, MAXINDIDEVICE-1);
495        dp->dev[MAXINDIDEVICE-1] = '\0';
496
497        /* Sending getProperties with device lets remote server limit its
498         * outbound (and our inbound) traffic on this socket to this device.
499         */
500        mp = newMsg();
501        pushFQ (dp->msgq, mp);
502        sprintf (buf, "<getProperties device='%s' version='%g'/>\n",
503                                                            dp->dev, INDIV);
504        setMsgStr (mp, buf);
505        mp->count++;
506
507        if (verbose > 0)
508            fprintf (stderr, "%s: Driver %s: socket=%d\n", indi_tstamp(NULL),
509                                                            dp->name, sockfd);
510}
511
512/* open a connection to the given host and port or die.
513 * return socket fd.
514 */
515static int
516openINDIServer (char host[], int indi_port)
517{
518        struct sockaddr_in serv_addr;
519        struct hostent *hp;
520        int sockfd;
521
522        /* lookup host address */
523        hp = gethostbyname (host);
524        if (!hp) {
525            fprintf (stderr, "gethostbyname(%s): %s\n", host, strerror(errno));
526            Bye();
527        }
528
529        /* create a socket to the INDI server */
530        (void) memset ((char *)&serv_addr, 0, sizeof(serv_addr));
531        serv_addr.sin_family = AF_INET;
532        serv_addr.sin_addr.s_addr =
533                            ((struct in_addr *)(hp->h_addr_list[0]))->s_addr;
534        serv_addr.sin_port = htons(indi_port);
535        if ((sockfd = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
536            fprintf (stderr, "socket(%s,%d): %s\n", host, indi_port,strerror(errno));
537            Bye();
538        }
539
540        /* connect */
541        if (connect (sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr))<0){
542            fprintf (stderr, "connect(%s,%d): %s\n", host,indi_port,strerror(errno));
543            Bye();
544        }
545
546        /* ok */
547        return (sockfd);
548}
549
550/* create the public INDI Driver endpoint lsocket on port.
551 * return server socket else exit.
552 */
553static void
554indiListen ()
555{
556        struct sockaddr_in serv_socket;
557        int sfd;
558        int reuse = 1;
559
560        /* make socket endpoint */
561        if ((sfd = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
562            fprintf (stderr, "%s: socket: %s\n", indi_tstamp(NULL), strerror(errno));
563            Bye();
564        }
565
566        /* bind to given port for any IP address */
567        memset (&serv_socket, 0, sizeof(serv_socket));
568        serv_socket.sin_family = AF_INET;
569        #ifdef SSH_TUNNEL
570        serv_socket.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
571        #else
572        serv_socket.sin_addr.s_addr = htonl (INADDR_ANY);
573        #endif
574        serv_socket.sin_port = htons ((unsigned short)port);
575        if (setsockopt(sfd,SOL_SOCKET,SO_REUSEADDR,&reuse,sizeof(reuse)) < 0){
576            fprintf (stderr, "%s: setsockopt: %s\n", indi_tstamp(NULL),
577                                                            strerror(errno));
578            Bye();
579        }
580        if (bind(sfd,(struct sockaddr*)&serv_socket,sizeof(serv_socket)) < 0){
581            fprintf (stderr, "%s: bind: %s\n", indi_tstamp(NULL), strerror(errno));
582            Bye();
583        }
584
585        /* willing to accept connections with a backlog of 5 pending */
586        if (listen (sfd, 5) < 0) {
587            fprintf (stderr, "%s: listen: %s\n", indi_tstamp(NULL), strerror(errno));
588            Bye();
589        }
590
591        /* ok */
592        lsocket = sfd;
593        if (verbose > 0)
594            fprintf (stderr, "%s: listening to port %d on fd %d\n",
595                                                indi_tstamp(NULL), port, sfd);
596}
597
598/* Attempt to open up FIFO */
599static void indiFIFO(void)
600{
601    /* Open up FIFO, if available */
602    if (fifo.name)
603    {
604        fifo.fd = open(fifo.name, O_RDONLY);
605                  if (fifo.fd < 0)
606                  {
607                       fprintf(stderr, "%s: open(%s): %s.\n", indi_tstamp(NULL), fifo.name, strerror(errno));
608                        Bye();
609                   }
610
611        fifo.fs = fdopen(fifo.fd, "r");
612    }
613}
614
615/* service traffic from clients and drivers */
616static void
617indiRun(void)
618{
619        fd_set rs, ws;
620        int maxfd=0;
621        int i, s;
622
623        /* init with no writers or readers */
624        FD_ZERO(&ws);
625        FD_ZERO(&rs);
626
627        if (fifo.name && fifo.fd > 0)
628        {
629           FD_SET(fifo.fd, &rs);
630           maxfd = fifo.fd;
631        }
632
633        /* always listen for new clients */
634        FD_SET(lsocket, &rs);
635        if (lsocket > maxfd)
636                maxfd = lsocket;
637
638        /* add all client readers and client writers with work to send */
639        for (i = 0; i < nclinfo; i++) {
640            ClInfo *cp = &clinfo[i];
641            if (cp->active) {
642                FD_SET(cp->s, &rs);
643                if (nFQ(cp->msgq) > 0)
644                    FD_SET(cp->s, &ws);
645                if (cp->s > maxfd)
646                    maxfd = cp->s;
647            }
648        }
649
650        /* add all driver readers and driver writers with work to send */
651        for (i = 0; i < ndvrinfo; i++)
652        {
653            DvrInfo *dp = &dvrinfo[i];
654            if (dp->active)
655            {
656                FD_SET(dp->rfd, &rs);
657                if (dp->rfd > maxfd)
658                   maxfd = dp->rfd;
659                if (dp->pid != REMOTEDVR)
660                {
661                   FD_SET(dp->efd, &rs);
662                   if (dp->efd > maxfd)
663                      maxfd = dp->efd;
664                }
665                if (nFQ(dp->msgq) > 0)
666                {
667                   FD_SET(dp->wfd, &ws);
668                   if (dp->wfd > maxfd)
669                       maxfd = dp->wfd;
670                }
671            }
672        }
673
674        /* wait for action */
675        s = select (maxfd+1, &rs, &ws, NULL, NULL);
676        if (s < 0) {
677            fprintf (stderr, "%s: select(%d): %s\n", indi_tstamp(NULL), maxfd+1,
678                                                            strerror(errno));
679            Bye();
680        }
681
682
683        /* new command from FIFO? */
684        if (s > 0 && FD_ISSET(fifo.fd, &rs)) {
685            newFIFO();
686            s--;
687        }
688
689        /* new client? */
690        if (s > 0 && FD_ISSET(lsocket, &rs)) {
691            newClient();
692            s--;
693        }
694
695        /* message to/from client? */
696        for (i = 0; s > 0 && i < nclinfo; i++) {
697            ClInfo *cp = &clinfo[i];
698            if (cp->active) {
699                if (FD_ISSET(cp->s, &rs)) {
700                    if (readFromClient(cp) < 0)
701                        return; /* fds effected */
702                    s--;
703                }
704                if (s > 0 && FD_ISSET(cp->s, &ws)) {
705                    if (sendClientMsg(cp) < 0)
706                        return; /* fds effected */
707                    s--;
708                }
709            }
710        }
711
712        /* message to/from driver? */
713        for (i = 0; s > 0 && i < ndvrinfo; i++) {
714            DvrInfo *dp = &dvrinfo[i];
715            if (dp->pid != REMOTEDVR && FD_ISSET(dp->efd, &rs)) {
716                if (stderrFromDriver(dp) < 0)
717                    return;     /* fds effected */
718                s--;
719            }
720            if (s > 0 && FD_ISSET(dp->rfd, &rs)) {
721                if (readFromDriver(dp) < 0)
722                    return;     /* fds effected */
723                s--;
724            }
725            if (s > 0 && FD_ISSET(dp->wfd, &ws) && nFQ(dp->msgq) > 0) {
726                if (sendDriverMsg(dp) < 0)
727                    return;     /* fds effected */
728                s--;
729            }
730        }
731}
732
733/* Read commands from FIFO and process them. Start/stop drivers accordingly */
734static void newFIFO(void)
735{
736    char line[MAXRBUF], tDriver[MAXRBUF], tConfig[MAXRBUF], tDev[MAXRBUF];
737    static char *envDev=NULL, *envConfig=NULL;
738    const char *delm = " ";
739    char *token, *cp;
740    DvrInfo *dp = NULL;
741    int startCmd=0;
742
743    if (envDev == NULL)
744        envDev = (char *) malloc(MAXRBUF* sizeof(char));
745    if (envConfig == NULL)
746        envConfig = (char *) malloc(MAXRBUF * sizeof(char));
747
748    while ( fgets (line, MAXRBUF, fifo.fs) != NULL)
749    {
750        //fprintf(stderr, "FIFO: %s\n", line);
751        tDev[0] = '\0', tDriver[0] = '\0', tConfig[0] = '\0', envDev[0] = '\0', envConfig[0] = '\0';
752        cp = strdup(line);
753
754        token = strsep(&cp, delm);
755
756        if (!strcmp(token, "start") || !strcmp(token, "stop"))
757        {
758                if (!strcmp(token, "start"))
759                    startCmd = 1;
760
761                token = strsep(&cp, delm);
762
763                if (!token)
764                    continue;
765
766               strncpy(tDriver, token, MAXRBUF);
767
768               if (verbose)
769                fprintf(stderr, "FIFO: Request for %s driver: %s\n", (startCmd == 1) ? "starting" : "stopping", tDriver);
770
771               /* Find more name + config */
772               token = strsep(&cp, delm);
773
774               if (token)
775               {
776                 /* If config file detected, copy it */
777                if (strstr(token, ".xml"))                 
778                    strncpy(tConfig, token, MAXRBUF);
779                /* Get rid of quotes */
780                else if (strstr(token, "\"") || strstr(token, "'"))
781                {
782                    strncat(tDev, ++token, MAXRBUF);
783                    while (token = strsep(&cp, delm) )
784                   {
785                     strcat(tDev, " ");
786                     strncat(tDev, token, MAXRBUF);
787                     if (strstr(token, "\"") || strstr(token, "'"))
788                     {
789                         tDev[strlen(tDev)-1] = '\0';
790                         break;
791                     }
792                    }
793                 }
794                 else
795                     strncpy(tDev, token, MAXRBUF);
796
797                  /* Find config, if there is any */
798                  token = strsep(&cp, delm);
799                  if (token)
800                  {
801                      /* Get rid of quotes */
802                      if (strstr(token, "\"") || strstr(token, "'"))
803                      {
804                       strncat(tConfig, ++token, MAXRBUF);
805                       while (token = strsep(&cp, delm) )
806                       {
807                          strcat(tConfig, " ");
808                          strncat(tConfig, token, MAXRBUF);
809
810                          if (strstr(token, "\"") || strstr(token, "'"))
811                          {
812                                 tConfig[strlen(tConfig)-1] = '\0';
813                                 break;
814                          }
815                       }
816                      }
817                       else
818                           strncpy(tConfig, token, MAXRBUF);
819                  }
820              }
821
822               /* Did we find device name? */
823               if (tDev[0])
824               {
825                 snprintf(envDev, MAXRBUF, "INDIDEV=%s", tDev);
826                 //fprintf(stderr, "With name: %s\n", envDev);
827                 putenv(envDev);
828
829                 //fprintf(stderr, "envionment check INDIDEV: %s\n", getenv("INDIDEV"));
830               }
831
832               /* Did we find config file */
833               if (tConfig[0])
834               {
835                   snprintf(envConfig, MAXRBUF, "INDICONFIG=%s", tConfig);
836                   //fprintf(stderr, "With config: %s\n", envConfig);
837                   putenv(envConfig);
838               }
839
840               if (startCmd)
841               {
842                   if (verbose)
843                        fprintf(stderr, "FIFO: Starting driver %s\n", tDriver);
844                    dp = allocDvr();
845                    strncpy(dp->name, tDriver, MAXINDIDEVICE);
846                    strncpy(dp->dev, tDev, MAXINDIDEVICE);
847                    startDvr (dp);
848              }
849               else
850               {
851                  for (dp = dvrinfo; dp < &dvrinfo[ndvrinfo]; dp++)
852                   {
853                       if (!strcmp(dp->name, tDriver))
854                       {
855                           /* If device name is given, check against it before shutting down */
856                           if (tDev[0] && strcmp(dp->dev, tDev))
857                               continue;
858
859                           if (verbose)
860                               fprintf(stderr, "FIFO: Shutting down driver: %s\n", tDriver);
861
862                           shutdownDvr(dp, 0);
863
864                               /* Inform clients that this driver is dead */
865                               XMLEle *root = addXMLEle (NULL, "delProperty");
866                               addXMLAtt(root, "device", dp->dev);
867                               Msg * mp = newMsg();
868
869                               q2Clients(NULL, 0, dp->dev, NULL, mp, root);
870                               if (mp->count > 0)
871                                   setMsgXMLEle (mp, root);
872                               else
873                                   freeMsg (mp);
874                               delXMLEle (root);
875
876                           break;
877
878                       }
879                   }
880               }
881         }
882    }
883}
884
885/* prepare for new client arriving on lsocket.
886 * exit if trouble.
887 */
888static void
889newClient()
890{
891        ClInfo *cp = NULL;
892        int s, cli;
893
894        /* assign new socket */
895        s = newClSocket ();
896
897        /* try to reuse a clinfo slot, else add one */
898        for (cli = 0; cli < nclinfo; cli++)
899            if (!(cp = &clinfo[cli])->active)
900                break;
901        if (cli == nclinfo) {
902            /* grow clinfo */
903            clinfo = (ClInfo *) realloc (clinfo, (nclinfo+1)*sizeof(ClInfo));
904            if (!clinfo) {
905                fprintf (stderr, "no memory for new client\n");
906                Bye();
907            }
908            cp = &clinfo[nclinfo++];
909        }
910
911        /* rig up new clinfo entry */
912        memset (cp, 0, sizeof(*cp));
913        cp->active = 1;
914        cp->s = s;
915        cp->lp = newLilXML();
916        cp->msgq = newFQ(1);
917        cp->props = malloc (1);
918        cp->nsent = 0;
919
920        if (verbose > 0) {
921            struct sockaddr_in addr;
922            socklen_t len = sizeof(addr);
923            getpeername(s, (struct sockaddr*)&addr, &len);
924            fprintf(stderr,"%s: Client %d: new arrival from %s:%d - welcome!\n",
925                            indi_tstamp(NULL), cp->s, inet_ntoa(addr.sin_addr),
926                                                        ntohs(addr.sin_port));
927        }
928}
929
930/* read more from the given client, send to each appropriate driver when see
931 * xml closure. also send all newXXX() to all other interested clients.
932 * return -1 if had to shut down anything, else 0.
933 */
934static int
935readFromClient (ClInfo *cp)
936{
937        char buf[MAXRBUF];
938        int shutany = 0;
939        int i, nr;
940
941        /* read client */
942        nr = read (cp->s, buf, sizeof(buf));
943        if (nr <= 0) {
944            if (nr < 0)
945                fprintf (stderr, "%s: Client %d: read: %s\n", indi_tstamp(NULL),
946                                                        cp->s, strerror(errno));
947            else if (verbose > 0)
948                fprintf (stderr, "%s: Client %d: read EOF\n", indi_tstamp(NULL),
949                                                                        cp->s);
950            shutdownClient (cp);
951            return (-1);
952        }
953
954        /* process XML, sending when find closure */
955        for (i = 0; i < nr; i++) {
956            char err[1024];
957            XMLEle *root = readXMLEle (cp->lp, buf[i], err);
958            if (root) {
959                char *roottag = tagXMLEle(root);
960                const char *dev = findXMLAttValu (root, "device");
961                const char *name = findXMLAttValu (root, "name");
962                int isblob = !strcmp (tagXMLEle(root), "setBLOBVector");
963                Msg *mp;
964
965                if (verbose > 2) {
966                    fprintf (stderr, "%s: Client %d: read ",indi_tstamp(NULL),cp->s);
967                    traceMsg (root);
968                } else if (verbose > 1) {
969                    fprintf (stderr, "%s: Client %d: read <%s device='%s' name='%s'>\n",
970                                    indi_tstamp(NULL), cp->s, tagXMLEle(root),
971                                    findXMLAttValu (root, "device"),
972                                    findXMLAttValu (root, "name"));
973                }
974
975                /* snag interested properties.
976                 * N.B. don't open to alldevs if seen specific dev already, else
977                 *   remote client connections start returning too much.
978                 */
979                if (dev[0])
980                    addClDevice (cp, dev, name);
981                else if (!strcmp (roottag, "getProperties") && !cp->nprops)
982                    cp->allprops = 1;
983
984                /* snag enableBLOB -- send to remote drivers too */
985                if (!strcmp (roottag, "enableBLOB"))
986                    crackBLOB (pcdataXMLEle(root), &cp->blob);
987
988                /* build a new message -- set content iff anyone cares */
989                mp = newMsg();
990
991                /* send message to driver(s) responsible for dev */
992                q2RDrivers (dev, mp, root);
993
994                /* echo new* commands back to other clients */
995                if (!strncmp (roottag, "new", 3)) {
996                    if (q2Clients (cp, isblob, dev, name, mp, root) < 0)
997                        shutany++;
998                }
999
1000                /* set message content if anyone cares else forget it */
1001                if (mp->count > 0)
1002                    setMsgXMLEle (mp, root);
1003                else
1004                    freeMsg (mp);
1005                delXMLEle (root);
1006
1007            } else if (err[0]) {
1008                char *ts = indi_tstamp(NULL);
1009                fprintf (stderr, "%s: Client %d: XML error: %s\n", ts,
1010                                                                cp->s, err);
1011                fprintf (stderr, "%s: Client %d: XML read: %.*s\n", ts,
1012                                                            cp->s, nr, buf);
1013                shutdownClient (cp);
1014                return (-1);
1015            }
1016        }
1017
1018        return (shutany ? -1 : 0);
1019}
1020
1021/* read more from the given driver, send to each interested client when see
1022 * xml closure. if driver dies, try restarting.
1023 * return 0 if ok else -1 if had to shut down anything.
1024 */
1025static int
1026readFromDriver (DvrInfo *dp)
1027{
1028        char buf[MAXRBUF];
1029        int shutany = 0;
1030        int i, nr;
1031
1032        /* read driver */
1033        nr = read (dp->rfd, buf, sizeof(buf));
1034        if (nr <= 0) {
1035            if (nr < 0)
1036                fprintf (stderr, "%s: Driver %s: stdin %s\n", indi_tstamp(NULL),
1037                                                    dp->name, strerror(errno));
1038            else
1039                fprintf (stderr, "%s: Driver %s: stdin EOF\n",
1040                                                        indi_tstamp(NULL), dp->name);
1041            shutdownDvr (dp, 1);
1042            return (-1);
1043        }
1044
1045        /* process XML, sending when find closure */
1046        for (i = 0; i < nr; i++) {
1047            char err[1024];
1048            XMLEle *root = readXMLEle (dp->lp, buf[i], err);
1049            if (root) {
1050                char *roottag = tagXMLEle(root);
1051                const char *dev = findXMLAttValu (root, "device");
1052                const char *name = findXMLAttValu (root, "name");
1053                int isblob = !strcmp (tagXMLEle(root), "setBLOBVector");
1054                Msg *mp;
1055
1056                if (verbose > 2) {
1057                    fprintf(stderr, "%s: Driver %s: read ", indi_tstamp(0),dp->name);
1058                    traceMsg (root);
1059                } else if (verbose > 1) {
1060                    fprintf (stderr, "%s: Driver %s: read <%s device='%s' name='%s'>\n",
1061                                    indi_tstamp(NULL), dp->name, tagXMLEle(root),
1062                                    findXMLAttValu (root, "device"),
1063                                    findXMLAttValu (root, "name"));
1064                }
1065
1066                /* that's all if driver is just registering a snoop */
1067                if (!strcmp (roottag, "getProperties")) {
1068                    addSDevice (dp, dev, name);
1069                    delXMLEle (root);
1070                    continue;
1071                }
1072
1073                /* that's all if driver is just registering a BLOB mode */
1074                if (!strcmp (roottag, "enableBLOB")) {
1075                    Snoopee *sp = findSDevice (dp, dev, name);
1076                    if (sp)
1077                        crackBLOB (pcdataXMLEle (root), &sp->blob);
1078                    delXMLEle (root);
1079                    continue;
1080                }
1081
1082                /* snag device name if not known yet */
1083                if (!dp->dev[0] && dev[0]) {
1084                    strncpy (dp->dev, dev, MAXINDIDEVICE-1);
1085                    dp->dev[MAXINDIDEVICE-1] = '\0';
1086                }
1087
1088                /* log messages if any and wanted */
1089                if (ldir)
1090                    logDMsg (root, dev);
1091
1092                /* build a new message -- set content iff anyone cares */
1093                mp = newMsg();
1094
1095                /* send to interested clients */
1096                if (q2Clients (NULL, isblob, dev, name, mp, root) < 0)
1097                    shutany++;
1098
1099                /* send to snooping drivers */
1100                q2SDrivers (isblob, dev, name, mp, root);
1101
1102                /* set message content if anyone cares else forget it */
1103                if (mp->count > 0)
1104                    setMsgXMLEle (mp, root);
1105                else
1106                    freeMsg (mp);
1107                delXMLEle (root);
1108
1109            } else if (err[0]) {
1110                char *ts = indi_tstamp(NULL);
1111                fprintf (stderr, "%s: Driver %s: XML error: %s\n", ts,
1112                                                                dp->name, err);
1113                fprintf (stderr, "%s: Driver %s: XML read: %.*s\n", ts,
1114                                                            dp->name, nr, buf);
1115                shutdownDvr (dp, 1);
1116                return (-1);
1117            }
1118        }
1119
1120        return (shutany ? -1 : 0);
1121}
1122
1123/* read more from the given driver stderr, add prefix and send to our stderr.
1124 * return 0 if ok else -1 if had to restart.
1125 */
1126static int
1127stderrFromDriver (DvrInfo *dp)
1128{
1129        static char exbuf[MAXRBUF];
1130        static int nexbuf;
1131        int i, nr;
1132
1133        /* read more */
1134        nr = read (dp->efd, exbuf+nexbuf, sizeof(exbuf)-nexbuf);
1135        if (nr <= 0) {
1136            if (nr < 0)
1137                fprintf (stderr, "%s: Driver %s: stderr %s\n", indi_tstamp(NULL),
1138                                                    dp->name, strerror(errno));
1139            else
1140                fprintf (stderr, "%s: Driver %s: stderr EOF\n",
1141                                                        indi_tstamp(NULL), dp->name);
1142            shutdownDvr (dp, 1);
1143            return (-1);
1144        }
1145        nexbuf += nr;
1146
1147        /* prefix each whole line to our stderr, save extra for next time */
1148        for (i = 0; i < nexbuf; i++) {
1149            if (exbuf[i] == '\n') {
1150                fprintf (stderr, "%s: Driver %s: %.*s\n", indi_tstamp(NULL),
1151                                                            dp->name, i, exbuf);
1152                i++;                              /* count including nl */
1153                nexbuf -= i;                      /* remove from nexbuf */
1154                memmove (exbuf, exbuf+i, nexbuf); /* slide remaining to front */
1155                i = -1;                           /* restart for loop scan */
1156            }
1157        }
1158
1159        return (0);
1160}
1161
1162/* close down the given client */
1163static void
1164shutdownClient (ClInfo *cp)
1165{
1166        Msg *mp;
1167
1168        /* close connection */
1169        shutdown (cp->s, SHUT_RDWR);
1170        close (cp->s);
1171
1172        /* free memory */
1173        delLilXML (cp->lp);
1174        free (cp->props);
1175
1176        /* decrement and possibly free any unsent messages for this client */
1177        while ((mp = (Msg*) popFQ(cp->msgq)) != NULL)
1178            if (--mp->count == 0)
1179                freeMsg (mp);
1180        delFQ (cp->msgq);
1181
1182        /* ok now to recycle */
1183        cp->active = 0;
1184
1185        if (verbose > 0)
1186            fprintf (stderr, "%s: Client %d: shut down complete - bye!\n",
1187                                                        indi_tstamp(NULL), cp->s);
1188}
1189
1190/* close down the given driver and restart */
1191static void
1192shutdownDvr (DvrInfo *dp, int restart)
1193{
1194        Msg *mp;
1195
1196        /* make sure it's dead, reclaim resources */
1197        if (dp->pid == REMOTEDVR) {
1198            /* socket connection */
1199            shutdown (dp->wfd, SHUT_RDWR);
1200            close (dp->wfd);    /* same as rfd */
1201        } else {
1202            /* local pipe connection */
1203            kill (dp->pid, SIGKILL);    /* we've insured there are no zombies */
1204            close (dp->wfd);
1205            close (dp->rfd);
1206            close (dp->efd);
1207        }
1208
1209        /* free memory */
1210        free (dp->sprops);
1211        delLilXML (dp->lp);
1212
1213        /* ok now to recycle */
1214        dp->active = 0;
1215
1216        /* decrement and possibly free any unsent messages for this client */
1217        while ((mp = (Msg*) popFQ(dp->msgq)) != NULL)
1218            if (--mp->count == 0)
1219                freeMsg (mp);
1220        delFQ (dp->msgq);
1221
1222        if (restart)
1223        {
1224            fprintf (stderr, "%s: Driver %s: restart #%d\n", indi_tstamp(NULL),
1225                                                    dp->name, ++dp->restarts);
1226            startDvr (dp);
1227        }
1228
1229}
1230
1231/* put Msg mp on queue of each driver responsible for dev, or all drivers
1232 * if dev not specified.
1233 */
1234static void
1235q2RDrivers (const char *dev, Msg *mp, XMLEle *root)
1236{
1237        int sawremote = 0;
1238        DvrInfo *dp;
1239
1240        /* queue message to each interested driver.
1241         * N.B. don't send generic getProps to more than one remote driver,
1242         *   otherwise they all fan out and we get multiple responses back.
1243         */
1244        for (dp = dvrinfo; dp < &dvrinfo[ndvrinfo]; dp++) {
1245            int isremote = (dp->pid == REMOTEDVR);
1246            if (dev[0] && dp->dev[0] && strcmp (dev, dp->dev))
1247                continue;       /* driver known to not support this dev */
1248            if (!dev[0] && isremote && sawremote)
1249                continue;       /* already sent generic to another remote */
1250            if (isremote)
1251                sawremote = 1;
1252
1253            /* ok: queue message to this driver */
1254            mp->count++;
1255            pushFQ (dp->msgq, mp);
1256            if (verbose > 1)
1257                fprintf (stderr, "%s: Driver %s: queuing responsible for <%s device='%s' name='%s'>\n",
1258                                    indi_tstamp(NULL), dp->name, tagXMLEle(root),
1259                                    findXMLAttValu (root, "device"),
1260                                    findXMLAttValu (root, "name"));
1261        }
1262}
1263
1264/* put Msg mp on queue of each driver snooping dev/name.
1265 * if BLOB always honor current mode.
1266 */
1267static void
1268q2SDrivers (int isblob, const char *dev, const char *name, Msg *mp, XMLEle *root)
1269{
1270        DvrInfo *dp;
1271
1272        for (dp = dvrinfo; dp < &dvrinfo[ndvrinfo]; dp++) {
1273            Snoopee *sp = findSDevice (dp, dev, name);
1274
1275            /* nothing for dp if not snooping for dev/name or wrong BLOB mode */
1276            if (!sp)
1277                continue;
1278            if ((isblob && sp->blob==B_NEVER) || (!isblob && sp->blob==B_ONLY))
1279                continue;
1280
1281            /* ok: queue message to this device */
1282            mp->count++;
1283            pushFQ (dp->msgq, mp);
1284            if (verbose > 1) {
1285                fprintf (stderr, "%s: Driver %s: queuing snooped <%s device='%s' name='%s'>\n",
1286                                    indi_tstamp(NULL), dp->name, tagXMLEle(root),
1287                                    findXMLAttValu (root, "device"),
1288                                    findXMLAttValu (root, "name"));
1289            }
1290        }
1291}
1292
1293/* add dev/name to dp's snooping list.
1294 * init with blob mode set to B_NEVER.
1295 */
1296static void
1297addSDevice (DvrInfo *dp, const char *dev, const char *name)
1298{
1299        Snoopee *sp;
1300        char *ip;
1301
1302        /* no dups */
1303        sp = findSDevice (dp, dev, name);
1304        if (sp)
1305            return;
1306
1307        /* add dev to sdevs list */
1308        dp->sprops = (Snoopee*) realloc (dp->sprops,
1309                                            (dp->nsprops+1)*sizeof(Snoopee));
1310        sp = &dp->sprops[dp->nsprops++];
1311
1312        ip = sp->prop.dev;
1313        strncpy (ip, dev, MAXINDIDEVICE-1);
1314        ip[MAXINDIDEVICE-1] = '\0';
1315
1316        ip = sp->prop.name;
1317        strncpy (ip, name, MAXINDINAME-1);
1318        ip[MAXINDINAME-1] = '\0';
1319
1320        sp->blob = B_NEVER;
1321
1322        if (verbose)
1323            fprintf (stderr, "%s: Driver %s: snooping on %s.%s\n", indi_tstamp(NULL),
1324                                                        dp->name, dev, name);
1325}
1326
1327/* return Snoopee if dp is snooping dev/name, else NULL.
1328 */
1329static Snoopee *
1330findSDevice (DvrInfo *dp, const char *dev, const char *name)
1331{
1332        int i;
1333
1334        for (i = 0; i < dp->nsprops; i++) {
1335            Snoopee *sp = &dp->sprops[i];
1336            Property *pp = &sp->prop;
1337            if (!strcmp (pp->dev, dev) &&
1338                    (!pp->name[0] || !strcmp(pp->name, name)))
1339                return (sp);
1340        }
1341
1342        return (NULL);
1343}
1344
1345/* put Msg mp on queue of each client interested in dev/name, except notme.
1346 * if BLOB always honor current mode.
1347 * return -1 if had to shut down any clients, else 0.
1348 */
1349static int
1350q2Clients (ClInfo *notme, int isblob, const char *dev, const char *name, Msg *mp, XMLEle *root)
1351{
1352        int shutany = 0;
1353        ClInfo *cp;
1354        int ql;
1355
1356        /* queue message to each interested client */
1357        for (cp = clinfo; cp < &clinfo[nclinfo]; cp++) {
1358            /* cp in use? notme? want this dev/name? blob? */
1359            if (!cp->active || cp == notme)
1360                continue;
1361            if (findClDevice (cp, dev, name) < 0)
1362                continue;
1363            if ((isblob && cp->blob==B_NEVER) || (!isblob && cp->blob==B_ONLY))
1364                continue;
1365
1366            /* shut down this client if its q is already too large */
1367            ql = msgQSize(cp->msgq);
1368            if (ql > maxqsiz) {
1369                if (verbose)
1370                    fprintf (stderr, "%s: Client %d: %d bytes behind, shutting down\n",
1371                                                    indi_tstamp(NULL), cp->s, ql);
1372                shutdownClient (cp);
1373                shutany++;
1374                continue;
1375            }
1376
1377            /* ok: queue message to this client */
1378            mp->count++;
1379            pushFQ (cp->msgq, mp);
1380            if (verbose > 1)
1381                fprintf (stderr, "%s: Client %d: queuing <%s device='%s' name='%s'>\n",
1382                                    indi_tstamp(NULL), cp->s, tagXMLEle(root),
1383                                    findXMLAttValu (root, "device"),
1384                                    findXMLAttValu (root, "name"));
1385        }
1386
1387        return (shutany ? -1 : 0);
1388}
1389
1390/* return size of all Msqs on the given q */
1391static int
1392msgQSize (FQ *q)
1393{
1394        int i, l = 0;
1395
1396        for (i = 0; i < nFQ(q); i++) {
1397            Msg *mp = (Msg *) peekiFQ(q,i);
1398            l += mp->cl;
1399        }
1400
1401        return (l);
1402}
1403
1404/* print root as content in Msg mp.
1405 */
1406static void
1407setMsgXMLEle (Msg *mp, XMLEle *root)
1408{
1409        /* want cl to only count content, but need room for final \0 */
1410        mp->cl = sprlXMLEle (root, 0);
1411        if (mp->cl < sizeof(mp->buf))
1412            mp->cp = mp->buf;
1413        else
1414            mp->cp = malloc (mp->cl+1);
1415        sprXMLEle (mp->cp, root, 0);
1416}
1417
1418/* save str as content in Msg mp.
1419 */
1420static void
1421setMsgStr (Msg *mp, char *str)
1422{
1423        /* want cl to only count content, but need room for final \0 */
1424        mp->cl = strlen (str);
1425        if (mp->cl < sizeof(mp->buf))
1426            mp->cp = mp->buf;
1427        else
1428            mp->cp = malloc (mp->cl+1);
1429        strcpy (mp->cp, str);
1430}
1431
1432/* return pointer to one new nulled Msg
1433 */
1434static Msg *
1435newMsg (void)
1436{
1437        return ((Msg *) calloc (1, sizeof(Msg)));
1438}
1439
1440/* free Msg mp and everything it contains */
1441static void
1442freeMsg (Msg *mp)
1443{
1444        if (mp->cp && mp->cp != mp->buf)
1445            free (mp->cp);
1446        free (mp);
1447}
1448
1449/* write the next chunk of the current message in the queue to the given
1450 * client. pop message from queue when complete and free the message if we are
1451 * the last one to use it. shut down this client if trouble.
1452 * N.B. we assume we will never be called with cp->msgq empty.
1453 * return 0 if ok else -1 if had to shut down.
1454 */
1455static int
1456sendClientMsg (ClInfo *cp)
1457{
1458        int nsend, nw;
1459        Msg *mp;
1460
1461        /* get current message */
1462        mp = (Msg *) peekFQ (cp->msgq);
1463
1464        /* send next chunk, never more than MAXWSIZ to reduce blocking */
1465        nsend = mp->cl - cp->nsent;
1466        if (nsend > MAXWSIZ)
1467            nsend = MAXWSIZ;
1468        nw = write (cp->s, &mp->cp[cp->nsent], nsend);
1469
1470        /* shut down if trouble */
1471        if (nw <= 0) {
1472            if (nw == 0)
1473                fprintf (stderr, "%s: Client %d: write returned 0\n",
1474                                                    indi_tstamp(NULL), cp->s);
1475            else
1476                fprintf (stderr, "%s: Client %d: write: %s\n", indi_tstamp(NULL),
1477                                                    cp->s, strerror(errno));
1478            shutdownClient (cp);
1479            return (-1);
1480        }
1481
1482        /* trace */
1483        if (verbose > 2) {
1484            fprintf(stderr, "%s: Client %d: sending msg copy %d nq %d:\n%.*s\n",
1485                                indi_tstamp(NULL), cp->s, mp->count, nFQ(cp->msgq),
1486                                nw, &mp->cp[cp->nsent]);
1487        } else if (verbose > 1) {
1488            fprintf(stderr, "%s: Client %d: sending %.50s\n", indi_tstamp(NULL),
1489                                                    cp->s, &mp->cp[cp->nsent]);
1490        }
1491
1492        /* update amount sent. when complete: free message if we are the last
1493         * to use it and pop from our queue.
1494         */
1495        cp->nsent += nw;
1496        if (cp->nsent == mp->cl) {
1497            if (--mp->count == 0)
1498                freeMsg (mp);
1499            popFQ (cp->msgq);
1500            cp->nsent = 0;
1501        }
1502
1503        return (0);
1504}
1505
1506/* write the next chunk of the current message in the queue to the given
1507 * driver. pop message from queue when complete and free the message if we are
1508 * the last one to use it. restart this driver if touble.
1509 * N.B. we assume we will never be called with dp->msgq empty.
1510 * return 0 if ok else -1 if had to shut down.
1511 */
1512static int
1513sendDriverMsg (DvrInfo *dp)
1514{
1515        int nsend, nw;
1516        Msg *mp;
1517
1518        /* get current message */
1519        mp = (Msg *) peekFQ (dp->msgq);
1520
1521        /* send next chunk, never more than MAXWSIZ to reduce blocking */
1522        nsend = mp->cl - dp->nsent;
1523        if (nsend > MAXWSIZ)
1524            nsend = MAXWSIZ;
1525        nw = write (dp->wfd, &mp->cp[dp->nsent], nsend);
1526
1527        /* restart if trouble */
1528        if (nw <= 0) {
1529            if (nw == 0)
1530                fprintf (stderr, "%s: Driver %s: write returned 0\n",
1531                                                    indi_tstamp(NULL), dp->name);
1532            else
1533                fprintf (stderr, "%s: Driver %s: write: %s\n", indi_tstamp(NULL),
1534                                                    dp->name, strerror(errno));
1535            shutdownDvr (dp, 1);
1536            return (-1);
1537        }
1538
1539        /* trace */
1540        if (verbose > 2) {
1541            fprintf(stderr, "%s: Driver %s: sending msg copy %d nq %d:\n%.*s\n",
1542                            indi_tstamp(NULL), dp->name, mp->count, nFQ(dp->msgq),
1543                            nw, &mp->cp[dp->nsent]);
1544        } else if (verbose > 1) {
1545            fprintf(stderr, "%s: Driver %s: sending %.50s\n", indi_tstamp(NULL),
1546                                                dp->name, &mp->cp[dp->nsent]);
1547        }
1548
1549        /* update amount sent. when complete: free message if we are the last
1550         * to use it and pop from our queue.
1551         */
1552        dp->nsent += nw;
1553        if (dp->nsent == mp->cl) {
1554            if (--mp->count == 0)
1555                freeMsg (mp);
1556            popFQ (dp->msgq);
1557            dp->nsent = 0;
1558        }
1559
1560        return (0);
1561}
1562
1563/* return 0 if cp may be interested in dev/name else -1
1564 */
1565static int
1566findClDevice (ClInfo *cp, const char *dev, const char *name)
1567{
1568        int i;
1569
1570        if (cp->allprops || !dev[0])
1571            return (0);
1572        for (i = 0; i < cp->nprops; i++) {
1573            Property *pp = &cp->props[i];
1574            if (!strcmp (pp->dev, dev) &&
1575                                    (!pp->name[0] || !strcmp(pp->name, name)))
1576                return (0);
1577        }
1578        return (-1);
1579}
1580
1581/* add the given device and property to the devs[] list of client if new.
1582 */
1583static void
1584addClDevice (ClInfo *cp, const char *dev, const char *name)
1585{
1586        Property *pp;
1587        char *ip;
1588
1589        /* no dups */
1590        if (!findClDevice (cp, dev, name))
1591            return;
1592
1593        /* add */
1594        cp->props = (Property *) realloc (cp->props,
1595                                            (cp->nprops+1)*sizeof(Property));
1596        pp = &cp->props[cp->nprops++];
1597
1598        ip = pp->dev;
1599        strncpy (ip, dev, MAXINDIDEVICE-1);
1600        ip[MAXINDIDEVICE-1] = '\0';
1601
1602        ip = pp->name;
1603        strncpy (ip, name, MAXINDINAME-1);
1604        ip[MAXINDINAME-1] = '\0';
1605}
1606
1607
1608/* block to accept a new client arriving on lsocket.
1609 * return private nonblocking socket or exit.
1610 */
1611static int
1612newClSocket ()
1613{
1614        struct sockaddr_in cli_socket;
1615        socklen_t cli_len;
1616        int cli_fd;
1617
1618        /* get a private connection to new client */
1619        cli_len = sizeof(cli_socket);
1620        cli_fd = accept (lsocket, (struct sockaddr *)&cli_socket, &cli_len);
1621        if(cli_fd < 0) {
1622            fprintf (stderr, "accept: %s\n", strerror(errno));
1623            Bye();
1624        }
1625
1626        /* ok */
1627        return (cli_fd);
1628}
1629
1630/* convert the string value of enableBLOB to our B_ state value.
1631 * no change if unrecognized
1632 */
1633static void
1634crackBLOB (char *enableBLOB, BLOBHandling *bp)
1635{
1636        if (!strcmp (enableBLOB, "Also"))
1637            *bp = B_ALSO;
1638        else if (!strcmp (enableBLOB, "Only"))
1639            *bp = B_ONLY;
1640        else if (!strcmp (enableBLOB, "Never"))
1641            *bp = B_NEVER;
1642}
1643
1644/* print key attributes and values of the given xml to stderr.
1645 */
1646static void
1647traceMsg (XMLEle *root)
1648{
1649        static const char *prtags[] = {
1650            "defNumber", "oneNumber",
1651            "defText",   "oneText",
1652            "defSwitch", "oneSwitch",
1653            "defLight",  "oneLight",
1654        };
1655        XMLEle *e;
1656        const char *msg, *perm, *pcd;
1657        unsigned int i;
1658
1659        /* print tag header */
1660        fprintf (stderr, "%s %s %s %s", tagXMLEle(root),
1661                                                findXMLAttValu(root,"device"),
1662                                                findXMLAttValu(root,"name"),
1663                                                findXMLAttValu(root,"state"));
1664        pcd = pcdataXMLEle (root);
1665        if (pcd[0])
1666            fprintf (stderr, " %s", pcd);
1667        perm = findXMLAttValu(root,"perm");
1668        if (perm[0])
1669            fprintf (stderr, " %s", perm);
1670        msg = findXMLAttValu(root,"message");
1671        if (msg[0])
1672            fprintf (stderr, " '%s'", msg);
1673
1674        /* print each array value */
1675        for (e = nextXMLEle(root,1); e; e = nextXMLEle(root,0))
1676            for (i = 0; i < sizeof(prtags)/sizeof(prtags[0]); i++)
1677                if (strcmp (prtags[i], tagXMLEle(e)) == 0)
1678                    fprintf (stderr, "\n %10s='%s'", findXMLAttValu(e,"name"),
1679                                                            pcdataXMLEle (e));
1680
1681        fprintf (stderr, "\n");
1682}
1683
1684/* fill s with current UT string.
1685 * if no s, use a static buffer
1686 * return s or buffer.
1687 * N.B. if use our buffer, be sure to use before calling again
1688 */
1689static char *
1690indi_tstamp (char *s)
1691{
1692        static char sbuf[64];
1693        struct tm *tp;
1694        time_t t;
1695
1696        time (&t);
1697        tp = gmtime (&t);
1698        if (!s)
1699            s = sbuf;
1700        strftime (s, sizeof(sbuf), "%Y-%m-%dT%H:%M:%S", tp);
1701        return (s);
1702}
1703
1704/* log message in root known to be from device dev to ldir, if any.
1705 */
1706static void
1707logDMsg (XMLEle *root, const char *dev)
1708{
1709        char stamp[64];
1710        char logfn[1024];
1711        const char *ts, *ms;
1712        FILE *fp;
1713
1714        /* get message, if any */
1715        ms = findXMLAttValu (root, "message");
1716        if (!ms[0])
1717            return;
1718
1719        /* get timestamp now if not provided */
1720        ts = findXMLAttValu (root, "timestamp");
1721        if (!ts[0])
1722        {
1723            indi_tstamp (stamp);
1724            ts = stamp;
1725        }
1726
1727        /* append to log file, name is date portion of time stamp */
1728        sprintf (logfn, "%s/%.10s.islog", ldir, ts);
1729        fp = fopen (logfn, "a");
1730        if (!fp)
1731            return;     /* oh well */
1732        fprintf (fp, "%s: %s: %s\n", ts, dev, ms);
1733        fclose (fp);
1734}
1735
1736/* log when then exit */
1737static void
1738Bye()
1739{
1740        fprintf (stderr, "%s: good bye\n", indi_tstamp(NULL));
1741        exit(1);
1742}
1743
Note: See TracBrowser for help on using the repository browser.