source: BAORadio/libindi/v1/indiserver.c@ 622

Last change on this file since 622 was 490, checked in by campagne, 15 years ago

import libindi (JEC)
File size: 40.2 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
94/* info for each connected client */
95typedef struct {
96 int active; /* 1 when this record is in use */
97 Property *props; /* malloced array of props we want */
98 int nprops; /* n entries in props[] */
99 int allprops; /* saw getProperties w/o device */
100 BLOBHandling blob; /* when to send setBLOBs */
101 int s; /* socket for this client */
102 LilXML *lp; /* XML parsing context */
103 FQ *msgq; /* Msg queue */
104 unsigned int nsent; /* bytes of current Msg sent so far */
105} ClInfo;
106static ClInfo *clinfo; /* malloced pool of clients */
107static int nclinfo; /* n total (not active) */
108
109/* info for each connected driver */
110typedef struct {
111 const char *name; /* persistent malloced name */
112 char dev[MAXINDIDEVICE]; /* device served by this driver */
113 Snoopee *sprops; /* malloced array of props we snoop */
114 int nsprops; /* n entries in sprops[] */
115 int pid; /* process id or REMOTEDVR if remote */
116 int rfd; /* read pipe fd */
117 int wfd; /* write pipe fd */
118 int efd; /* stderr from driver, if local */
119 int restarts; /* times process has been restarted */
120 LilXML *lp; /* XML parsing context */
121 FQ *msgq; /* Msg queue */
122 unsigned int nsent; /* bytes of current Msg sent so far */
123} DvrInfo;
124static DvrInfo *dvrinfo; /* malloced array of drivers */
125static int ndvrinfo; /* n total */
126
127static char *me; /* our name */
128static int port = INDIPORT; /* public INDI port */
129static int verbose; /* chattiness */
130static int lsocket; /* listen socket */
131static char *ldir; /* where to log driver messages */
132static int maxqsiz = (DEFMAXQSIZ*1024*1024); /* kill if these bytes behind */
133
134static void logStartup(int ac, char *av[]);
135static void usage (void);
136static void noZombies (void);
137static void noSIGPIPE (void);
138static void indiRun (void);
139static void indiListen (void);
140static void newClient (void);
141static int newClSocket (void);
142static void shutdownClient (ClInfo *cp);
143static int readFromClient (ClInfo *cp);
144static void startDvr (DvrInfo *dp);
145static void startLocalDvr (DvrInfo *dp);
146static void startRemoteDvr (DvrInfo *dp);
147static int openINDIServer (char host[], int indi_port);
148static void restartDvr (DvrInfo *dp);
149static void q2RDrivers (const char *dev, Msg *mp, XMLEle *root);
150static void q2SDrivers (int isblob, const char *dev, const char *name, Msg *mp,
151 XMLEle *root);
152static int q2Clients (ClInfo *notme, int isblob, const char *dev, const char *name,
153 Msg *mp, XMLEle *root);
154static void addSDevice (DvrInfo *dp, const char *dev, const char *name);
155static Snoopee *findSDevice (DvrInfo *dp, const char *dev, const char *name);
156static void addClDevice (ClInfo *cp, const char *dev, const char *name);
157static int findClDevice (ClInfo *cp, const char *dev, const char *name);
158static int readFromDriver (DvrInfo *dp);
159static int stderrFromDriver (DvrInfo *dp);
160static int msgQSize (FQ *q);
161static void setMsgXMLEle (Msg *mp, XMLEle *root);
162static void setMsgStr (Msg *mp, char *str);
163static void freeMsg (Msg *mp);
164static Msg *newMsg (void);
165static int sendClientMsg (ClInfo *cp);
166static int sendDriverMsg (DvrInfo *cp);
167static void crackBLOB (char *enableBLOB, BLOBHandling *bp);
168static void traceMsg (XMLEle *root);
169static char *indi_tstamp (char *s);
170static void logDMsg (XMLEle *root, const char *dev);
171static void Bye(void);
172
173int
174main (int ac, char *av[])
175{
176 /* log startup */
177 logStartup(ac, av);
178
179 /* save our name */
180 me = av[0];
181
182 /* crack args */
183 while ((--ac > 0) && ((*++av)[0] == '-')) {
184 char *s;
185 for (s = av[0]+1; *s != '\0'; s++)
186 switch (*s) {
187 case 'l':
188 if (ac < 2) {
189 fprintf (stderr, "-l requires log directory\n");
190 usage();
191 }
192 ldir = *++av;
193 ac--;
194 break;
195 case 'm':
196 if (ac < 2) {
197 fprintf (stderr, "-m requires max MB behind\n");
198 usage();
199 }
200 maxqsiz = 1024*1024*atoi(*++av);
201 ac--;
202 break;
203 case 'p':
204 if (ac < 2) {
205 fprintf (stderr, "-p requires port value\n");
206 usage();
207 }
208 port = atoi(*++av);
209 ac--;
210 break;
211 case 'v':
212 verbose++;
213 break;
214 default:
215 usage();
216 }
217 }
218
219 /* at this point there are ac args in av[] to name our drivers */
220 if (ac == 0)
221 usage();
222
223 /* take care of some unixisms */
224 noZombies();
225 noSIGPIPE();
226
227 /* realloc seed for client pool */
228 clinfo = (ClInfo *) malloc (1);
229 nclinfo = 0;
230
231 /* create driver info array all at once since size never changes */
232 ndvrinfo = ac;
233 dvrinfo = (DvrInfo *) calloc (ndvrinfo, sizeof(DvrInfo));
234
235 /* start each driver */
236 while (ac-- > 0) {
237 dvrinfo[ac].name = *av++;
238 startDvr (&dvrinfo[ac]);
239 }
240
241 /* announce we are online */
242 indiListen();
243
244 /* handle new clients and all io */
245 while (1)
246 indiRun();
247
248 /* whoa! */
249 fprintf (stderr, "unexpected return from main\n");
250 return (1);
251}
252
253/* record we have started and our args */
254static void
255logStartup(int ac, char *av[])
256{
257 int i;
258
259 fprintf (stderr, "%s: startup: ", indi_tstamp(NULL));
260 for (i = 0; i < ac; i++)
261 fprintf (stderr, "%s ", av[i]);
262 fprintf (stderr, "\n");
263}
264
265/* print usage message and exit (2) */
266static void
267usage(void)
268{
269 fprintf (stderr, "Usage: %s [options] driver [driver ...]\n", me);
270 fprintf (stderr, "Purpose: server for local and remote INDI drivers\n");
271 fprintf (stderr, "Code %s. Protocol %g.\n", "$Revision: 726523 $", INDIV);
272 fprintf (stderr, "Options:\n");
273 fprintf (stderr, " -l d : log driver messages to <d>/YYYY-MM-DD.islog\n");
274 fprintf (stderr, " -m m : kill client if gets more than this many MB behind, default %d\n", DEFMAXQSIZ);
275 fprintf (stderr, " -p p : alternate IP port, default %d\n", INDIPORT);
276 fprintf (stderr, " -v : show key events, no traffic\n");
277 fprintf (stderr, " -vv : -v + key message content\n");
278 fprintf (stderr, " -vvv : -vv + complete xml\n");
279 fprintf (stderr, "driver : executable or device@host[:port]\n");
280
281 exit (2);
282}
283
284/* arrange for no zombies if drivers die */
285static void
286noZombies()
287{
288 struct sigaction sa;
289 sa.sa_handler = SIG_IGN;
290 sigemptyset(&sa.sa_mask);
291#ifdef SA_NOCLDWAIT
292 sa.sa_flags = SA_NOCLDWAIT;
293#else
294 sa.sa_flags = 0;
295#endif
296 (void)sigaction(SIGCHLD, &sa, NULL);
297}
298
299/* turn off SIGPIPE on bad write so we can handle it inline */
300static void
301noSIGPIPE()
302{
303 struct sigaction sa;
304 sa.sa_handler = SIG_IGN;
305 sigemptyset(&sa.sa_mask);
306 (void)sigaction(SIGPIPE, &sa, NULL);
307}
308
309/* start the given INDI driver process or connection.
310 * exit if trouble.
311 */
312static void
313startDvr (DvrInfo *dp)
314{
315 if (strchr (dp->name, '@'))
316 startRemoteDvr (dp);
317 else
318 startLocalDvr (dp);
319}
320
321/* start the given local INDI driver process.
322 * exit if trouble.
323 */
324static void
325startLocalDvr (DvrInfo *dp)
326{
327 Msg *mp;
328 char buf[1024];
329 int rp[2], wp[2], ep[2];
330 int pid;
331
332 /* build three pipes: r, w and error*/
333 if (pipe (rp) < 0) {
334 fprintf (stderr, "%s: read pipe: %s\n", indi_tstamp(NULL),
335 strerror(errno));
336 Bye();
337 }
338 if (pipe (wp) < 0) {
339 fprintf (stderr, "%s: write pipe: %s\n", indi_tstamp(NULL),
340 strerror(errno));
341 Bye();
342 }
343 if (pipe (ep) < 0) {
344 fprintf (stderr, "%s: stderr pipe: %s\n", indi_tstamp(NULL),
345 strerror(errno));
346 Bye();
347 }
348
349 /* fork&exec new process */
350 pid = fork();
351 if (pid < 0) {
352 fprintf (stderr, "%s: fork: %s\n", indi_tstamp(NULL), strerror(errno));
353 Bye();
354 }
355 if (pid == 0) {
356 /* child: exec name */
357 int fd;
358
359 /* rig up pipes */
360 dup2 (wp[0], 0); /* driver stdin reads from wp[0] */
361 dup2 (rp[1], 1); /* driver stdout writes to rp[1] */
362 dup2 (ep[1], 2); /* driver stderr writes to e[]1] */
363 for (fd = 3; fd < 100; fd++)
364 (void) close (fd);
365
366 /* go -- should never return */
367 execlp (dp->name, dp->name, NULL);
368 fprintf (stderr, "%s: Driver %s: execlp: %s\n", indi_tstamp(NULL),
369 dp->name, strerror(errno));
370 _exit (1); /* parent will notice EOF shortly */
371 }
372
373 /* don't need child's side of pipes */
374 close (wp[0]);
375 close (rp[1]);
376 close (ep[1]);
377
378 /* record pid, io channels, init lp and snoop list */
379 dp->pid = pid;
380 dp->rfd = rp[0];
381 dp->wfd = wp[1];
382 dp->efd = ep[0];
383 dp->lp = newLilXML();
384 dp->msgq = newFQ(1);
385 dp->sprops = (Snoopee*) malloc (1); /* seed for realloc */
386 dp->nsprops = 0;
387 dp->nsent = 0;
388
389 /* first message primes driver to report its properties -- dev known
390 * if restarting
391 */
392 mp = newMsg();
393 pushFQ (dp->msgq, mp);
394 if (dp->dev[0])
395 sprintf (buf, "<getProperties device='%s' version='%g'/>\n",
396 dp->dev, INDIV);
397 else
398 sprintf (buf, "<getProperties version='%g'/>\n", INDIV);
399 setMsgStr (mp, buf);
400 mp->count++;
401
402 if (verbose > 0)
403 fprintf (stderr, "%s: Driver %s: pid=%d rfd=%d wfd=%d efd=%d\n",
404 indi_tstamp(NULL), dp->name, dp->pid, dp->rfd, dp->wfd, dp->efd);
405}
406
407/* start the given remote INDI driver connection.
408 * exit if trouble.
409 */
410static void
411startRemoteDvr (DvrInfo *dp)
412{
413 Msg *mp;
414 char dev[1024];
415 char host[1024];
416 char buf[1024];
417 int indi_port, sockfd;
418
419 /* extract host and port */
420 indi_port = INDIPORT;
421 if (sscanf (dp->name, "%[^@]@%[^:]:%d", dev, host, &indi_port) < 2) {
422 fprintf (stderr, "Bad remote device syntax: %s\n", dp->name);
423 Bye();
424 }
425
426 /* connect */
427 sockfd = openINDIServer (host, indi_port);
428
429 /* record flag pid, io channels, init lp and snoop list */
430 dp->pid = REMOTEDVR;
431 dp->rfd = sockfd;
432 dp->wfd = sockfd;
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
439 /* N.B. storing name now is key to limiting outbound traffic to this
440 * dev.
441 */
442 strncpy (dp->dev, dev, MAXINDIDEVICE-1);
443 dp->dev[MAXINDIDEVICE-1] = '\0';
444
445 /* Sending getProperties with device lets remote server limit its
446 * outbound (and our inbound) traffic on this socket to this device.
447 */
448 mp = newMsg();
449 pushFQ (dp->msgq, mp);
450 sprintf (buf, "<getProperties device='%s' version='%g'/>\n",
451 dp->dev, INDIV);
452 setMsgStr (mp, buf);
453 mp->count++;
454
455 if (verbose > 0)
456 fprintf (stderr, "%s: Driver %s: socket=%d\n", indi_tstamp(NULL),
457 dp->name, sockfd);
458}
459
460/* open a connection to the given host and port or die.
461 * return socket fd.
462 */
463static int
464openINDIServer (char host[], int indi_port)
465{
466 struct sockaddr_in serv_addr;
467 struct hostent *hp;
468 int sockfd;
469
470 /* lookup host address */
471 hp = gethostbyname (host);
472 if (!hp) {
473 fprintf (stderr, "gethostbyname(%s): %s\n", host, strerror(errno));
474 Bye();
475 }
476
477 /* create a socket to the INDI server */
478 (void) memset ((char *)&serv_addr, 0, sizeof(serv_addr));
479 serv_addr.sin_family = AF_INET;
480 serv_addr.sin_addr.s_addr =
481 ((struct in_addr *)(hp->h_addr_list[0]))->s_addr;
482 serv_addr.sin_port = htons(indi_port);
483 if ((sockfd = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
484 fprintf (stderr, "socket(%s,%d): %s\n", host, indi_port,strerror(errno));
485 Bye();
486 }
487
488 /* connect */
489 if (connect (sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr))<0){
490 fprintf (stderr, "connect(%s,%d): %s\n", host,indi_port,strerror(errno));
491 Bye();
492 }
493
494 /* ok */
495 return (sockfd);
496}
497
498/* create the public INDI Driver endpoint lsocket on port.
499 * return server socket else exit.
500 */
501static void
502indiListen ()
503{
504 struct sockaddr_in serv_socket;
505 int sfd;
506 int reuse = 1;
507
508 /* make socket endpoint */
509 if ((sfd = socket (AF_INET, SOCK_STREAM, 0)) < 0) {
510 fprintf (stderr, "%s: socket: %s\n", indi_tstamp(NULL), strerror(errno));
511 Bye();
512 }
513
514 /* bind to given port for any IP address */
515 memset (&serv_socket, 0, sizeof(serv_socket));
516 serv_socket.sin_family = AF_INET;
517 #ifdef SSH_TUNNEL
518 serv_socket.sin_addr.s_addr = htonl (INADDR_LOOPBACK);
519 #else
520 serv_socket.sin_addr.s_addr = htonl (INADDR_ANY);
521 #endif
522 serv_socket.sin_port = htons ((unsigned short)port);
523 if (setsockopt(sfd,SOL_SOCKET,SO_REUSEADDR,&reuse,sizeof(reuse)) < 0){
524 fprintf (stderr, "%s: setsockopt: %s\n", indi_tstamp(NULL),
525 strerror(errno));
526 Bye();
527 }
528 if (bind(sfd,(struct sockaddr*)&serv_socket,sizeof(serv_socket)) < 0){
529 fprintf (stderr, "%s: bind: %s\n", indi_tstamp(NULL), strerror(errno));
530 Bye();
531 }
532
533 /* willing to accept connections with a backlog of 5 pending */
534 if (listen (sfd, 5) < 0) {
535 fprintf (stderr, "%s: listen: %s\n", indi_tstamp(NULL), strerror(errno));
536 Bye();
537 }
538
539 /* ok */
540 lsocket = sfd;
541 if (verbose > 0)
542 fprintf (stderr, "%s: listening to port %d on fd %d\n",
543 indi_tstamp(NULL), port, sfd);
544}
545
546/* service traffic from clients and drivers */
547static void
548indiRun(void)
549{
550 fd_set rs, ws;
551 int maxfd;
552 int i, s;
553
554 /* init with no writers or readers */
555 FD_ZERO(&ws);
556 FD_ZERO(&rs);
557
558 /* always listen for new clients */
559 FD_SET(lsocket, &rs);
560 maxfd = lsocket;
561
562 /* add all client readers and client writers with work to send */
563 for (i = 0; i < nclinfo; i++) {
564 ClInfo *cp = &clinfo[i];
565 if (cp->active) {
566 FD_SET(cp->s, &rs);
567 if (nFQ(cp->msgq) > 0)
568 FD_SET(cp->s, &ws);
569 if (cp->s > maxfd)
570 maxfd = cp->s;
571 }
572 }
573
574 /* add all driver readers and driver writers with work to send */
575 for (i = 0; i < ndvrinfo; i++) {
576 DvrInfo *dp = &dvrinfo[i];
577 FD_SET(dp->rfd, &rs);
578 if (dp->rfd > maxfd)
579 maxfd = dp->rfd;
580 if (dp->pid != REMOTEDVR) {
581 FD_SET(dp->efd, &rs);
582 if (dp->efd > maxfd)
583 maxfd = dp->efd;
584 }
585 if (nFQ(dp->msgq) > 0) {
586 FD_SET(dp->wfd, &ws);
587 if (dp->wfd > maxfd)
588 maxfd = dp->wfd;
589 }
590 }
591
592 /* wait for action */
593 s = select (maxfd+1, &rs, &ws, NULL, NULL);
594 if (s < 0) {
595 fprintf (stderr, "%s: select(%d): %s\n", indi_tstamp(NULL), maxfd+1,
596 strerror(errno));
597 Bye();
598 }
599
600 /* new client? */
601 if (s > 0 && FD_ISSET(lsocket, &rs)) {
602 newClient();
603 s--;
604 }
605
606 /* message to/from client? */
607 for (i = 0; s > 0 && i < nclinfo; i++) {
608 ClInfo *cp = &clinfo[i];
609 if (cp->active) {
610 if (FD_ISSET(cp->s, &rs)) {
611 if (readFromClient(cp) < 0)
612 return; /* fds effected */
613 s--;
614 }
615 if (s > 0 && FD_ISSET(cp->s, &ws)) {
616 if (sendClientMsg(cp) < 0)
617 return; /* fds effected */
618 s--;
619 }
620 }
621 }
622
623 /* message to/from driver? */
624 for (i = 0; s > 0 && i < ndvrinfo; i++) {
625 DvrInfo *dp = &dvrinfo[i];
626 if (dp->pid != REMOTEDVR && FD_ISSET(dp->efd, &rs)) {
627 if (stderrFromDriver(dp) < 0)
628 return; /* fds effected */
629 s--;
630 }
631 if (s > 0 && FD_ISSET(dp->rfd, &rs)) {
632 if (readFromDriver(dp) < 0)
633 return; /* fds effected */
634 s--;
635 }
636 if (s > 0 && FD_ISSET(dp->wfd, &ws) && nFQ(dp->msgq) > 0) {
637 if (sendDriverMsg(dp) < 0)
638 return; /* fds effected */
639 s--;
640 }
641 }
642}
643
644/* prepare for new client arriving on lsocket.
645 * exit if trouble.
646 */
647static void
648newClient()
649{
650 ClInfo *cp = NULL;
651 int s, cli;
652
653 /* assign new socket */
654 s = newClSocket ();
655
656 /* try to reuse a clinfo slot, else add one */
657 for (cli = 0; cli < nclinfo; cli++)
658 if (!(cp = &clinfo[cli])->active)
659 break;
660 if (cli == nclinfo) {
661 /* grow clinfo */
662 clinfo = (ClInfo *) realloc (clinfo, (nclinfo+1)*sizeof(ClInfo));
663 if (!clinfo) {
664 fprintf (stderr, "no memory for new client\n");
665 Bye();
666 }
667 cp = &clinfo[nclinfo++];
668 }
669
670 /* rig up new clinfo entry */
671 memset (cp, 0, sizeof(*cp));
672 cp->active = 1;
673 cp->s = s;
674 cp->lp = newLilXML();
675 cp->msgq = newFQ(1);
676 cp->props = malloc (1);
677 cp->nsent = 0;
678
679 if (verbose > 0) {
680 struct sockaddr_in addr;
681 socklen_t len = sizeof(addr);
682 getpeername(s, (struct sockaddr*)&addr, &len);
683 fprintf(stderr,"%s: Client %d: new arrival from %s:%d - welcome!\n",
684 indi_tstamp(NULL), cp->s, inet_ntoa(addr.sin_addr),
685 ntohs(addr.sin_port));
686 }
687}
688
689/* read more from the given client, send to each appropriate driver when see
690 * xml closure. also send all newXXX() to all other interested clients.
691 * return -1 if had to shut down anything, else 0.
692 */
693static int
694readFromClient (ClInfo *cp)
695{
696 char buf[MAXRBUF];
697 int shutany = 0;
698 int i, nr;
699
700 /* read client */
701 nr = read (cp->s, buf, sizeof(buf));
702 if (nr <= 0) {
703 if (nr < 0)
704 fprintf (stderr, "%s: Client %d: read: %s\n", indi_tstamp(NULL),
705 cp->s, strerror(errno));
706 else if (verbose > 0)
707 fprintf (stderr, "%s: Client %d: read EOF\n", indi_tstamp(NULL),
708 cp->s);
709 shutdownClient (cp);
710 return (-1);
711 }
712
713 /* process XML, sending when find closure */
714 for (i = 0; i < nr; i++) {
715 char err[1024];
716 XMLEle *root = readXMLEle (cp->lp, buf[i], err);
717 if (root) {
718 char *roottag = tagXMLEle(root);
719 const char *dev = findXMLAttValu (root, "device");
720 const char *name = findXMLAttValu (root, "name");
721 int isblob = !strcmp (tagXMLEle(root), "setBLOBVector");
722 Msg *mp;
723
724 if (verbose > 2) {
725 fprintf (stderr, "%s: Client %d: read ",indi_tstamp(NULL),cp->s);
726 traceMsg (root);
727 } else if (verbose > 1) {
728 fprintf (stderr, "%s: Client %d: read <%s device='%s' name='%s'>\n",
729 indi_tstamp(NULL), cp->s, tagXMLEle(root),
730 findXMLAttValu (root, "device"),
731 findXMLAttValu (root, "name"));
732 }
733
734 /* snag interested properties.
735 * N.B. don't open to alldevs if seen specific dev already, else
736 * remote client connections start returning too much.
737 */
738 if (dev[0])
739 addClDevice (cp, dev, name);
740 else if (!strcmp (roottag, "getProperties") && !cp->nprops)
741 cp->allprops = 1;
742
743 /* snag enableBLOB -- send to remote drivers too */
744 if (!strcmp (roottag, "enableBLOB"))
745 crackBLOB (pcdataXMLEle(root), &cp->blob);
746
747 /* build a new message -- set content iff anyone cares */
748 mp = newMsg();
749
750 /* send message to driver(s) responsible for dev */
751 q2RDrivers (dev, mp, root);
752
753 /* echo new* commands back to other clients */
754 if (!strncmp (roottag, "new", 3)) {
755 if (q2Clients (cp, isblob, dev, name, mp, root) < 0)
756 shutany++;
757 }
758
759 /* set message content if anyone cares else forget it */
760 if (mp->count > 0)
761 setMsgXMLEle (mp, root);
762 else
763 freeMsg (mp);
764 delXMLEle (root);
765
766 } else if (err[0]) {
767 char *ts = indi_tstamp(NULL);
768 fprintf (stderr, "%s: Client %d: XML error: %s\n", ts,
769 cp->s, err);
770 fprintf (stderr, "%s: Client %d: XML read: %.*s\n", ts,
771 cp->s, nr, buf);
772 shutdownClient (cp);
773 return (-1);
774 }
775 }
776
777 return (shutany ? -1 : 0);
778}
779
780/* read more from the given driver, send to each interested client when see
781 * xml closure. if driver dies, try restarting.
782 * return 0 if ok else -1 if had to shut down anything.
783 */
784static int
785readFromDriver (DvrInfo *dp)
786{
787 char buf[MAXRBUF];
788 int shutany = 0;
789 int i, nr;
790
791 /* read driver */
792 nr = read (dp->rfd, buf, sizeof(buf));
793 if (nr <= 0) {
794 if (nr < 0)
795 fprintf (stderr, "%s: Driver %s: stdin %s\n", indi_tstamp(NULL),
796 dp->name, strerror(errno));
797 else
798 fprintf (stderr, "%s: Driver %s: stdin EOF\n",
799 indi_tstamp(NULL), dp->name);
800 restartDvr (dp);
801 return (-1);
802 }
803
804 /* process XML, sending when find closure */
805 for (i = 0; i < nr; i++) {
806 char err[1024];
807 XMLEle *root = readXMLEle (dp->lp, buf[i], err);
808 if (root) {
809 char *roottag = tagXMLEle(root);
810 const char *dev = findXMLAttValu (root, "device");
811 const char *name = findXMLAttValu (root, "name");
812 int isblob = !strcmp (tagXMLEle(root), "setBLOBVector");
813 Msg *mp;
814
815 if (verbose > 2) {
816 fprintf(stderr, "%s: Driver %s: read ", indi_tstamp(0),dp->name);
817 traceMsg (root);
818 } else if (verbose > 1) {
819 fprintf (stderr, "%s: Driver %s: read <%s device='%s' name='%s'>\n",
820 indi_tstamp(NULL), dp->name, tagXMLEle(root),
821 findXMLAttValu (root, "device"),
822 findXMLAttValu (root, "name"));
823 }
824
825 /* that's all if driver is just registering a snoop */
826 if (!strcmp (roottag, "getProperties")) {
827 addSDevice (dp, dev, name);
828 delXMLEle (root);
829 continue;
830 }
831
832 /* that's all if driver is just registering a BLOB mode */
833 if (!strcmp (roottag, "enableBLOB")) {
834 Snoopee *sp = findSDevice (dp, dev, name);
835 if (sp)
836 crackBLOB (pcdataXMLEle (root), &sp->blob);
837 delXMLEle (root);
838 continue;
839 }
840
841 /* snag device name if not known yet */
842 if (!dp->dev[0] && dev[0]) {
843 strncpy (dp->dev, dev, MAXINDIDEVICE-1);
844 dp->dev[MAXINDIDEVICE-1] = '\0';
845 }
846
847 /* log messages if any and wanted */
848 if (ldir)
849 logDMsg (root, dev);
850
851 /* build a new message -- set content iff anyone cares */
852 mp = newMsg();
853
854 /* send to interested clients */
855 if (q2Clients (NULL, isblob, dev, name, mp, root) < 0)
856 shutany++;
857
858 /* send to snooping drivers */
859 q2SDrivers (isblob, dev, name, mp, root);
860
861 /* set message content if anyone cares else forget it */
862 if (mp->count > 0)
863 setMsgXMLEle (mp, root);
864 else
865 freeMsg (mp);
866 delXMLEle (root);
867
868 } else if (err[0]) {
869 char *ts = indi_tstamp(NULL);
870 fprintf (stderr, "%s: Driver %s: XML error: %s\n", ts,
871 dp->name, err);
872 fprintf (stderr, "%s: Driver %s: XML read: %.*s\n", ts,
873 dp->name, nr, buf);
874 restartDvr (dp);
875 return (-1);
876 }
877 }
878
879 return (shutany ? -1 : 0);
880}
881
882/* read more from the given driver stderr, add prefix and send to our stderr.
883 * return 0 if ok else -1 if had to restart.
884 */
885static int
886stderrFromDriver (DvrInfo *dp)
887{
888 static char exbuf[MAXRBUF];
889 static int nexbuf;
890 int i, nr;
891
892 /* read more */
893 nr = read (dp->efd, exbuf+nexbuf, sizeof(exbuf)-nexbuf);
894 if (nr <= 0) {
895 if (nr < 0)
896 fprintf (stderr, "%s: Driver %s: stderr %s\n", indi_tstamp(NULL),
897 dp->name, strerror(errno));
898 else
899 fprintf (stderr, "%s: Driver %s: stderr EOF\n",
900 indi_tstamp(NULL), dp->name);
901 restartDvr (dp);
902 return (-1);
903 }
904 nexbuf += nr;
905
906 /* prefix each whole line to our stderr, save extra for next time */
907 for (i = 0; i < nexbuf; i++) {
908 if (exbuf[i] == '\n') {
909 fprintf (stderr, "%s: Driver %s: %.*s\n", indi_tstamp(NULL),
910 dp->name, i, exbuf);
911 i++; /* count including nl */
912 nexbuf -= i; /* remove from nexbuf */
913 memmove (exbuf, exbuf+i, nexbuf); /* slide remaining to front */
914 i = -1; /* restart for loop scan */
915 }
916 }
917
918 return (0);
919}
920
921/* close down the given client */
922static void
923shutdownClient (ClInfo *cp)
924{
925 Msg *mp;
926
927 /* close connection */
928 shutdown (cp->s, SHUT_RDWR);
929 close (cp->s);
930
931 /* free memory */
932 delLilXML (cp->lp);
933 free (cp->props);
934
935 /* decrement and possibly free any unsent messages for this client */
936 while ((mp = (Msg*) popFQ(cp->msgq)) != NULL)
937 if (--mp->count == 0)
938 freeMsg (mp);
939 delFQ (cp->msgq);
940
941 /* ok now to recycle */
942 cp->active = 0;
943
944 if (verbose > 0)
945 fprintf (stderr, "%s: Client %d: shut down complete - bye!\n",
946 indi_tstamp(NULL), cp->s);
947}
948
949/* close down the given driver and restart */
950static void
951restartDvr (DvrInfo *dp)
952{
953 Msg *mp;
954
955 /* make sure it's dead, reclaim resources */
956 if (dp->pid == REMOTEDVR) {
957 /* socket connection */
958 shutdown (dp->wfd, SHUT_RDWR);
959 close (dp->wfd); /* same as rfd */
960 } else {
961 /* local pipe connection */
962 kill (dp->pid, SIGKILL); /* we've insured there are no zombies */
963 close (dp->wfd);
964 close (dp->rfd);
965 close (dp->efd);
966 }
967
968 /* free memory */
969 free (dp->sprops);
970 delLilXML (dp->lp);
971
972 /* decrement and possibly free any unsent messages for this client */
973 while ((mp = (Msg*) popFQ(dp->msgq)) != NULL)
974 if (--mp->count == 0)
975 freeMsg (mp);
976 delFQ (dp->msgq);
977
978 fprintf (stderr, "%s: Driver %s: restart #%d\n", indi_tstamp(NULL),
979 dp->name, ++dp->restarts);
980 startDvr (dp);
981}
982
983/* put Msg mp on queue of each driver responsible for dev, or all drivers
984 * if dev not specified.
985 */
986static void
987q2RDrivers (const char *dev, Msg *mp, XMLEle *root)
988{
989 int sawremote = 0;
990 DvrInfo *dp;
991
992 /* queue message to each interested driver.
993 * N.B. don't send generic getProps to more than one remote driver,
994 * otherwise they all fan out and we get multiple responses back.
995 */
996 for (dp = dvrinfo; dp < &dvrinfo[ndvrinfo]; dp++) {
997 int isremote = (dp->pid == REMOTEDVR);
998 if (dev[0] && dp->dev[0] && strcmp (dev, dp->dev))
999 continue; /* driver known to not support this dev */
1000 if (!dev[0] && isremote && sawremote)
1001 continue; /* already sent generic to another remote */
1002 if (isremote)
1003 sawremote = 1;
1004
1005 /* ok: queue message to this driver */
1006 mp->count++;
1007 pushFQ (dp->msgq, mp);
1008 if (verbose > 1)
1009 fprintf (stderr, "%s: Driver %s: queuing responsible for <%s device='%s' name='%s'>\n",
1010 indi_tstamp(NULL), dp->name, tagXMLEle(root),
1011 findXMLAttValu (root, "device"),
1012 findXMLAttValu (root, "name"));
1013 }
1014}
1015
1016/* put Msg mp on queue of each driver snooping dev/name.
1017 * if BLOB always honor current mode.
1018 */
1019static void
1020q2SDrivers (int isblob, const char *dev, const char *name, Msg *mp, XMLEle *root)
1021{
1022 DvrInfo *dp;
1023
1024 for (dp = dvrinfo; dp < &dvrinfo[ndvrinfo]; dp++) {
1025 Snoopee *sp = findSDevice (dp, dev, name);
1026
1027 /* nothing for dp if not snooping for dev/name or wrong BLOB mode */
1028 if (!sp)
1029 continue;
1030 if ((isblob && sp->blob==B_NEVER) || (!isblob && sp->blob==B_ONLY))
1031 continue;
1032
1033 /* ok: queue message to this device */
1034 mp->count++;
1035 pushFQ (dp->msgq, mp);
1036 if (verbose > 1) {
1037 fprintf (stderr, "%s: Driver %s: queuing snooped <%s device='%s' name='%s'>\n",
1038 indi_tstamp(NULL), dp->name, tagXMLEle(root),
1039 findXMLAttValu (root, "device"),
1040 findXMLAttValu (root, "name"));
1041 }
1042 }
1043}
1044
1045/* add dev/name to dp's snooping list.
1046 * init with blob mode set to B_NEVER.
1047 */
1048static void
1049addSDevice (DvrInfo *dp, const char *dev, const char *name)
1050{
1051 Snoopee *sp;
1052 char *ip;
1053
1054 /* no dups */
1055 sp = findSDevice (dp, dev, name);
1056 if (sp)
1057 return;
1058
1059 /* add dev to sdevs list */
1060 dp->sprops = (Snoopee*) realloc (dp->sprops,
1061 (dp->nsprops+1)*sizeof(Snoopee));
1062 sp = &dp->sprops[dp->nsprops++];
1063
1064 ip = sp->prop.dev;
1065 strncpy (ip, dev, MAXINDIDEVICE-1);
1066 ip[MAXINDIDEVICE-1] = '\0';
1067
1068 ip = sp->prop.name;
1069 strncpy (ip, name, MAXINDINAME-1);
1070 ip[MAXINDINAME-1] = '\0';
1071
1072 sp->blob = B_NEVER;
1073
1074 if (verbose)
1075 fprintf (stderr, "%s: Driver %s: snooping on %s.%s\n", indi_tstamp(NULL),
1076 dp->name, dev, name);
1077}
1078
1079/* return Snoopee if dp is snooping dev/name, else NULL.
1080 */
1081static Snoopee *
1082findSDevice (DvrInfo *dp, const char *dev, const char *name)
1083{
1084 int i;
1085
1086 for (i = 0; i < dp->nsprops; i++) {
1087 Snoopee *sp = &dp->sprops[i];
1088 Property *pp = &sp->prop;
1089 if (!strcmp (pp->dev, dev) &&
1090 (!pp->name[0] || !strcmp(pp->name, name)))
1091 return (sp);
1092 }
1093
1094 return (NULL);
1095}
1096
1097/* put Msg mp on queue of each client interested in dev/name, except notme.
1098 * if BLOB always honor current mode.
1099 * return -1 if had to shut down any clients, else 0.
1100 */
1101static int
1102q2Clients (ClInfo *notme, int isblob, const char *dev, const char *name, Msg *mp, XMLEle *root)
1103{
1104 int shutany = 0;
1105 ClInfo *cp;
1106 int ql;
1107
1108 /* queue message to each interested client */
1109 for (cp = clinfo; cp < &clinfo[nclinfo]; cp++) {
1110 /* cp in use? notme? want this dev/name? blob? */
1111 if (!cp->active || cp == notme)
1112 continue;
1113 if (findClDevice (cp, dev, name) < 0)
1114 continue;
1115 if ((isblob && cp->blob==B_NEVER) || (!isblob && cp->blob==B_ONLY))
1116 continue;
1117
1118 /* shut down this client if its q is already too large */
1119 ql = msgQSize(cp->msgq);
1120 if (ql > maxqsiz) {
1121 if (verbose)
1122 fprintf (stderr, "%s: Client %d: %d bytes behind, shutting down\n",
1123 indi_tstamp(NULL), cp->s, ql);
1124 shutdownClient (cp);
1125 shutany++;
1126 continue;
1127 }
1128
1129 /* ok: queue message to this client */
1130 mp->count++;
1131 pushFQ (cp->msgq, mp);
1132 if (verbose > 1)
1133 fprintf (stderr, "%s: Client %d: queuing <%s device='%s' name='%s'>\n",
1134 indi_tstamp(NULL), cp->s, tagXMLEle(root),
1135 findXMLAttValu (root, "device"),
1136 findXMLAttValu (root, "name"));
1137 }
1138
1139 return (shutany ? -1 : 0);
1140}
1141
1142/* return size of all Msqs on the given q */
1143static int
1144msgQSize (FQ *q)
1145{
1146 int i, l = 0;
1147
1148 for (i = 0; i < nFQ(q); i++) {
1149 Msg *mp = (Msg *) peekiFQ(q,i);
1150 l += mp->cl;
1151 }
1152
1153 return (l);
1154}
1155
1156/* print root as content in Msg mp.
1157 */
1158static void
1159setMsgXMLEle (Msg *mp, XMLEle *root)
1160{
1161 /* want cl to only count content, but need room for final \0 */
1162 mp->cl = sprlXMLEle (root, 0);
1163 if (mp->cl < sizeof(mp->buf))
1164 mp->cp = mp->buf;
1165 else
1166 mp->cp = malloc (mp->cl+1);
1167 sprXMLEle (mp->cp, root, 0);
1168}
1169
1170/* save str as content in Msg mp.
1171 */
1172static void
1173setMsgStr (Msg *mp, char *str)
1174{
1175 /* want cl to only count content, but need room for final \0 */
1176 mp->cl = strlen (str);
1177 if (mp->cl < sizeof(mp->buf))
1178 mp->cp = mp->buf;
1179 else
1180 mp->cp = malloc (mp->cl+1);
1181 strcpy (mp->cp, str);
1182}
1183
1184/* return pointer to one new nulled Msg
1185 */
1186static Msg *
1187newMsg (void)
1188{
1189 return ((Msg *) calloc (1, sizeof(Msg)));
1190}
1191
1192/* free Msg mp and everything it contains */
1193static void
1194freeMsg (Msg *mp)
1195{
1196 if (mp->cp && mp->cp != mp->buf)
1197 free (mp->cp);
1198 free (mp);
1199}
1200
1201/* write the next chunk of the current message in the queue to the given
1202 * client. pop message from queue when complete and free the message if we are
1203 * the last one to use it. shut down this client if trouble.
1204 * N.B. we assume we will never be called with cp->msgq empty.
1205 * return 0 if ok else -1 if had to shut down.
1206 */
1207static int
1208sendClientMsg (ClInfo *cp)
1209{
1210 int nsend, nw;
1211 Msg *mp;
1212
1213 /* get current message */
1214 mp = (Msg *) peekFQ (cp->msgq);
1215
1216 /* send next chunk, never more than MAXWSIZ to reduce blocking */
1217 nsend = mp->cl - cp->nsent;
1218 if (nsend > MAXWSIZ)
1219 nsend = MAXWSIZ;
1220 nw = write (cp->s, &mp->cp[cp->nsent], nsend);
1221
1222 /* shut down if trouble */
1223 if (nw <= 0) {
1224 if (nw == 0)
1225 fprintf (stderr, "%s: Client %d: write returned 0\n",
1226 indi_tstamp(NULL), cp->s);
1227 else
1228 fprintf (stderr, "%s: Client %d: write: %s\n", indi_tstamp(NULL),
1229 cp->s, strerror(errno));
1230 shutdownClient (cp);
1231 return (-1);
1232 }
1233
1234 /* trace */
1235 if (verbose > 2) {
1236 fprintf(stderr, "%s: Client %d: sending msg copy %d nq %d:\n%.*s\n",
1237 indi_tstamp(NULL), cp->s, mp->count, nFQ(cp->msgq),
1238 nw, &mp->cp[cp->nsent]);
1239 } else if (verbose > 1) {
1240 fprintf(stderr, "%s: Client %d: sending %.50s\n", indi_tstamp(NULL),
1241 cp->s, &mp->cp[cp->nsent]);
1242 }
1243
1244 /* update amount sent. when complete: free message if we are the last
1245 * to use it and pop from our queue.
1246 */
1247 cp->nsent += nw;
1248 if (cp->nsent == mp->cl) {
1249 if (--mp->count == 0)
1250 freeMsg (mp);
1251 popFQ (cp->msgq);
1252 cp->nsent = 0;
1253 }
1254
1255 return (0);
1256}
1257
1258/* write the next chunk of the current message in the queue to the given
1259 * driver. pop message from queue when complete and free the message if we are
1260 * the last one to use it. restart this driver if touble.
1261 * N.B. we assume we will never be called with dp->msgq empty.
1262 * return 0 if ok else -1 if had to shut down.
1263 */
1264static int
1265sendDriverMsg (DvrInfo *dp)
1266{
1267 int nsend, nw;
1268 Msg *mp;
1269
1270 /* get current message */
1271 mp = (Msg *) peekFQ (dp->msgq);
1272
1273 /* send next chunk, never more than MAXWSIZ to reduce blocking */
1274 nsend = mp->cl - dp->nsent;
1275 if (nsend > MAXWSIZ)
1276 nsend = MAXWSIZ;
1277 nw = write (dp->wfd, &mp->cp[dp->nsent], nsend);
1278
1279 /* restart if trouble */
1280 if (nw <= 0) {
1281 if (nw == 0)
1282 fprintf (stderr, "%s: Driver %s: write returned 0\n",
1283 indi_tstamp(NULL), dp->name);
1284 else
1285 fprintf (stderr, "%s: Driver %s: write: %s\n", indi_tstamp(NULL),
1286 dp->name, strerror(errno));
1287 restartDvr (dp);
1288 return (-1);
1289 }
1290
1291 /* trace */
1292 if (verbose > 2) {
1293 fprintf(stderr, "%s: Driver %s: sending msg copy %d nq %d:\n%.*s\n",
1294 indi_tstamp(NULL), dp->name, mp->count, nFQ(dp->msgq),
1295 nw, &mp->cp[dp->nsent]);
1296 } else if (verbose > 1) {
1297 fprintf(stderr, "%s: Driver %s: sending %.50s\n", indi_tstamp(NULL),
1298 dp->name, &mp->cp[dp->nsent]);
1299 }
1300
1301 /* update amount sent. when complete: free message if we are the last
1302 * to use it and pop from our queue.
1303 */
1304 dp->nsent += nw;
1305 if (dp->nsent == mp->cl) {
1306 if (--mp->count == 0)
1307 freeMsg (mp);
1308 popFQ (dp->msgq);
1309 dp->nsent = 0;
1310 }
1311
1312 return (0);
1313}
1314
1315/* return 0 if cp may be interested in dev/name else -1
1316 */
1317static int
1318findClDevice (ClInfo *cp, const char *dev, const char *name)
1319{
1320 int i;
1321
1322 if (cp->allprops || !dev[0])
1323 return (0);
1324 for (i = 0; i < cp->nprops; i++) {
1325 Property *pp = &cp->props[i];
1326 if (!strcmp (pp->dev, dev) &&
1327 (!pp->name[0] || !strcmp(pp->name, name)))
1328 return (0);
1329 }
1330 return (-1);
1331}
1332
1333/* add the given device and property to the devs[] list of client if new.
1334 */
1335static void
1336addClDevice (ClInfo *cp, const char *dev, const char *name)
1337{
1338 Property *pp;
1339 char *ip;
1340
1341 /* no dups */
1342 if (!findClDevice (cp, dev, name))
1343 return;
1344
1345 /* add */
1346 cp->props = (Property *) realloc (cp->props,
1347 (cp->nprops+1)*sizeof(Property));
1348 pp = &cp->props[cp->nprops++];
1349
1350 ip = pp->dev;
1351 strncpy (ip, dev, MAXINDIDEVICE-1);
1352 ip[MAXINDIDEVICE-1] = '\0';
1353
1354 ip = pp->name;
1355 strncpy (ip, name, MAXINDINAME-1);
1356 ip[MAXINDINAME-1] = '\0';
1357}
1358
1359
1360/* block to accept a new client arriving on lsocket.
1361 * return private nonblocking socket or exit.
1362 */
1363static int
1364newClSocket ()
1365{
1366 struct sockaddr_in cli_socket;
1367 socklen_t cli_len;
1368 int cli_fd;
1369
1370 /* get a private connection to new client */
1371 cli_len = sizeof(cli_socket);
1372 cli_fd = accept (lsocket, (struct sockaddr *)&cli_socket, &cli_len);
1373 if(cli_fd < 0) {
1374 fprintf (stderr, "accept: %s\n", strerror(errno));
1375 Bye();
1376 }
1377
1378 /* ok */
1379 return (cli_fd);
1380}
1381
1382/* convert the string value of enableBLOB to our B_ state value.
1383 * no change if unrecognized
1384 */
1385static void
1386crackBLOB (char *enableBLOB, BLOBHandling *bp)
1387{
1388 if (!strcmp (enableBLOB, "Also"))
1389 *bp = B_ALSO;
1390 else if (!strcmp (enableBLOB, "Only"))
1391 *bp = B_ONLY;
1392 else if (!strcmp (enableBLOB, "Never"))
1393 *bp = B_NEVER;
1394}
1395
1396/* print key attributes and values of the given xml to stderr.
1397 */
1398static void
1399traceMsg (XMLEle *root)
1400{
1401 static const char *prtags[] = {
1402 "defNumber", "oneNumber",
1403 "defText", "oneText",
1404 "defSwitch", "oneSwitch",
1405 "defLight", "oneLight",
1406 };
1407 XMLEle *e;
1408 const char *msg, *perm, *pcd;
1409 unsigned int i;
1410
1411 /* print tag header */
1412 fprintf (stderr, "%s %s %s %s", tagXMLEle(root),
1413 findXMLAttValu(root,"device"),
1414 findXMLAttValu(root,"name"),
1415 findXMLAttValu(root,"state"));
1416 pcd = pcdataXMLEle (root);
1417 if (pcd[0])
1418 fprintf (stderr, " %s", pcd);
1419 perm = findXMLAttValu(root,"perm");
1420 if (perm[0])
1421 fprintf (stderr, " %s", perm);
1422 msg = findXMLAttValu(root,"message");
1423 if (msg[0])
1424 fprintf (stderr, " '%s'", msg);
1425
1426 /* print each array value */
1427 for (e = nextXMLEle(root,1); e; e = nextXMLEle(root,0))
1428 for (i = 0; i < sizeof(prtags)/sizeof(prtags[0]); i++)
1429 if (strcmp (prtags[i], tagXMLEle(e)) == 0)
1430 fprintf (stderr, "\n %10s='%s'", findXMLAttValu(e,"name"),
1431 pcdataXMLEle (e));
1432
1433 fprintf (stderr, "\n");
1434}
1435
1436/* fill s with current UT string.
1437 * if no s, use a static buffer
1438 * return s or buffer.
1439 * N.B. if use our buffer, be sure to use before calling again
1440 */
1441static char *
1442indi_tstamp (char *s)
1443{
1444 static char sbuf[64];
1445 struct tm *tp;
1446 time_t t;
1447
1448 time (&t);
1449 tp = gmtime (&t);
1450 if (!s)
1451 s = sbuf;
1452 strftime (s, sizeof(sbuf), "%Y-%m-%dT%H:%M:%S", tp);
1453 return (s);
1454}
1455
1456/* log message in root known to be from device dev to ldir, if any.
1457 */
1458static void
1459logDMsg (XMLEle *root, const char *dev)
1460{
1461 char stamp[64];
1462 char logfn[1024];
1463 const char *ts, *ms;
1464 FILE *fp;
1465
1466 /* get message, if any */
1467 ms = findXMLAttValu (root, "message");
1468 if (!ms[0])
1469 return;
1470
1471 /* get timestamp now if not provided */
1472 ts = findXMLAttValu (root, "timestamp");
1473 if (!ts[0])
1474 {
1475 indi_tstamp (stamp);
1476 ts = stamp;
1477 }
1478
1479 /* append to log file, name is date portion of time stamp */
1480 sprintf (logfn, "%s/%.10s.islog", ldir, ts);
1481 fp = fopen (logfn, "a");
1482 if (!fp)
1483 return; /* oh well */
1484 fprintf (fp, "%s: %s: %s\n", ts, dev, ms);
1485 fclose (fp);
1486}
1487
1488/* log when then exit */
1489static void
1490Bye()
1491{
1492 fprintf (stderr, "%s: good bye\n", indi_tstamp(NULL));
1493 exit(1);
1494}
1495
Note: See TracBrowser for help on using the repository browser.