[490] | 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: $"}; |
---|