1 | /* connect to an INDI server and show all desired device.property.element |
---|
2 | * with possible wild card * in any category. |
---|
3 | * All types but BLOBs are handled from their defXXX messages. Receipt of a |
---|
4 | * defBLOB sends enableBLOB then uses setBLOBVector for the value. BLOBs |
---|
5 | * are stored in a file dev.nam.elem.format. only .z compression is handled. |
---|
6 | * exit status: 0 at least some found, 1 some not found, 2 real trouble. |
---|
7 | */ |
---|
8 | |
---|
9 | #include <stdio.h> |
---|
10 | #include <stdlib.h> |
---|
11 | #include <math.h> |
---|
12 | #include <string.h> |
---|
13 | #include <errno.h> |
---|
14 | #include <signal.h> |
---|
15 | #include <time.h> |
---|
16 | #include <unistd.h> |
---|
17 | #include <sys/types.h> |
---|
18 | #include <sys/socket.h> |
---|
19 | #include <netinet/in.h> |
---|
20 | #include <netdb.h> |
---|
21 | |
---|
22 | #include "indiapi.h" |
---|
23 | #include "lilxml.h" |
---|
24 | #include "base64.h" |
---|
25 | #include "zlib.h" |
---|
26 | |
---|
27 | |
---|
28 | /* table of INDI definition elements, plus setBLOB. |
---|
29 | * we also look for set* if -m |
---|
30 | */ |
---|
31 | typedef struct { |
---|
32 | char *vec; /* vector name */ |
---|
33 | char *one; /* one element name */ |
---|
34 | } INDIDef; |
---|
35 | static INDIDef defs[] = { |
---|
36 | {"defTextVector", "defText"}, |
---|
37 | {"defNumberVector", "defNumber"}, |
---|
38 | {"defSwitchVector", "defSwitch"}, |
---|
39 | {"defLightVector", "defLight"}, |
---|
40 | {"defBLOBVector", "defBLOB"}, |
---|
41 | {"setBLOBVector", "oneBLOB"}, |
---|
42 | {"setTextVector", "oneText"}, |
---|
43 | {"setNumberVector", "oneNumber"}, |
---|
44 | {"setSwitchVector", "oneSwitch"}, |
---|
45 | {"setLightVector", "oneLight"}, |
---|
46 | }; |
---|
47 | static int ndefs = 6; /* or 10 if -m */ |
---|
48 | |
---|
49 | /* table of keyword to use in query vs name of INDI defXXX attribute */ |
---|
50 | typedef struct { |
---|
51 | char *keyword; |
---|
52 | char *indiattr; |
---|
53 | } INDIkwattr; |
---|
54 | static INDIkwattr kwattr[] = { |
---|
55 | {"_LABEL", "label"}, |
---|
56 | {"_GROUP", "group"}, |
---|
57 | {"_STATE", "state"}, |
---|
58 | {"_PERM", "perm"}, |
---|
59 | {"_TO", "timeout"}, |
---|
60 | {"_TS", "timestamp"}, |
---|
61 | }; |
---|
62 | #define NKWA (sizeof(kwattr)/sizeof(kwattr[0])) |
---|
63 | |
---|
64 | typedef struct { |
---|
65 | char *d; /* device to seek */ |
---|
66 | char *p; /* property to seek */ |
---|
67 | char *e; /* element to seek */ |
---|
68 | int wc : 1; /* whether pattern uses wild cards */ |
---|
69 | int ok : 1; /* something matched this query */ |
---|
70 | } SearchDef; |
---|
71 | static SearchDef *srchs; /* properties to look for */ |
---|
72 | static int nsrchs; |
---|
73 | |
---|
74 | static void usage (void); |
---|
75 | static void crackDPE (char *spec); |
---|
76 | static void addSearchDef (char *dev, char *prop, char *ele); |
---|
77 | static void openINDIServer(void); |
---|
78 | static void getprops(void); |
---|
79 | static void listenINDI(void); |
---|
80 | static int finished (void); |
---|
81 | static void onAlarm (int dummy); |
---|
82 | static int readServerChar(void); |
---|
83 | static void findDPE (XMLEle *root); |
---|
84 | static void findEle (XMLEle *root, char *dev, char *nam, char *defone, |
---|
85 | SearchDef *sp); |
---|
86 | static void enableBLOBs(char *dev, char *nam); |
---|
87 | static void oneBLOB (XMLEle *root, char *dev, char *nam, char *enam, char *p, |
---|
88 | int plen); |
---|
89 | |
---|
90 | static char *me; /* our name for usage() message */ |
---|
91 | static char host_def[] = "localhost"; /* default host name */ |
---|
92 | static char *host = host_def; /* working host name */ |
---|
93 | #define INDIPORT 7624 /* default port */ |
---|
94 | static int port = INDIPORT; /* working port number */ |
---|
95 | #define TIMEOUT 2 /* default timeout, secs */ |
---|
96 | static int timeout = TIMEOUT; /* working timeout, secs */ |
---|
97 | static int verbose; /* report extra info */ |
---|
98 | static LilXML *lillp; /* XML parser context */ |
---|
99 | #define WILDCARD '*' /* show all in this category */ |
---|
100 | static int onematch; /* only one possible match */ |
---|
101 | static int justvalue; /* if just one match show only value */ |
---|
102 | static int monitor; /* keep watching even after seen def */ |
---|
103 | static int directfd = -1; /* direct filedes to server, if >= 0 */ |
---|
104 | static FILE *svrwfp; /* FILE * to talk to server */ |
---|
105 | static FILE *svrrfp; /* FILE * to read from server */ |
---|
106 | static int wflag; /* show wo properties too */ |
---|
107 | |
---|
108 | int |
---|
109 | main (int ac, char *av[]) |
---|
110 | { |
---|
111 | /* save our name */ |
---|
112 | me = av[0]; |
---|
113 | |
---|
114 | /* crack args */ |
---|
115 | while (--ac && **++av == '-') { |
---|
116 | char *s = *av; |
---|
117 | while (*++s) { |
---|
118 | switch (*s) { |
---|
119 | case '1': /* just value */ |
---|
120 | justvalue++; |
---|
121 | break; |
---|
122 | case 'd': |
---|
123 | if (ac < 2) { |
---|
124 | fprintf (stderr, "-d requires open fileno\n"); |
---|
125 | usage(); |
---|
126 | } |
---|
127 | directfd = atoi(*++av); |
---|
128 | ac--; |
---|
129 | break; |
---|
130 | case 'h': |
---|
131 | if (directfd >= 0) { |
---|
132 | fprintf (stderr, "Can not combine -d and -h\n"); |
---|
133 | usage(); |
---|
134 | } |
---|
135 | if (ac < 2) { |
---|
136 | fprintf (stderr, "-h requires host name\n"); |
---|
137 | usage(); |
---|
138 | } |
---|
139 | host = *++av; |
---|
140 | ac--; |
---|
141 | break; |
---|
142 | case 'm': |
---|
143 | monitor++; |
---|
144 | ndefs = 10; /* include set*Vectors too */ |
---|
145 | break; |
---|
146 | case 'p': |
---|
147 | if (directfd >= 0) { |
---|
148 | fprintf (stderr, "Can not combine -d and -p\n"); |
---|
149 | usage(); |
---|
150 | } |
---|
151 | if (ac < 2) { |
---|
152 | fprintf (stderr, "-p requires tcp port number\n"); |
---|
153 | usage(); |
---|
154 | } |
---|
155 | port = atoi(*++av); |
---|
156 | ac--; |
---|
157 | break; |
---|
158 | case 't': |
---|
159 | if (ac < 2) { |
---|
160 | fprintf (stderr, "-t requires timeout\n"); |
---|
161 | usage(); |
---|
162 | } |
---|
163 | timeout = atoi(*++av); |
---|
164 | ac--; |
---|
165 | break; |
---|
166 | case 'v': /* verbose */ |
---|
167 | verbose++; |
---|
168 | break; |
---|
169 | case 'w': |
---|
170 | wflag++; |
---|
171 | break; |
---|
172 | default: |
---|
173 | fprintf (stderr, "Unknown flag: %c\n", *s); |
---|
174 | usage(); |
---|
175 | } |
---|
176 | } |
---|
177 | } |
---|
178 | |
---|
179 | /* now ac args starting with av[0] */ |
---|
180 | if (ac == 0) |
---|
181 | av[ac++] = "*.*.*"; /* default is get everything */ |
---|
182 | |
---|
183 | /* crack each d.p.e */ |
---|
184 | while (ac--) |
---|
185 | crackDPE (*av++); |
---|
186 | onematch = nsrchs == 1 && !srchs[0].wc; |
---|
187 | |
---|
188 | /* open connection */ |
---|
189 | if (directfd >= 0) { |
---|
190 | svrwfp = fdopen (directfd, "w"); |
---|
191 | svrrfp = fdopen (directfd, "r"); |
---|
192 | setbuf (svrrfp, NULL); /* don't absorb next guy's stuff */ |
---|
193 | if (!svrwfp || !svrrfp) { |
---|
194 | fprintf (stderr, "Direct fd %d: %s\n",directfd,strerror(errno)); |
---|
195 | exit(1); |
---|
196 | } |
---|
197 | if (verbose) |
---|
198 | fprintf (stderr, "Using direct fd %d\n", directfd); |
---|
199 | } else { |
---|
200 | openINDIServer(); |
---|
201 | if (verbose) |
---|
202 | fprintf (stderr, "Connected to %s on port %d\n", host, port); |
---|
203 | } |
---|
204 | |
---|
205 | /* build a parser context for cracking XML responses */ |
---|
206 | lillp = newLilXML(); |
---|
207 | |
---|
208 | /* issue getProperties */ |
---|
209 | getprops(); |
---|
210 | |
---|
211 | /* listen for responses, looking for d.p.e or timeout */ |
---|
212 | listenINDI(); |
---|
213 | |
---|
214 | return (0); |
---|
215 | } |
---|
216 | |
---|
217 | static void |
---|
218 | usage() |
---|
219 | { |
---|
220 | int i; |
---|
221 | |
---|
222 | fprintf(stderr, "Purpose: retrieve readable properties from an INDI server\n"); |
---|
223 | fprintf(stderr, "%s\n", "$Revision: 1.11 $"); |
---|
224 | fprintf(stderr, "Usage: %s [options] [device.property.element ...]\n",me); |
---|
225 | fprintf(stderr, " Any component may be \"*\" to match all (beware shell metacharacters).\n"); |
---|
226 | fprintf(stderr, " Reports all properties if none specified.\n"); |
---|
227 | fprintf(stderr, " BLOBs are saved in file named device.property.element.format\n"); |
---|
228 | fprintf(stderr, " In perl try: %s\n", "%props = split (/[=\\n]/, `getINDI`);"); |
---|
229 | fprintf(stderr, " Set element to one of following to return property attribute:\n"); |
---|
230 | for (i = 0; i < NKWA; i++) |
---|
231 | fprintf (stderr, " %10s to report %s\n", kwattr[i].keyword, |
---|
232 | kwattr[i].indiattr); |
---|
233 | fprintf(stderr, "Output format: output is fully qualified name=value one per line\n"); |
---|
234 | fprintf(stderr, " or just value if -1 and exactly one query without wildcards.\n"); |
---|
235 | fprintf(stderr, "Options:\n"); |
---|
236 | fprintf(stderr, " -1 : print just value if expecting exactly one response\n"); |
---|
237 | fprintf(stderr, " -d f : use file descriptor f already open to server\n"); |
---|
238 | fprintf(stderr, " -h h : alternate host, default is %s\n", host_def); |
---|
239 | fprintf(stderr, " -m : keep monitoring for more updates\n"); |
---|
240 | fprintf(stderr, " -p p : alternate port, default is %d\n", INDIPORT); |
---|
241 | fprintf(stderr, " -t t : max time to wait, default is %d secs\n",TIMEOUT); |
---|
242 | fprintf(stderr, " -v : verbose (cumulative)\n"); |
---|
243 | fprintf(stderr, " -w : show write-only properties too\n"); |
---|
244 | fprintf(stderr, "Exit status:\n"); |
---|
245 | fprintf(stderr, " 0: found at least one match for each query\n"); |
---|
246 | fprintf(stderr, " 1: at least one query returned nothing\n"); |
---|
247 | fprintf(stderr, " 2: real trouble, try repeating with -v\n"); |
---|
248 | |
---|
249 | exit (2); |
---|
250 | } |
---|
251 | |
---|
252 | /* crack spec and add to srchs[], else exit */ |
---|
253 | static void |
---|
254 | crackDPE (char *spec) |
---|
255 | { |
---|
256 | char d[1024], p[1024], e[1024]; |
---|
257 | |
---|
258 | if (verbose) |
---|
259 | fprintf (stderr, "looking for %s\n", spec); |
---|
260 | if (sscanf (spec, "%[^.].%[^.].%[^.]", d, p, e) != 3) { |
---|
261 | fprintf (stderr, "Unknown format for property spec: %s\n", spec); |
---|
262 | usage(); |
---|
263 | } |
---|
264 | |
---|
265 | addSearchDef (d, p, e); |
---|
266 | } |
---|
267 | |
---|
268 | /* grow srchs[] with the new search */ |
---|
269 | static void |
---|
270 | addSearchDef (char *dev, char *prop, char *ele) |
---|
271 | { |
---|
272 | if (!srchs) |
---|
273 | srchs = (SearchDef *) malloc (1); /* realloc seed */ |
---|
274 | srchs = (SearchDef *) realloc (srchs, (nsrchs+1)*sizeof(SearchDef)); |
---|
275 | srchs[nsrchs].d = strcpy (malloc(strlen(dev)+1), dev); |
---|
276 | srchs[nsrchs].p = strcpy (malloc(strlen(prop)+1), prop); |
---|
277 | srchs[nsrchs].e = strcpy (malloc(strlen(ele)+1), ele); |
---|
278 | srchs[nsrchs].wc = *dev==WILDCARD || *prop==WILDCARD || *ele==WILDCARD; |
---|
279 | srchs[nsrchs].ok = 0; |
---|
280 | nsrchs++; |
---|
281 | } |
---|
282 | |
---|
283 | /* open a connection to the given host and port. |
---|
284 | * set svrwfp and svrrfp or die. |
---|
285 | */ |
---|
286 | static void |
---|
287 | openINDIServer (void) |
---|
288 | { |
---|
289 | struct sockaddr_in serv_addr; |
---|
290 | struct hostent *hp; |
---|
291 | int sockfd; |
---|
292 | |
---|
293 | /* lookup host address */ |
---|
294 | hp = gethostbyname (host); |
---|
295 | if (!hp) { |
---|
296 | herror ("gethostbyname"); |
---|
297 | exit (2); |
---|
298 | } |
---|
299 | |
---|
300 | /* create a socket to the INDI server */ |
---|
301 | (void) memset ((char *)&serv_addr, 0, sizeof(serv_addr)); |
---|
302 | serv_addr.sin_family = AF_INET; |
---|
303 | serv_addr.sin_addr.s_addr = |
---|
304 | ((struct in_addr *)(hp->h_addr_list[0]))->s_addr; |
---|
305 | serv_addr.sin_port = htons(port); |
---|
306 | if ((sockfd = socket (AF_INET, SOCK_STREAM, 0)) < 0) { |
---|
307 | perror ("socket"); |
---|
308 | exit(2); |
---|
309 | } |
---|
310 | |
---|
311 | /* connect */ |
---|
312 | if (connect (sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr))<0){ |
---|
313 | perror ("connect"); |
---|
314 | exit(2); |
---|
315 | } |
---|
316 | |
---|
317 | /* prepare for line-oriented i/o with client */ |
---|
318 | svrwfp = fdopen (sockfd, "w"); |
---|
319 | svrrfp = fdopen (sockfd, "r"); |
---|
320 | } |
---|
321 | |
---|
322 | /* issue getProperties to svrwfp, possibly constrained to one device */ |
---|
323 | static void |
---|
324 | getprops() |
---|
325 | { |
---|
326 | char *onedev = NULL; |
---|
327 | int i; |
---|
328 | |
---|
329 | /* find if only need one device */ |
---|
330 | for (i = 0; i < nsrchs; i++) { |
---|
331 | char *d = srchs[i].d; |
---|
332 | if (*d == WILDCARD || (onedev && strcmp(d,onedev))) { |
---|
333 | onedev = NULL; |
---|
334 | break; |
---|
335 | } else |
---|
336 | onedev = d; |
---|
337 | } |
---|
338 | |
---|
339 | if (onedev) |
---|
340 | fprintf(svrwfp, "<getProperties version='%g' device='%s'/>\n", |
---|
341 | INDIV, onedev); |
---|
342 | else |
---|
343 | fprintf(svrwfp, "<getProperties version='%g'/>\n", INDIV); |
---|
344 | fflush (svrwfp); |
---|
345 | |
---|
346 | if (verbose) |
---|
347 | fprintf (stderr, "Queried properties from %s\n", onedev?onedev:"*"); |
---|
348 | } |
---|
349 | |
---|
350 | /* listen for INDI traffic on svrrfp. |
---|
351 | * print matching srchs[] and return when see all. |
---|
352 | * timeout and exit if any trouble. |
---|
353 | */ |
---|
354 | static void |
---|
355 | listenINDI () |
---|
356 | { |
---|
357 | char msg[1024]; |
---|
358 | |
---|
359 | /* arrange to call onAlarm() if not seeing any more defXXX */ |
---|
360 | signal (SIGALRM, onAlarm); |
---|
361 | alarm (timeout); |
---|
362 | |
---|
363 | /* read from server, exit if find all requested properties */ |
---|
364 | while (1) { |
---|
365 | XMLEle *root = readXMLEle (lillp, readServerChar(), msg); |
---|
366 | if (root) { |
---|
367 | /* found a complete XML element */ |
---|
368 | if (verbose > 1) |
---|
369 | prXMLEle (stderr, root, 0); |
---|
370 | findDPE (root); |
---|
371 | if (finished() == 0) |
---|
372 | exit (0); /* found all we want */ |
---|
373 | delXMLEle (root); /* not yet, delete and continue */ |
---|
374 | } else if (msg[0]) { |
---|
375 | fprintf (stderr, "Bad XML from %s/%d: %s\n", host, port, msg); |
---|
376 | exit(2); |
---|
377 | } |
---|
378 | } |
---|
379 | } |
---|
380 | |
---|
381 | /* return 0 if we are sure we have everything we are looking for, else -1 */ |
---|
382 | static int |
---|
383 | finished () |
---|
384 | { |
---|
385 | int i; |
---|
386 | |
---|
387 | if (monitor) |
---|
388 | return(-1); |
---|
389 | |
---|
390 | for (i = 0; i < nsrchs; i++) |
---|
391 | if (srchs[i].wc || !srchs[i].ok) |
---|
392 | return (-1); |
---|
393 | return (0); |
---|
394 | } |
---|
395 | |
---|
396 | /* called after timeout seconds either because we are matching wild cards or |
---|
397 | * there is something still not found |
---|
398 | */ |
---|
399 | static void |
---|
400 | onAlarm (int dummy) |
---|
401 | { |
---|
402 | int trouble = 0; |
---|
403 | int i; |
---|
404 | |
---|
405 | for (i = 0; i < nsrchs; i++) { |
---|
406 | if (!srchs[i].ok) { |
---|
407 | trouble = 1; |
---|
408 | fprintf (stderr, "No %s.%s.%s from %s:%d\n", srchs[i].d, |
---|
409 | srchs[i].p, srchs[i].e, host, port); |
---|
410 | } |
---|
411 | } |
---|
412 | |
---|
413 | exit (trouble ? 1 : 0); |
---|
414 | } |
---|
415 | |
---|
416 | /* read one char from svrrfp */ |
---|
417 | static int |
---|
418 | readServerChar () |
---|
419 | { |
---|
420 | int c = fgetc (svrrfp); |
---|
421 | |
---|
422 | if (c == EOF) { |
---|
423 | if (ferror(svrrfp)) |
---|
424 | perror ("read"); |
---|
425 | else |
---|
426 | fprintf (stderr,"INDI server %s/%d disconnected\n", host, port); |
---|
427 | exit (2); |
---|
428 | } |
---|
429 | |
---|
430 | if (verbose > 2) |
---|
431 | fprintf (stderr, "Read %c\n", c); |
---|
432 | |
---|
433 | return (c); |
---|
434 | } |
---|
435 | |
---|
436 | /* print value if root is any srchs[] we are looking for*/ |
---|
437 | static void |
---|
438 | findDPE (XMLEle *root) |
---|
439 | { |
---|
440 | int i, j; |
---|
441 | |
---|
442 | for (i = 0; i < nsrchs; i++) { |
---|
443 | /* for each property we are looking for */ |
---|
444 | for (j = 0; j < ndefs; j++) { |
---|
445 | /* for each possible type */ |
---|
446 | if (strcmp (tagXMLEle (root), defs[j].vec) == 0) { |
---|
447 | /* legal defXXXVector, check device */ |
---|
448 | char *dev = findXMLAttValu (root, "device"); |
---|
449 | char *idev = srchs[i].d; |
---|
450 | if (idev[0] == WILDCARD || !strcmp (dev,idev)) { |
---|
451 | /* found device, check name */ |
---|
452 | char *nam = findXMLAttValu (root, "name"); |
---|
453 | char *iprop = srchs[i].p; |
---|
454 | if (iprop[0] == WILDCARD || !strcmp (nam,iprop)) { |
---|
455 | /* found device and name, check perm */ |
---|
456 | char *perm = findXMLAttValu (root, "perm"); |
---|
457 | if (!wflag && perm[0] && !strchr (perm, 'r')) { |
---|
458 | if (verbose) |
---|
459 | fprintf (stderr, "%s.%s is write-only\n", |
---|
460 | dev, nam); |
---|
461 | } else { |
---|
462 | /* check elements or attr keywords */ |
---|
463 | if (!strcmp (defs[j].vec, "defBLOBVector")) |
---|
464 | enableBLOBs (dev,nam); |
---|
465 | else |
---|
466 | findEle(root,dev,nam,defs[j].one,&srchs[i]); |
---|
467 | if (onematch) |
---|
468 | return; /* only one can match */ |
---|
469 | if (!strncmp (defs[j].vec, "def", 3)) |
---|
470 | alarm (timeout); /* reset timer if def */ |
---|
471 | } |
---|
472 | } |
---|
473 | } |
---|
474 | } |
---|
475 | } |
---|
476 | } |
---|
477 | } |
---|
478 | |
---|
479 | /* print elements in root speced in sp (known to be of type defone). |
---|
480 | * print just value if onematch and justvalue else fully qualified name. |
---|
481 | */ |
---|
482 | static void |
---|
483 | findEle (XMLEle *root, char *dev, char *nam, char *defone, SearchDef *sp) |
---|
484 | { |
---|
485 | char *iele = sp->e; |
---|
486 | XMLEle *ep; |
---|
487 | int i; |
---|
488 | |
---|
489 | /* check for attr keyword */ |
---|
490 | for (i = 0; i < NKWA; i++) { |
---|
491 | if (strcmp (iele, kwattr[i].keyword) == 0) { |
---|
492 | /* just print the property state, not the element values */ |
---|
493 | char *s = findXMLAttValu (root, kwattr[i].indiattr); |
---|
494 | sp->ok = 1; /* progress */ |
---|
495 | if (onematch && justvalue) |
---|
496 | printf ("%s\n", s); |
---|
497 | else |
---|
498 | printf ("%s.%s.%s=%s\n", dev, nam, kwattr[i].keyword, s); |
---|
499 | return; |
---|
500 | } |
---|
501 | } |
---|
502 | |
---|
503 | /* no special attr, look for specific element name */ |
---|
504 | for (ep = nextXMLEle(root,1); ep; ep = nextXMLEle(root,0)) { |
---|
505 | if (!strcmp (tagXMLEle (ep), defone)) { |
---|
506 | /* legal defXXX, check deeper */ |
---|
507 | char *enam = findXMLAttValu (ep, "name"); |
---|
508 | if (iele[0]==WILDCARD || !strcmp(enam,iele)) { |
---|
509 | /* found it! */ |
---|
510 | char *p = pcdataXMLEle(ep); |
---|
511 | sp->ok = 1; /* progress */ |
---|
512 | if (!strcmp (defone, "oneBLOB")) |
---|
513 | oneBLOB (ep, dev, nam, enam, p, pcdatalenXMLEle(ep)); |
---|
514 | else if (onematch && justvalue) |
---|
515 | printf ("%s\n", p); |
---|
516 | else |
---|
517 | printf ("%s.%s.%s=%s\n", dev, nam, enam, p); |
---|
518 | if (onematch) |
---|
519 | return; /* only one can match*/ |
---|
520 | } |
---|
521 | } |
---|
522 | } |
---|
523 | } |
---|
524 | |
---|
525 | /* send server command to svrwfp that enables blobs for the given dev nam |
---|
526 | */ |
---|
527 | static void |
---|
528 | enableBLOBs(char *dev, char *nam) |
---|
529 | { |
---|
530 | if (verbose) |
---|
531 | fprintf (stderr, "sending enableBLOB %s.%s\n", dev, nam); |
---|
532 | fprintf (svrwfp,"<enableBLOB device='%s' name='%s'>Also</enableBLOB>\n", |
---|
533 | dev, nam); |
---|
534 | fflush (svrwfp); |
---|
535 | } |
---|
536 | |
---|
537 | /* given a oneBLOB, save |
---|
538 | */ |
---|
539 | static void |
---|
540 | oneBLOB (XMLEle *root, char *dev, char *nam, char *enam, char *p, int plen) |
---|
541 | { |
---|
542 | char *format; |
---|
543 | FILE *fp; |
---|
544 | int bloblen; |
---|
545 | unsigned char *blob; |
---|
546 | int ucs; |
---|
547 | int isz; |
---|
548 | char fn[128]; |
---|
549 | int i; |
---|
550 | |
---|
551 | /* get uncompressed size */ |
---|
552 | ucs = atoi(findXMLAttValu (root, "size")); |
---|
553 | if (verbose) |
---|
554 | fprintf (stderr, "%s.%s.%s reports uncompressed size as %d\n", |
---|
555 | dev, nam, enam, ucs); |
---|
556 | |
---|
557 | /* get format and length */ |
---|
558 | format = findXMLAttValu (root, "format"); |
---|
559 | isz = !strcmp (&format[strlen(format)-2], ".z"); |
---|
560 | |
---|
561 | /* decode blob from base64 in p */ |
---|
562 | blob = malloc (3*plen/4); |
---|
563 | bloblen = from64tobits ((char *)blob, p); |
---|
564 | if (bloblen < 0) { |
---|
565 | fprintf (stderr, "%s.%s.%s bad base64\n", dev, nam, enam); |
---|
566 | exit(2); |
---|
567 | } |
---|
568 | |
---|
569 | /* uncompress effectively in place if z */ |
---|
570 | if (isz) { |
---|
571 | uLong nuncomp = ucs; |
---|
572 | unsigned char *uncomp = malloc (ucs); |
---|
573 | int ok = uncompress (uncomp, &nuncomp, blob, bloblen); |
---|
574 | if (ok != Z_OK) { |
---|
575 | fprintf (stderr, "%s.%s.%s uncompress error %d\n", dev, nam, |
---|
576 | enam, ok); |
---|
577 | exit(2); |
---|
578 | } |
---|
579 | free (blob); |
---|
580 | blob = uncomp; |
---|
581 | bloblen = nuncomp; |
---|
582 | } |
---|
583 | |
---|
584 | /* rig up a file name from property name */ |
---|
585 | i = sprintf (fn, "%s.%s.%s%s", dev, nam, enam, format); |
---|
586 | if (isz) |
---|
587 | fn[i-2] = '\0'; /* chop off .z */ |
---|
588 | |
---|
589 | /* save */ |
---|
590 | fp = fopen (fn, "w"); |
---|
591 | if (fp) { |
---|
592 | if (verbose) |
---|
593 | fprintf (stderr, "Wrote %s\n", fn); |
---|
594 | fwrite (blob, bloblen, 1, fp); |
---|
595 | fclose (fp); |
---|
596 | } else { |
---|
597 | fprintf (stderr, "%s: %s\n", fn, strerror(errno)); |
---|
598 | } |
---|
599 | |
---|
600 | /* clean up */ |
---|
601 | free (blob); |
---|
602 | } |
---|
603 | |
---|
604 | /* For RCS Only -- Do Not Edit */ |
---|
605 | static char *rcsid[2] = {(char *)rcsid, "@(#) $RCSfile: getINDI.c,v $ $Date: 2007/10/11 20:11:23 $ $Revision: 1.11 $ $Name: $"}; |
---|