Line data Source code
1 : /*****************************************************************************
2 : *
3 : * This module has a number of additions and improvements over the original
4 : * implementation to be suitable for usage in GDAL HDF driver.
5 : *
6 : * Andrey Kiselev <dron@ak4719.spb.edu> is responsible for all the changes.
7 : ****************************************************************************/
8 :
9 : /*
10 : Copyright (C) 1996 Hughes and Applied Research Corporation
11 :
12 : Permission to use, modify, and distribute this software and its documentation
13 : for any purpose without fee is hereby granted, provided that the above
14 : copyright notice appear in all copies and that both that copyright notice and
15 : this permission notice appear in supporting documentation.
16 : */
17 :
18 : #include "cpl_port.h"
19 : #include <errno.h>
20 : #include "mfhdf.h"
21 : #include "HdfEosDef.h"
22 :
23 : /* Set maximum number of HDF-EOS files to HDF limit (MAX_FILE) */
24 : #define NEOSHDF MAX_FILE
25 : static intn EHXmaxfilecount = 0;
26 : static uint8 *EHXtypeTable = NULL;
27 : static uint8 *EHXacsTable = NULL;
28 : static int32 *EHXfidTable = NULL;
29 : static int32 *EHXsdTable = NULL;
30 :
31 : /* define a macro for the string size of the utility strings and some dimension
32 : list strings. The value in previous versions of this code may not be
33 : enough in some cases. The length now is 512 which seems to be more than
34 : enough to hold larger strings. */
35 :
36 : #define UTLSTR_MAX_SIZE 512
37 : #define UTLSTRSIZE 32000
38 :
39 : #define EHIDOFFSET 524288
40 :
41 : #define HDFEOSVERSION 2.12
42 : #define HDFEOSVERSION1 "2.12"
43 : #include "HDFEOSVersion.h"
44 :
45 : #define MAX_RETRIES 10
46 :
47 : /* Function Prototypes */
48 : static intn EHreset_maxopenfiles(intn);
49 : static intn EHget_maxopenfiles(intn *, intn *);
50 : static intn EHget_numfiles(void);
51 :
52 : /*----------------------------------------------------------------------------|
53 : | BEGIN_PROLOG |
54 : | |
55 : | FUNCTION: EHopen |
56 : | |
57 : | DESCRIPTION: Opens HDF-EOS file and returns file handle |
58 : | |
59 : | |
60 : | Return Value Type Units Description |
61 : | ============ ====== ========= ===================================== |
62 : | fid int32 HDF-EOS file ID |
63 : | |
64 : | INPUTS: |
65 : | filename char Filename |
66 : | access intn HDF access code |
67 : | |
68 : | OUTPUTS: |
69 : | None |
70 : | |
71 : | NOTES: |
72 : | |
73 : | |
74 : | Date Programmer Description |
75 : | ====== ============ ================================================= |
76 : | Jun 96 Joel Gales Original Programmer |
77 : | Jul 96 Joel Gales Add file id offset EHIDOFFSET |
78 : | Aug 96 Joel Gales Add "END" statement to structural metadata |
79 : | Sep 96 Joel Gales Reverse order of Hopen ane SDstart statements |
80 : | for RDWR and READ access |
81 : | Oct 96 Joel Gales Trap CREATE & RDWR (no write permission) |
82 : | access errors |
83 : | Apr 97 Joel Gales Fix problem with RDWR open when file previously |
84 : | open for READONLY access |
85 : | |
86 : | END_PROLOG |
87 : -----------------------------------------------------------------------------*/
88 : int32
89 8 : EHopen(const char *filename, intn access)
90 :
91 : {
92 : intn i; /* Loop index */
93 8 : intn status = 0; /* routine return status variable */
94 : intn dum; /* Dummy variable */
95 8 : intn curr_max = 0; /* maximum # of HDF files to open */
96 8 : intn sys_limit = 0; /* OS limit for maximum # of opened files */
97 :
98 8 : int32 HDFfid = 0; /* HDF file ID */
99 8 : int32 fid = -1; /* HDF-EOS file ID */
100 8 : int32 sdInterfaceID = 0; /* HDF SDS interface ID */
101 : int32 attrIndex; /* Structural Metadata attribute index */
102 :
103 8 : uint8 acs = 0; /* Read (0) / Write (1) access code */
104 :
105 : char *testname; /* Test filename */
106 : char errbuf[256];/* Error report buffer */
107 : char *metabuf; /* Pointer to structural metadata buffer */
108 : char hdfeosVersion[32]; /* HDFEOS version string */
109 :
110 : intn retryCount;
111 :
112 : /* Request the system allowed number of opened files */
113 : /* and increase HDFEOS file tables to the same size */
114 : /* ------------------------------------------------- */
115 8 : if (EHget_maxopenfiles(&curr_max, &sys_limit) >= 0
116 8 : && curr_max < sys_limit)
117 : {
118 8 : if (EHreset_maxopenfiles(sys_limit) < 0)
119 : {
120 0 : HEpush(DFE_ALROPEN, "EHopen", __FILE__, __LINE__);
121 0 : HEreport("Can't set maximum opened files number to \"%d\".\n", curr_max);
122 0 : return -1;
123 : }
124 : }
125 :
126 : /* Setup file interface */
127 : /* -------------------- */
128 8 : if (EHget_numfiles() < EHXmaxfilecount)
129 : {
130 :
131 : /*
132 : * Check that file has not been previously opened for write access if
133 : * current open request is not READONLY
134 : */
135 8 : if (access != DFACC_READ)
136 : {
137 : /* Loop through all files */
138 : /* ---------------------- */
139 0 : for (i = 0; i < EHXmaxfilecount; i++)
140 : {
141 : /* if entry is active file opened for write access ... */
142 : /* --------------------------------------------------- */
143 0 : if (EHXtypeTable[i] != 0 && EHXacsTable[i] == 1)
144 : {
145 : /* Get filename (testname) */
146 : /* ----------------------- */
147 0 : Hfidinquire(EHXfidTable[i], &testname, &dum, &dum);
148 :
149 :
150 : /* if same as filename then report error */
151 : /* ------------------------------------- */
152 0 : if (strcmp(testname, filename) == 0)
153 : {
154 0 : status = -1;
155 0 : fid = -1;
156 0 : HEpush(DFE_ALROPEN, "EHopen", __FILE__, __LINE__);
157 0 : HEreport("\"%s\" already open.\n", filename);
158 0 : break;
159 : }
160 : }
161 : }
162 : }
163 8 : if (status == 0)
164 : {
165 : /* Create HDF-EOS file */
166 : /* ------------------- */
167 8 : switch (access)
168 : {
169 0 : case DFACC_CREATE:
170 :
171 : /* Get SDS interface ID */
172 : /* -------------------- */
173 0 : sdInterfaceID = SDstart(filename, DFACC_CREATE);
174 :
175 : /* If SDstart successful ... */
176 : /* ------------------------- */
177 0 : if (sdInterfaceID != -1)
178 : {
179 : /* Set HDFEOS version number in file */
180 : /* --------------------------------- */
181 0 : snprintf(hdfeosVersion, sizeof(hdfeosVersion), "%s%s", "HDFEOS_V",
182 : HDFEOSVERSION1);
183 0 : SDsetattr(sdInterfaceID, "HDFEOSVersion", DFNT_CHAR8,
184 0 : (int)strlen(hdfeosVersion), hdfeosVersion);
185 :
186 :
187 : /* Get HDF file ID */
188 : /* --------------- */
189 0 : HDFfid = Hopen(filename, DFACC_RDWR, 0);
190 :
191 : /* Set open access to write */
192 : /* ------------------------ */
193 0 : acs = 1;
194 :
195 : /* Setup structural metadata */
196 : /* ------------------------- */
197 0 : metabuf = (char *) calloc(32000, 1);
198 0 : if(metabuf == NULL)
199 : {
200 0 : HEpush(DFE_NOSPACE,"EHopen", __FILE__, __LINE__);
201 0 : return(-1);
202 : }
203 :
204 0 : strcpy(metabuf, "GROUP=SwathStructure\n");
205 0 : strcat(metabuf, "END_GROUP=SwathStructure\n");
206 0 : strcat(metabuf, "GROUP=GridStructure\n");
207 0 : strcat(metabuf, "END_GROUP=GridStructure\n");
208 0 : strcat(metabuf, "GROUP=PointStructure\n");
209 0 : strcat(metabuf, "END_GROUP=PointStructure\n");
210 0 : strcat(metabuf, "END\n");
211 :
212 : /* Write Structural metadata */
213 : /* ------------------------- */
214 0 : SDsetattr(sdInterfaceID, "StructMetadata.0",
215 : DFNT_CHAR8, 32000, metabuf);
216 0 : free(metabuf);
217 : } else
218 : {
219 : /* If error in SDstart then report */
220 : /* ------------------------------- */
221 0 : fid = -1;
222 0 : status = -1;
223 0 : HEpush(DFE_FNF, "EHopen", __FILE__, __LINE__);
224 0 : snprintf(errbuf, sizeof(errbuf), "%s%s%s", "\"", filename,
225 : "\" cannot be created.");
226 0 : HEreport("%s\n", errbuf);
227 : }
228 :
229 0 : break;
230 :
231 : /* Open existing HDF-EOS file for read/write access */
232 : /* ------------------------------------------------ */
233 0 : case DFACC_RDWR:
234 :
235 : /* Get HDF file ID */
236 : /* --------------- */
237 : #ifndef _PGS_OLDNFS
238 : /* The following loop around the function Hopen is intended to deal with the NFS cache
239 : problem when opening file fails with errno = 150 or 151. When NFS cache is updated,
240 : this part of change is no longer necessary. 10/18/1999 */
241 0 : retryCount = 0;
242 0 : HDFfid = -1;
243 0 : while ((HDFfid == -1) && (retryCount < MAX_RETRIES))
244 : {
245 0 : HDFfid = Hopen(filename, DFACC_RDWR, 0);
246 0 : if((HDFfid == -1) && (errno == 150 || errno == 151))
247 : {
248 0 : HEpush(DFE_FNF, "EHopen", __FILE__, __LINE__);
249 0 : snprintf(errbuf, sizeof(errbuf), "\"%s\" cannot be opened for READ/WRITE access, will retry %d times.", filename, (MAX_RETRIES - retryCount - 1));
250 0 : HEreport("%s\n", errbuf);
251 : }
252 0 : retryCount++;
253 : }
254 : #else
255 : HDFfid = Hopen(filename, DFACC_RDWR, 0);
256 : #endif
257 :
258 : /* If Hopen successful ... */
259 : /* ----------------------- */
260 0 : if (HDFfid != -1)
261 : {
262 : /* Get SDS interface ID */
263 : /* -------------------- */
264 0 : sdInterfaceID = SDstart(filename, DFACC_RDWR);
265 :
266 : /* If SDstart successful ... */
267 : /* ------------------------- */
268 0 : if (sdInterfaceID != -1)
269 : {
270 : /* Set HDFEOS version number in file */
271 : /* --------------------------------- */
272 :
273 0 : attrIndex = SDfindattr(sdInterfaceID, "HDFEOSVersion");
274 0 : if (attrIndex == -1)
275 : {
276 0 : snprintf(hdfeosVersion, sizeof(hdfeosVersion), "%s%s", "HDFEOS_V",
277 : HDFEOSVERSION1);
278 0 : SDsetattr(sdInterfaceID, "HDFEOSVersion", DFNT_CHAR8,
279 0 : (int)strlen(hdfeosVersion), hdfeosVersion);
280 : }
281 : /* Set open access to write */
282 : /* ------------------------ */
283 0 : acs = 1;
284 :
285 : /* Get structural metadata attribute ID */
286 : /* ------------------------------------ */
287 0 : attrIndex = SDfindattr(sdInterfaceID, "StructMetadata.0");
288 :
289 : /* Write structural metadata if it doesn't exist */
290 : /* --------------------------------------------- */
291 0 : if (attrIndex == -1)
292 : {
293 0 : metabuf = (char *) calloc(32000, 1);
294 0 : if(metabuf == NULL)
295 : {
296 0 : HEpush(DFE_NOSPACE,"EHopen", __FILE__, __LINE__);
297 0 : return(-1);
298 : }
299 :
300 0 : strcpy(metabuf, "GROUP=SwathStructure\n");
301 0 : strcat(metabuf, "END_GROUP=SwathStructure\n");
302 0 : strcat(metabuf, "GROUP=GridStructure\n");
303 0 : strcat(metabuf, "END_GROUP=GridStructure\n");
304 0 : strcat(metabuf, "GROUP=PointStructure\n");
305 0 : strcat(metabuf, "END_GROUP=PointStructure\n");
306 0 : strcat(metabuf, "END\n");
307 :
308 0 : SDsetattr(sdInterfaceID, "StructMetadata.0",
309 : DFNT_CHAR8, 32000, metabuf);
310 0 : free(metabuf);
311 : }
312 : } else
313 : {
314 : /* If error in SDstart then report */
315 : /* ------------------------------- */
316 0 : fid = -1;
317 0 : status = -1;
318 0 : HEpush(DFE_FNF, "EHopen", __FILE__, __LINE__);
319 0 : snprintf(errbuf, sizeof(errbuf), "%s%s%s", "\"", filename,
320 : "\" cannot be opened for read/write access.");
321 0 : HEreport("%s\n", errbuf);
322 : }
323 : } else
324 : {
325 : /* If error in Hopen then report */
326 : /* ----------------------------- */
327 0 : fid = -1;
328 0 : status = -1;
329 0 : HEpush(DFE_FNF, "EHopen", __FILE__, __LINE__);
330 0 : snprintf(errbuf, sizeof(errbuf), "%s%s%s", "\"", filename,
331 : "\" cannot be opened for RDWR access.");
332 0 : HEreport("%s\n", errbuf);
333 : }
334 :
335 0 : break;
336 :
337 :
338 : /* Open existing HDF-EOS file for read-only access */
339 : /* ----------------------------------------------- */
340 8 : case DFACC_READ:
341 :
342 : /* Get HDF file ID */
343 : /* --------------- */
344 : #ifndef _PGS_OLDNFS
345 : /* The following loop around the function Hopen is intended to deal with the NFS cache
346 : problem when opening file fails with errno = 150 or 151. When NFS cache is updated,
347 : this part of change is no longer necessary. 10/18/1999 */
348 8 : retryCount = 0;
349 8 : HDFfid = -1;
350 16 : while ((HDFfid == -1) && (retryCount < MAX_RETRIES))
351 : {
352 8 : HDFfid = Hopen(filename, DFACC_READ, 0);
353 8 : if((HDFfid == -1) && (errno == 150 || errno == 151))
354 : {
355 0 : HEpush(DFE_FNF, "EHopen", __FILE__, __LINE__);
356 0 : snprintf(errbuf, sizeof(errbuf), "\"%s\" cannot be opened for READONLY access, will retry %d times.", filename, (MAX_RETRIES - retryCount - 1));
357 0 : HEreport("%s\n", errbuf);
358 : }
359 8 : retryCount++;
360 : }
361 : #else
362 : HDFfid = Hopen(filename, DFACC_READ, 0);
363 : #endif
364 :
365 : /* If file does not exist report error */
366 : /* ----------------------------------- */
367 8 : if (HDFfid == -1)
368 : {
369 0 : fid = -1;
370 0 : status = -1;
371 0 : HEpush(DFE_FNF, "EHopen", __FILE__, __LINE__);
372 0 : snprintf(errbuf, sizeof(errbuf), "\"%s\" (opened for READONLY access) does not exist.", filename);
373 0 : HEreport("%s\n", errbuf);
374 : } else
375 : {
376 : /* If file exists then get SD interface ID */
377 : /* --------------------------------------- */
378 8 : sdInterfaceID = SDstart(filename, DFACC_RDONLY);
379 :
380 : /* If SDstart successful ... */
381 : /* ------------------------- */
382 8 : if (sdInterfaceID != -1)
383 : {
384 :
385 : /* Set open access to read-only */
386 : /* ---------------------------- */
387 8 : acs = 0;
388 : } else
389 : {
390 : /* If error in SDstart then report */
391 : /* ------------------------------- */
392 0 : fid = -1;
393 0 : status = -1;
394 0 : HEpush(DFE_FNF, "EHopen", __FILE__, __LINE__);
395 0 : snprintf(errbuf, sizeof(errbuf), "%s%s%s", "\"", filename,
396 : "\" cannot be opened for read access.");
397 0 : HEreport("%s\n", errbuf);
398 : }
399 : }
400 :
401 8 : break;
402 :
403 0 : default:
404 : /* Invalid Access Code */
405 : /* ------------------- */
406 0 : fid = -1;
407 0 : status = -1;
408 0 : HEpush(DFE_BADACC, "EHopen", __FILE__, __LINE__);
409 0 : HEreport("Access Code: %d (%s).\n", access, filename);
410 : }
411 :
412 0 : }
413 : } else
414 : {
415 : /* Too many files opened */
416 : /* --------------------- */
417 0 : status = -1;
418 0 : fid = -1;
419 0 : HEpush(DFE_TOOMANY, "EHopen", __FILE__, __LINE__);
420 0 : HEreport("No more than %d files may be open simultaneously (%s).\n",
421 : EHXmaxfilecount, filename);
422 : }
423 :
424 :
425 :
426 :
427 8 : if (status == 0)
428 : {
429 : /* Initialize Vgroup Access */
430 : /* ------------------------ */
431 8 : Vstart(HDFfid);
432 :
433 :
434 : /* Assign HDFEOS fid # & Load HDF fid and sdInterfaceID tables */
435 : /* ----------------------------------------------------------- */
436 8 : for (i = 0; i < EHXmaxfilecount; i++)
437 : {
438 8 : if (EHXtypeTable[i] == 0)
439 : {
440 8 : fid = i + EHIDOFFSET;
441 8 : EHXacsTable[i] = acs;
442 8 : EHXtypeTable[i] = 1;
443 8 : EHXfidTable[i] = HDFfid;
444 8 : EHXsdTable[i] = sdInterfaceID;
445 8 : break;
446 : }
447 : }
448 :
449 : }
450 8 : return (fid);
451 : }
452 :
453 :
454 :
455 :
456 : /*----------------------------------------------------------------------------|
457 : | BEGIN_PROLOG |
458 : | |
459 : | FUNCTION: EHchkfid |
460 : | |
461 : | DESCRIPTION: Checks for valid file id and returns HDF file ID and |
462 : | SD interface ID |
463 : | |
464 : | |
465 : | Return Value Type Units Description |
466 : | ============ ====== ========= ===================================== |
467 : | status intn return status (0) SUCCEED, (-1) FAIL |
468 : | |
469 : | INPUTS: |
470 : | fid int32 HDF-EOS file ID |
471 : | name char Structure name |
472 : | |
473 : | OUTPUTS: |
474 : | HDFfid int32 HDF File ID |
475 : | sdInterfaceID int32 SDS interface ID |
476 : | access uint8 access code |
477 : | |
478 : | NOTES: |
479 : | |
480 : | |
481 : | Date Programmer Description |
482 : | ====== ============ ================================================= |
483 : | Jun 96 Joel Gales Original Programmer |
484 : | Jul 96 Joel Gales set status=-1 if failure |
485 : | Jul 96 Joel Gales Add file id offset EHIDOFFSET |
486 : | |
487 : | END_PROLOG |
488 : -----------------------------------------------------------------------------*/
489 : intn
490 0 : EHchkfid(int32 fid, const char *name, int32 * HDFfid, int32 * sdInterfaceID,
491 : uint8 * access)
492 :
493 : {
494 0 : intn status = 0; /* routine return status variable */
495 : intn fid0; /* HDFEOS file ID - Offset */
496 :
497 :
498 : /* Check for valid HDFEOS file ID range */
499 : /* ------------------------------------ */
500 0 : if (fid < EHIDOFFSET || fid > EHXmaxfilecount + EHIDOFFSET)
501 : {
502 0 : status = -1;
503 0 : HEpush(DFE_RANGE, "EHchkfid", __FILE__, __LINE__);
504 0 : HEreport("Invalid file id: %d. ID must be >= %d and < %d (%s).\n",
505 : fid, EHIDOFFSET, EHXmaxfilecount + EHIDOFFSET, name);
506 : } else
507 : {
508 : /* Compute "reduced" file ID */
509 : /* ------------------------- */
510 0 : fid0 = fid % EHIDOFFSET;
511 :
512 :
513 : /* Check that HDFEOS file ID is active */
514 : /* ----------------------------------- */
515 0 : if (EHXtypeTable[fid0] == 0)
516 : {
517 0 : status = -1;
518 0 : HEpush(DFE_GENAPP, "EHchkfid", __FILE__, __LINE__);
519 0 : HEreport("File id %d not active (%s).\n", fid, name);
520 : } else
521 : {
522 : /*
523 : * Get HDF file ID, SD interface ID and file access from external
524 : * arrays
525 : */
526 0 : *HDFfid = EHXfidTable[fid0];
527 0 : *sdInterfaceID = EHXsdTable[fid0];
528 0 : *access = EHXacsTable[fid0];
529 : }
530 : }
531 :
532 0 : return (status);
533 : }
534 :
535 :
536 :
537 :
538 : /*----------------------------------------------------------------------------|
539 : | BEGIN_PROLOG |
540 : | |
541 : | FUNCTION: EHidinfo |
542 : | |
543 : | DESCRIPTION: Gets Hopen and SD interface IDs from HDF-EOS id |
544 : | |
545 : | |
546 : | Return Value Type Units Description |
547 : | ============ ====== ========= ===================================== |
548 : | status intn return status (0) SUCCEED, (-1) FAIL |
549 : | |
550 : | INPUTS: |
551 : | fid int32 HDF-EOS file ID |
552 : | |
553 : | OUTPUTS: |
554 : | HDFfid int32 HDF File ID |
555 : | sdInterfaceID int32 SDS interface ID |
556 : | |
557 : | NOTES: |
558 : | |
559 : | |
560 : | Date Programmer Description |
561 : | ====== ============ ================================================= |
562 : | Jul 96 Joel Gales Original Programmer |
563 : | |
564 : | END_PROLOG |
565 : -----------------------------------------------------------------------------*/
566 : intn
567 0 : EHidinfo(int32 fid, int32 * HDFfid, int32 * sdInterfaceID)
568 :
569 : {
570 0 : intn status = 0; /* routine return status variable */
571 : uint8 dum; /* Dummy variable */
572 :
573 : /* Call EHchkfid to get HDF and SD interface IDs */
574 : /* --------------------------------------------- */
575 0 : status = EHchkfid(fid, "EHidinfo", HDFfid, sdInterfaceID, &dum);
576 :
577 0 : return (status);
578 : }
579 :
580 :
581 : /*----------------------------------------------------------------------------|
582 : | BEGIN_PROLOG |
583 : | |
584 : | FUNCTION: EHgetversion |
585 : | |
586 : | DESCRIPTION: Returns HDF-EOS version string |
587 : | |
588 : | |
589 : | Return Value Type Units Description |
590 : | ============ ====== ========= ===================================== |
591 : | status intn return status (0) SUCCEED, (-1) FAIL |
592 : | |
593 : | INPUTS: |
594 : | fid int32 HDF-EOS file id |
595 : | |
596 : | OUTPUTS: |
597 : | version char HDF-EOS version string |
598 : | |
599 : | NOTES: |
600 : | |
601 : | |
602 : | Date Programmer Description |
603 : | ====== ============ ================================================= |
604 : | Mar 97 Joel Gales Original Programmer |
605 : | |
606 : | END_PROLOG |
607 : -----------------------------------------------------------------------------*/
608 : intn
609 0 : EHgetversion(int32 fid, char *version)
610 : {
611 0 : intn status = 0; /* routine return status variable */
612 :
613 : uint8 access; /* Access code */
614 : int32 dum; /* Dummy variable */
615 0 : int32 sdInterfaceID = 0; /* HDF SDS interface ID */
616 : int32 attrIndex; /* HDFEOS version attribute index */
617 : int32 count; /* Version string size */
618 :
619 : char attrname[16]; /* Attribute name */
620 :
621 :
622 : /* Get SDS interface ID */
623 : /* -------------------- */
624 0 : status = EHchkfid(fid, "EHgetversion", &dum, &sdInterfaceID, &access);
625 :
626 :
627 : /* Get attribute index number */
628 : /* -------------------------- */
629 0 : attrIndex = SDfindattr(sdInterfaceID, "HDFEOSVersion");
630 :
631 : /* No such attribute */
632 : /* ----------------- */
633 0 : if (attrIndex < 0)
634 0 : return (-1);
635 :
636 : /* Get attribute size */
637 : /* ------------------ */
638 0 : status = SDattrinfo(sdInterfaceID, attrIndex, attrname, &dum, &count);
639 :
640 : /* Check return status */
641 : /* ------------------- */
642 0 : if (status < 0)
643 0 : return (-1);
644 :
645 : /* Read version attribute */
646 : /* ---------------------- */
647 0 : status = SDreadattr(sdInterfaceID, attrIndex, (VOIDP) version);
648 :
649 :
650 : /* Place string terminator on version string */
651 : /* ----------------------------------------- */
652 0 : version[count] = 0;
653 :
654 :
655 0 : return (status);
656 : }
657 :
658 :
659 :
660 :
661 : /*----------------------------------------------------------------------------|
662 : | BEGIN_PROLOG |
663 : | |
664 : | FUNCTION: EHconvAng |
665 : | |
666 : | DESCRIPTION: Angle conversion Utility |
667 : | |
668 : | |
669 : | Return Value Type Units Description |
670 : | ============ ====== ========= ===================================== |
671 : | outAngle float64 Output Angle value |
672 : | |
673 : | INPUTS: |
674 : | inAngle float64 Input Angle value |
675 : | code intn Conversion code |
676 : ! HDFE_RAD_DEG (0) |
677 : | HDFE_DEG_RAD (1) |
678 : | HDFE_DMS_DEG (2) |
679 : | HDFE_DEG_DMS (3) |
680 : | HDFE_RAD_DMS (4) |
681 : | HDFE_DMS_RAD (5) |
682 : | |
683 : | OUTPUTS: |
684 : | None |
685 : | |
686 : | NOTES: |
687 : | |
688 : | |
689 : | Date Programmer Description |
690 : | ====== ============ ================================================= |
691 : | Jun 96 Joel Gales Original Programmer |
692 : | Feb 97 Joel Gales Correct "60" min & "60" sec in _DMS conversion |
693 : | |
694 : | END_PROLOG |
695 : -----------------------------------------------------------------------------*/
696 : float64
697 0 : EHconvAng(float64 inAngle, intn code)
698 : {
699 : #define RADIANS_TO_DEGREES 180. / 3.14159265358979324
700 : #define DEGREES_TO_RADIANS 3.14159265358979324 / 180.
701 :
702 : int32 min; /* Truncated Minutes */
703 : int32 deg; /* Truncated Degrees */
704 :
705 : float64 sec; /* Seconds */
706 0 : float64 outAngle = 0.0; /* Angle in desired units */
707 :
708 0 : switch (code)
709 : {
710 :
711 : /* Convert radians to degrees */
712 : /* -------------------------- */
713 0 : case HDFE_RAD_DEG:
714 0 : outAngle = inAngle * RADIANS_TO_DEGREES;
715 0 : break;
716 :
717 :
718 : /* Convert degrees to radians */
719 : /* -------------------------- */
720 0 : case HDFE_DEG_RAD:
721 0 : outAngle = inAngle * DEGREES_TO_RADIANS;
722 0 : break;
723 :
724 :
725 : /* Convert packed degrees to degrees */
726 : /* --------------------------------- */
727 0 : case HDFE_DMS_DEG:
728 0 : deg = (int32)(inAngle / 1000000);
729 0 : min = (int32)((inAngle - deg * 1000000) / 1000);
730 0 : sec = (inAngle - deg * 1000000 - min * 1000);
731 0 : outAngle = deg + min / 60.0 + sec / 3600.0;
732 0 : break;
733 :
734 :
735 : /* Convert degrees to packed degrees */
736 : /* --------------------------------- */
737 0 : case HDFE_DEG_DMS:
738 0 : deg = (int32)(inAngle);
739 0 : min = (int32)((inAngle - deg) * 60);
740 0 : sec = (inAngle - deg - min / 60.0) * 3600;
741 :
742 0 : if ((intn) sec == 60)
743 : {
744 0 : sec = sec - 60;
745 0 : min = min + 1;
746 : }
747 0 : if (min == 60)
748 : {
749 0 : min = min - 60;
750 0 : deg = deg + 1;
751 : }
752 0 : outAngle = deg * 1000000 + min * 1000 + sec;
753 0 : break;
754 :
755 :
756 : /* Convert radians to packed degrees */
757 : /* --------------------------------- */
758 0 : case HDFE_RAD_DMS:
759 0 : inAngle = inAngle * RADIANS_TO_DEGREES;
760 0 : deg = (int32)(inAngle);
761 0 : min = (int32)((inAngle - deg) * 60);
762 0 : sec = (inAngle - deg - min / 60.0) * 3600;
763 :
764 0 : if ((intn) sec == 60)
765 : {
766 0 : sec = sec - 60;
767 0 : min = min + 1;
768 : }
769 0 : if (min == 60)
770 : {
771 0 : min = min - 60;
772 0 : deg = deg + 1;
773 : }
774 0 : outAngle = deg * 1000000 + min * 1000 + sec;
775 0 : break;
776 :
777 :
778 : /* Convert packed degrees to radians */
779 : /* --------------------------------- */
780 0 : case HDFE_DMS_RAD:
781 0 : deg = (int32)(inAngle / 1000000);
782 0 : min = (int32)((inAngle - deg * 1000000) / 1000);
783 0 : sec = (inAngle - deg * 1000000 - min * 1000);
784 0 : outAngle = deg + min / 60.0 + sec / 3600.0;
785 0 : outAngle = outAngle * DEGREES_TO_RADIANS;
786 0 : break;
787 : }
788 0 : return (outAngle);
789 : }
790 :
791 : #undef TO_DEGREES
792 : #undef TO_RADIANS
793 :
794 :
795 : /*----------------------------------------------------------------------------|
796 : | BEGIN_PROLOG |
797 : | |
798 : | FUNCTION: EHparsestr |
799 : | |
800 : | DESCRIPTION: String Parser Utility |
801 : | |
802 : | |
803 : | Return Value Type Units Description |
804 : | ============ ====== ========= ===================================== |
805 : | count int32 Number of string entries |
806 : | |
807 : | INPUTS: |
808 : | instring const char Input string |
809 : | delim const char string delimiter |
810 : | |
811 : | OUTPUTS: |
812 : | pntr char * Pointer array to beginning of each |
813 : | string entry |
814 : | len int32 Array of string entry lengths |
815 : | |
816 : | NOTES: |
817 : | |
818 : | |
819 : | Date Programmer Description |
820 : | ====== ============ ================================================= |
821 : | Jun 96 Joel Gales Original Programmer |
822 : | Aug 96 Joel Gales NULL pointer array returns count only |
823 : | |
824 : | END_PROLOG |
825 : -----------------------------------------------------------------------------*/
826 : int32
827 0 : EHparsestr(const char *instring, const char delim, char *pntr[], int32 len[])
828 : {
829 : int32 i; /* Loop index */
830 0 : int32 prevDelimPos = 0; /* Previous delimiter position */
831 : int32 count; /* Number of elements in string list */
832 : int32 slen; /* String length */
833 :
834 : char *delimitor; /* Pointer to delimiter */
835 :
836 :
837 : /* Get length of input string list & Point to first delimiter */
838 : /* ---------------------------------------------------------- */
839 0 : slen = (int)strlen(instring);
840 0 : delimitor = strchr(instring, delim);
841 :
842 : /* If NULL string set count to zero otherwise set to 1 */
843 : /* --------------------------------------------------- */
844 0 : count = (slen == 0) ? 0 : 1;
845 :
846 :
847 : /* if string pointers are requested set first one to beginning of string */
848 : /* --------------------------------------------------------------------- */
849 0 : if (&pntr[0] != NULL)
850 : {
851 0 : pntr[0] = (char *)instring;
852 : }
853 : /* If delimiter not found ... */
854 : /* ---------------------------- */
855 0 : if (delimitor == NULL)
856 : {
857 : /* if string length requested then set to input string length */
858 : /* ---------------------------------------------------------- */
859 0 : if (len != NULL)
860 : {
861 0 : len[0] = slen;
862 : }
863 : } else
864 : /* Delimiters Found */
865 : /* ---------------- */
866 : {
867 : /* Loop through all characters in string */
868 : /* ------------------------------------- */
869 0 : for (i = 1; i < slen; i++)
870 : {
871 : /* If character is a delimiter ... */
872 : /* ------------------------------- */
873 0 : if (instring[i] == delim)
874 : {
875 :
876 : /* If string pointer requested */
877 : /* --------------------------- */
878 0 : if (&pntr[0] != NULL)
879 : {
880 : /* if requested then compute string length of entry */
881 : /* ------------------------------------------------ */
882 0 : if (len != NULL)
883 : {
884 0 : len[count - 1] = i - prevDelimPos;
885 : }
886 : /* Point to beginning of string entry */
887 : /* ---------------------------------- */
888 0 : pntr[count] = (char *)instring + i + 1;
889 : }
890 : /* Reset previous delimiter position and increment counter */
891 : /* ------------------------------------------------------- */
892 0 : prevDelimPos = i + 1;
893 0 : count++;
894 : }
895 : }
896 :
897 : /* Compute string length of last entry */
898 : /* ----------------------------------- */
899 0 : if (&pntr[0] != NULL && len != NULL)
900 : {
901 0 : len[count - 1] = i - prevDelimPos;
902 : }
903 : }
904 :
905 0 : return (count);
906 : }
907 :
908 :
909 :
910 :
911 : /*----------------------------------------------------------------------------|
912 : | BEGIN_PROLOG |
913 : | |
914 : | FUNCTION: EHstrwithin |
915 : | |
916 : | DESCRIPTION: Searches for string within target string |
917 : | |
918 : | |
919 : | Return Value Type Units Description |
920 : | ============ ====== ========= ===================================== |
921 : | indx int32 Element index (0 - based) |
922 : | |
923 : | INPUTS: |
924 : | target const char Target string |
925 : | search const char Search string |
926 : | delim const char Delimiter |
927 : | |
928 : | OUTPUTS: |
929 : | None |
930 : | |
931 : | NOTES: |
932 : | |
933 : | |
934 : | Date Programmer Description |
935 : | ====== ============ ================================================= |
936 : | Jun 96 Joel Gales Original Programmer |
937 : | Jan 97 Joel Gales Change ptr & slen to dynamic arrays |
938 : | |
939 : | END_PROLOG |
940 : -----------------------------------------------------------------------------*/
941 : int32
942 0 : EHstrwithin(const char *target, const char *search, const char delim)
943 : {
944 0 : intn found = 0; /* Target string found flag */
945 :
946 : int32 indx; /* Loop index */
947 : int32 nentries; /* Number of entries in search string */
948 : int32 *slen; /* Pointer to string length array */
949 :
950 : char **ptr; /* Pointer to string pointer array */
951 : char buffer[128];/* Buffer to hold "test" string entry */
952 :
953 :
954 : /* Count number of entries in search string list */
955 : /* --------------------------------------------- */
956 0 : nentries = EHparsestr(search, delim, NULL, NULL);
957 :
958 :
959 : /* Allocate string pointer and length arrays */
960 : /* ----------------------------------------- */
961 0 : ptr = (char **) calloc(nentries, sizeof(char *));
962 0 : if(ptr == NULL)
963 : {
964 0 : HEpush(DFE_NOSPACE,"EHstrwithin", __FILE__, __LINE__);
965 0 : return(-1);
966 : }
967 0 : slen = (int32 *) calloc(nentries, sizeof(int32));
968 0 : if(slen == NULL)
969 : {
970 0 : HEpush(DFE_NOSPACE,"EHstrwithin", __FILE__, __LINE__);
971 0 : free(ptr);
972 0 : return(-1);
973 : }
974 :
975 :
976 : /* Parse search string */
977 : /* ------------------- */
978 0 : nentries = EHparsestr(search, delim, ptr, slen);
979 :
980 :
981 : /* Loop through all elements in search string list */
982 : /* ----------------------------------------------- */
983 0 : for (indx = 0; indx < nentries; indx++)
984 : {
985 : /* Copy string entry into buffer */
986 : /* ----------------------------- */
987 0 : memcpy(buffer, ptr[indx], slen[indx]);
988 0 : buffer[slen[indx]] = 0;
989 :
990 :
991 : /* Compare target string with string entry */
992 : /* --------------------------------------- */
993 0 : if (strcmp(target, buffer) == 0)
994 : {
995 0 : found = 1;
996 0 : break;
997 : }
998 : }
999 :
1000 : /* If not found set return to -1 */
1001 : /* ----------------------------- */
1002 0 : if (found == 0)
1003 : {
1004 0 : indx = -1;
1005 : }
1006 0 : free(slen);
1007 0 : free(ptr);
1008 :
1009 0 : return (indx);
1010 : }
1011 :
1012 :
1013 :
1014 :
1015 :
1016 : /*----------------------------------------------------------------------------|
1017 : | BEGIN_PROLOG |
1018 : | |
1019 : | FUNCTION: EHloadliststr |
1020 : | |
1021 : | DESCRIPTION: Builds list string from string array |
1022 : | |
1023 : | |
1024 : | Return Value Type Units Description |
1025 : | ============ ====== ========= ===================================== |
1026 : | status intn return status (0) SUCCEED, (-1) FAIL |
1027 : | |
1028 : | INPUTS: |
1029 : | ptr char String pointer array |
1030 : | nentries int32 Number of string array elements |
1031 : | delim char Delimiter |
1032 : | |
1033 : | OUTPUTS: |
1034 : | liststr char Output list string |
1035 : | |
1036 : | NOTES: |
1037 : | |
1038 : | |
1039 : | Date Programmer Description |
1040 : | ====== ============ ================================================= |
1041 : | Jun 96 Joel Gales Original Programmer |
1042 : | |
1043 : | END_PROLOG |
1044 : -----------------------------------------------------------------------------*/
1045 : intn
1046 0 : EHloadliststr(char *ptr[], int32 nentries, char *liststr, char delim)
1047 : {
1048 0 : intn status = 0; /* routine return status variable */
1049 :
1050 : int32 i; /* Loop index */
1051 : int32 slen; /* String entry length */
1052 0 : int32 off = 0; /* Position of next entry along string list */
1053 : char dstr[2]; /* string version of input variable "delim" */
1054 :
1055 0 : dstr[0] = delim;
1056 0 : dstr[1] = '\0';
1057 :
1058 :
1059 : /* Loop through all entries in string array */
1060 : /* ---------------------------------------- */
1061 0 : for (i = 0; i < nentries; i++)
1062 : {
1063 : /* Get string length of string array entry */
1064 : /* --------------------------------------- */
1065 0 : slen = (int)strlen(ptr[i]);
1066 :
1067 :
1068 : /* Copy string entry to string list */
1069 : /* -------------------------------- */
1070 0 : memcpy(liststr + off, ptr[i], slen + 1);
1071 :
1072 :
1073 : /* Concatenate with delimiter */
1074 : /* -------------------------- */
1075 0 : if (i != nentries - 1)
1076 : {
1077 0 : strcat(liststr, dstr);
1078 : }
1079 : /* Get position of next entry for string list */
1080 : /* ------------------------------------------ */
1081 0 : off += slen + 1;
1082 : }
1083 :
1084 0 : return (status);
1085 : }
1086 :
1087 :
1088 :
1089 :
1090 :
1091 : /*----------------------------------------------------------------------------|
1092 : | BEGIN_PROLOG |
1093 : | |
1094 : | FUNCTION: EHgetid |
1095 : | |
1096 : | DESCRIPTION: Get Vgroup/Vdata ID from name |
1097 : | |
1098 : | |
1099 : | Return Value Type Units Description |
1100 : | ============ ====== ========= ===================================== |
1101 : | outID int32 Output ID |
1102 : | |
1103 : | INPUTS: |
1104 : | fid int32 HDF-EOS file ID |
1105 : | vgid int32 Vgroup ID |
1106 : | objectname const char object name |
1107 : | code intn object code (0 - Vgroup, 1 - Vdata) |
1108 : | access const char access ("w/r") |
1109 : | |
1110 : | |
1111 : | OUTPUTS: |
1112 : | None |
1113 : | |
1114 : | NOTES: |
1115 : | |
1116 : | |
1117 : | Date Programmer Description |
1118 : | ====== ============ ================================================= |
1119 : | Jun 96 Joel Gales Original Programmer |
1120 : | |
1121 : | END_PROLOG |
1122 : -----------------------------------------------------------------------------*/
1123 : int32
1124 0 : EHgetid(int32 fid, int32 vgid, const char *objectname, intn code,
1125 : const char *access)
1126 : {
1127 : intn i; /* Loop index */
1128 :
1129 : int32 nObjects; /* # of objects in Vgroup */
1130 : int32 *tags; /* Pnt to Vgroup object tags array */
1131 : int32 *refs; /* Pnt to Vgroup object refs array */
1132 : int32 id; /* Object ID */
1133 0 : int32 outID = -1; /* Desired object ID */
1134 :
1135 : char name[128]; /* Object name */
1136 :
1137 :
1138 : /* Get Number of objects */
1139 : /* --------------------- */
1140 0 : nObjects = Vntagrefs(vgid);
1141 :
1142 : /* If objects exist ... */
1143 : /* -------------------- */
1144 0 : if (nObjects != 0)
1145 : {
1146 :
1147 : /* Get tags and references of objects */
1148 : /* ---------------------------------- */
1149 0 : tags = (int32 *) malloc(sizeof(int32) * nObjects);
1150 0 : if(tags == NULL)
1151 : {
1152 0 : HEpush(DFE_NOSPACE,"EHgetid", __FILE__, __LINE__);
1153 0 : return(-1);
1154 : }
1155 0 : refs = (int32 *) malloc(sizeof(int32) * nObjects);
1156 0 : if(refs == NULL)
1157 : {
1158 0 : HEpush(DFE_NOSPACE,"EHgetid", __FILE__, __LINE__);
1159 0 : free(tags);
1160 0 : return(-1);
1161 : }
1162 :
1163 0 : Vgettagrefs(vgid, tags, refs, nObjects);
1164 :
1165 :
1166 : /* Vgroup ID Section */
1167 : /* ----------------- */
1168 0 : if (code == 0)
1169 : {
1170 : /* Loop through objects */
1171 : /* -------------------- */
1172 0 : for (i = 0; i < nObjects; i++)
1173 : {
1174 :
1175 : /* If object is Vgroup ... */
1176 : /* ----------------------- */
1177 0 : if (*(tags + i) == DFTAG_VG)
1178 : {
1179 :
1180 : /* Get ID and name */
1181 : /* --------------- */
1182 0 : id = Vattach(fid, *(refs + i), access);
1183 0 : Vgetname(id, name);
1184 :
1185 : /* If name equals desired object name get ID */
1186 : /* ----------------------------------------- */
1187 0 : if (strcmp(name, objectname) == 0)
1188 : {
1189 0 : outID = id;
1190 0 : break;
1191 : }
1192 : /* If not desired object then detach */
1193 : /* --------------------------------- */
1194 0 : Vdetach(id);
1195 : }
1196 : }
1197 0 : } else if (code == 1)
1198 : {
1199 :
1200 : /* Loop through objects */
1201 : /* -------------------- */
1202 0 : for (i = 0; i < nObjects; i++)
1203 : {
1204 :
1205 : /* If object is Vdata ... */
1206 : /* ---------------------- */
1207 0 : if (*(tags + i) == DFTAG_VH)
1208 : {
1209 :
1210 : /* Get ID and name */
1211 : /* --------------- */
1212 0 : id = VSattach(fid, *(refs + i), access);
1213 0 : VSgetname(id, name);
1214 :
1215 : /* If name equals desired object name get ID */
1216 : /* ----------------------------------------- */
1217 0 : if (EHstrwithin(objectname, name, ',') != -1)
1218 : {
1219 0 : outID = id;
1220 0 : break;
1221 : }
1222 : /* If not desired object then detach */
1223 : /* --------------------------------- */
1224 0 : VSdetach(id);
1225 : }
1226 : }
1227 : }
1228 0 : free(tags);
1229 0 : free(refs);
1230 : }
1231 0 : return (outID);
1232 : }
1233 :
1234 :
1235 :
1236 :
1237 :
1238 : /*----------------------------------------------------------------------------|
1239 : | BEGIN_PROLOG |
1240 : | |
1241 : | FUNCTION: EHrevflds |
1242 : | |
1243 : | DESCRIPTION: Reverses elements in a string list |
1244 : | |
1245 : | |
1246 : | Return Value Type Units Description |
1247 : | ============ ====== ========= ===================================== |
1248 : | status intn return status (0) SUCCEED, (-1) FAIL |
1249 : | |
1250 : | INPUTS: |
1251 : | dimlist char Original dimension list |
1252 : | |
1253 : | OUTPUTS: |
1254 : | revdimlist char Reversed dimension list |
1255 : | |
1256 : | NOTES: |
1257 : | |
1258 : | |
1259 : | Date Programmer Description |
1260 : | ====== ============ ================================================= |
1261 : | Jun 96 Joel Gales Original Programmer |
1262 : | |
1263 : | END_PROLOG |
1264 : -----------------------------------------------------------------------------*/
1265 : intn
1266 0 : EHrevflds(const char *dimlist, char *revdimlist)
1267 : {
1268 0 : intn status = 0; /* routine return status variable */
1269 :
1270 : int32 indx; /* Loop index */
1271 : int32 nentries; /* Number of entries in search string */
1272 : int32 *slen; /* Pointer to string length array */
1273 :
1274 : char **ptr; /* Pointer to string pointer array */
1275 : char *tempPtr; /* Temporary string pointer */
1276 : char *tempdimlist;/* Temporary dimension list */
1277 :
1278 :
1279 : /* Copy dimlist into temp dimlist */
1280 : /* ------------------------------ */
1281 0 : tempdimlist = (char *) malloc(strlen(dimlist) + 1);
1282 0 : if(tempdimlist == NULL)
1283 : {
1284 0 : HEpush(DFE_NOSPACE,"EHrevflds", __FILE__, __LINE__);
1285 0 : return(-1);
1286 : }
1287 0 : strcpy(tempdimlist, dimlist);
1288 :
1289 :
1290 : /* Count number of entries in search string list */
1291 : /* --------------------------------------------- */
1292 0 : nentries = EHparsestr(tempdimlist, ',', NULL, NULL);
1293 :
1294 :
1295 : /* Allocate string pointer and length arrays */
1296 : /* ----------------------------------------- */
1297 0 : ptr = (char **) calloc(nentries, sizeof(char *));
1298 0 : if(ptr == NULL)
1299 : {
1300 0 : HEpush(DFE_NOSPACE,"EHrevflds", __FILE__, __LINE__);
1301 0 : free(tempdimlist);
1302 0 : return(-1);
1303 : }
1304 0 : slen = (int32 *) calloc(nentries, sizeof(int32));
1305 0 : if(slen == NULL)
1306 : {
1307 0 : HEpush(DFE_NOSPACE,"EHrevflds", __FILE__, __LINE__);
1308 0 : free(ptr);
1309 0 : free(tempdimlist);
1310 0 : return(-1);
1311 : }
1312 :
1313 :
1314 : /* Parse search string */
1315 : /* ------------------- */
1316 0 : nentries = EHparsestr(tempdimlist, ',', ptr, slen);
1317 :
1318 :
1319 : /* Reverse entries in string pointer array */
1320 : /* --------------------------------------- */
1321 0 : for (indx = 0; indx < nentries / 2; indx++)
1322 : {
1323 0 : tempPtr = ptr[indx];
1324 0 : ptr[indx] = ptr[nentries - 1 - indx];
1325 0 : ptr[nentries - 1 - indx] = tempPtr;
1326 : }
1327 :
1328 :
1329 : /* Replace comma delimiters by nulls */
1330 : /* --------------------------------- */
1331 0 : for (indx = 0; indx < nentries - 1; indx++)
1332 : {
1333 0 : *(ptr[indx] - 1) = 0;
1334 : }
1335 :
1336 :
1337 : /* Build new string list */
1338 : /* --------------------- */
1339 0 : status = EHloadliststr(ptr, nentries, revdimlist, ',');
1340 :
1341 :
1342 0 : free(slen);
1343 0 : free(ptr);
1344 0 : free(tempdimlist);
1345 :
1346 0 : return (status);
1347 : }
1348 :
1349 : /*----------------------------------------------------------------------------|
1350 : | BEGIN_PROLOG |
1351 : | |
1352 : | FUNCTION: EHgetmetavalue |
1353 : | |
1354 : | DESCRIPTION: Returns metadata value |
1355 : | |
1356 : | |
1357 : | Return Value Type Units Description |
1358 : | ============ ====== ========= ===================================== |
1359 : | status intn return status (0) SUCCEED, (-1) FAIL |
1360 : | |
1361 : | INPUTS: |
1362 : | metaptrs char Begin and end of metadata section |
1363 : | parameter char parameter to access |
1364 : | |
1365 : | OUTPUTS: |
1366 : | metaptr char Ptr to (updated) beginning of metadata |
1367 : | retstr char return string containing value |
1368 : | |
1369 : | NOTES: |
1370 : | |
1371 : | |
1372 : | Date Programmer Description |
1373 : | ====== ============ ================================================= |
1374 : | Jun 96 Joel Gales Original Programmer |
1375 : | Jan 97 Joel Gales Check string pointer against end of meta section |
1376 : | |
1377 : | END_PROLOG |
1378 : -----------------------------------------------------------------------------*/
1379 : intn
1380 0 : EHgetmetavalue(char *metaptrs[], const char *parameter, char *retstr)
1381 : {
1382 0 : intn status = 0; /* routine return status variable */
1383 :
1384 : int32 slen; /* String length */
1385 : char *newline; /* Position of new line character */
1386 : char *sptr; /* string pointer within metadata */
1387 :
1388 :
1389 : /* Get string length of parameter string + 1 */
1390 : /* ----------------------------------------- */
1391 0 : slen = (int)strlen(parameter) + 1;
1392 :
1393 :
1394 : /* Build search string (parameter string + "=") */
1395 : /* -------------------------------------------- */
1396 0 : strcpy(retstr, parameter);
1397 0 : strcat(retstr, "=");
1398 :
1399 :
1400 : /* Search for string within metadata (beginning at metaptrs[0]) */
1401 : /* ------------------------------------------------------------ */
1402 0 : sptr = strstr(metaptrs[0], retstr);
1403 :
1404 :
1405 : /* If string found within desired section ... */
1406 : /* ------------------------------------------ */
1407 0 : if (sptr != NULL && sptr < metaptrs[1])
1408 : {
1409 : /* Store position of string within metadata */
1410 : /* ---------------------------------------- */
1411 0 : metaptrs[0] = sptr;
1412 :
1413 : /* Find newline "\n" character */
1414 : /* --------------------------- */
1415 0 : newline = strchr(metaptrs[0], '\n');
1416 0 : if (newline == NULL)
1417 : {
1418 0 : retstr[0] = 0;
1419 0 : return -1;
1420 : }
1421 :
1422 : /* Copy from "=" to "\n" (exclusive) into return string */
1423 : /* ---------------------------------------------------- */
1424 0 : memcpy(retstr, metaptrs[0] + slen, newline - metaptrs[0] - slen);
1425 :
1426 : /* Terminate return string with null */
1427 : /* --------------------------------- */
1428 0 : retstr[newline - metaptrs[0] - slen] = 0;
1429 : } else
1430 : {
1431 : /*
1432 : * if parameter string not found within section, null return string
1433 : * and set status to -1.
1434 : */
1435 0 : retstr[0] = 0;
1436 0 : status = -1;
1437 : }
1438 :
1439 0 : return (status);
1440 : }
1441 :
1442 :
1443 :
1444 :
1445 : /*----------------------------------------------------------------------------|
1446 : | BEGIN_PROLOG |
1447 : | |
1448 : | FUNCTION: EHmetagroup |
1449 : | |
1450 : | DESCRIPTION: Returns pointers to beginning and end of metadata group |
1451 : | |
1452 : | |
1453 : | Return Value Type Units Description |
1454 : | ============ ====== ========= ===================================== |
1455 : | metabuf char Pointer to HDF-EOS object in metadata |
1456 : | |
1457 : | INPUTS: |
1458 : | sdInterfaceID int32 SDS interface ID |
1459 : | structname char HDF-EOS structure name |
1460 : | structcode char Structure code ("s/g/p") |
1461 : | groupname char Metadata group name |
1462 : | |
1463 : | OUTPUTS: |
1464 : | metaptrs char pointers to begin and end of metadata |
1465 : | |
1466 : | NOTES: |
1467 : | |
1468 : | |
1469 : | Date Programmer Description |
1470 : | ====== ============ ================================================= |
1471 : | Jun 96 Joel Gales Original Programmer |
1472 : | Aug 96 Joel Gales Make metadata ODL compliant |
1473 : | |
1474 : | END_PROLOG |
1475 : -----------------------------------------------------------------------------*/
1476 : char *
1477 0 : EHmetagroup(int32 sdInterfaceID, const char *structname, const char *structcode,
1478 : const char *groupname, char *metaptrs[])
1479 : {
1480 : intn i; /* Loop index */
1481 :
1482 : int32 attrIndex; /* Structural metadata attribute index */
1483 : int32 nmeta; /* Number of 32000 byte metadata sections */
1484 : int32 metalen; /* Length of structural metadata */
1485 :
1486 : char *metabuf; /* Pointer (handle) to structural metadata */
1487 0 : char *endptr = NULL; /* Pointer to end of metadata section */
1488 : char *metaptr; /* Metadata pointer */
1489 : char *prevmetaptr;/* Previous position of metadata pointer */
1490 : char *utlstr; /* Utility string */
1491 :
1492 :
1493 :
1494 : /* Allocate memory for utility string */
1495 : /* ---------------------------------- */
1496 0 : utlstr = (char *) calloc(UTLSTR_MAX_SIZE,sizeof(char));
1497 0 : if(utlstr == NULL)
1498 : {
1499 0 : HEpush(DFE_NOSPACE,"EHEHmetagroup", __FILE__, __LINE__);
1500 :
1501 0 : return( NULL);
1502 : }
1503 : /* Determine number of structural metadata "sections" */
1504 : /* -------------------------------------------------- */
1505 0 : nmeta = 0;
1506 : while (1)
1507 : {
1508 : /* Search for "StructMetadata.x" attribute */
1509 : /* --------------------------------------- */
1510 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%d", "StructMetadata.", (int)nmeta);
1511 0 : attrIndex = SDfindattr(sdInterfaceID, utlstr);
1512 :
1513 :
1514 : /* If found then increment metadata section counter else exit loop */
1515 : /* --------------------------------------------------------------- */
1516 0 : if (attrIndex != -1)
1517 : {
1518 0 : nmeta++;
1519 : } else
1520 : {
1521 0 : break;
1522 : }
1523 : }
1524 :
1525 :
1526 : /* Allocate space for metadata (in units of 32000 bytes) */
1527 : /* ----------------------------------------------------- */
1528 0 : metabuf = (char *) calloc(32000 * nmeta, 1);
1529 :
1530 0 : if(metabuf == NULL)
1531 : {
1532 0 : HEpush(DFE_NOSPACE,"EHmetagroup", __FILE__, __LINE__);
1533 0 : free(utlstr);
1534 0 : return(metabuf);
1535 : }
1536 :
1537 :
1538 : /* Read structural metadata */
1539 : /* ------------------------ */
1540 0 : for (i = 0; i < nmeta; i++)
1541 : {
1542 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%d", "StructMetadata.", i);
1543 0 : attrIndex = SDfindattr(sdInterfaceID, utlstr);
1544 0 : metalen = (int)strlen(metabuf);
1545 0 : SDreadattr(sdInterfaceID, attrIndex, metabuf + metalen);
1546 : }
1547 :
1548 : /* Determine length (# of characters) of metadata */
1549 : /* ---------------------------------------------- */
1550 0 : metalen = (int)strlen(metabuf);
1551 :
1552 :
1553 :
1554 : /* Find HDF-EOS structure "root" group in metadata */
1555 : /* ----------------------------------------------- */
1556 :
1557 : /* Setup proper search string */
1558 : /* -------------------------- */
1559 0 : if (strcmp(structcode, "s") == 0)
1560 : {
1561 0 : strcpy(utlstr, "GROUP=SwathStructure");
1562 0 : } else if (strcmp(structcode, "g") == 0)
1563 : {
1564 0 : strcpy(utlstr, "GROUP=GridStructure");
1565 0 : } else if (strcmp(structcode, "p") == 0)
1566 : {
1567 0 : strcpy(utlstr, "GROUP=PointStructure");
1568 : }
1569 : /* Use string search routine (strstr) to move through metadata */
1570 : /* ----------------------------------------------------------- */
1571 0 : metaptr = strstr(metabuf, utlstr);
1572 :
1573 :
1574 :
1575 : /* Save current metadata pointer */
1576 : /* ----------------------------- */
1577 0 : prevmetaptr = metaptr;
1578 :
1579 :
1580 : /* First loop for "old-style" (non-ODL) metadata string */
1581 : /* ---------------------------------------------------- */
1582 0 : if (strcmp(structcode, "s") == 0)
1583 : {
1584 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s", "SwathName=\"", structname);
1585 0 : } else if (strcmp(structcode, "g") == 0)
1586 : {
1587 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s", "GridName=\"", structname);
1588 0 : } else if (strcmp(structcode, "p") == 0)
1589 : {
1590 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s", "PointName=\"", structname);
1591 : }
1592 : /* Do string search */
1593 : /* ---------------- */
1594 0 : if (metaptr)
1595 0 : metaptr = strstr(metaptr, utlstr);
1596 :
1597 :
1598 : /*
1599 : * If not found then return to previous position in metadata and look for
1600 : * "new-style" (ODL) metadata string
1601 : */
1602 0 : if (metaptr == NULL)
1603 : {
1604 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s", "GROUP=\"", structname);
1605 0 : metaptr = strstr(prevmetaptr, utlstr);
1606 : }
1607 : /* Find group within structure */
1608 : /* --------------------------- */
1609 0 : if (metaptr && groupname != NULL)
1610 : {
1611 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s", "GROUP=", groupname);
1612 0 : metaptr = strstr(metaptr, utlstr);
1613 :
1614 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s%s", "\t\tEND_GROUP=", groupname);
1615 0 : if (metaptr)
1616 0 : endptr = strstr(metaptr, utlstr);
1617 : else
1618 0 : endptr = NULL;
1619 0 : } else if (metaptr)
1620 : {
1621 : /* If groupname == NULL then find end of structure in metadata */
1622 : /* ----------------------------------------------------------- */
1623 0 : snprintf(utlstr, UTLSTR_MAX_SIZE, "%s", "\n\tEND_GROUP=");
1624 0 : endptr = strstr(metaptr, utlstr);
1625 : }
1626 :
1627 :
1628 : /* Return beginning and ending pointers */
1629 : /* ------------------------------------ */
1630 0 : metaptrs[0] = metaptr;
1631 0 : metaptrs[1] = endptr;
1632 :
1633 0 : free(utlstr);
1634 :
1635 0 : return (metabuf);
1636 : }
1637 :
1638 :
1639 : /*----------------------------------------------------------------------------|
1640 : | BEGIN_PROLOG |
1641 : | |
1642 : | FUNCTION: EHattr |
1643 : | |
1644 : | DESCRIPTION: Reads/Writes attributes for HDF-EOS structures |
1645 : | |
1646 : | |
1647 : | Return Value Type Units Description |
1648 : | ============ ====== ========= ===================================== |
1649 : | status intn return status (0) SUCCEED, (-1) FAIL |
1650 : | |
1651 : | INPUTS: |
1652 : | fid int32 HDF-EOS file ID |
1653 : | attrVgrpID int32 Attribute Vgroup ID |
1654 : | attrname char attribute name |
1655 : | numbertype int32 attribute HDF numbertype |
1656 : | count int32 Number of attribute elements |
1657 : | wrcode char Read/Write Code "w/r" |
1658 : | datbuf void I/O buffer |
1659 : | |
1660 : | |
1661 : | OUTPUTS: |
1662 : | datbuf void I/O buffer |
1663 : | |
1664 : | NOTES: |
1665 : | |
1666 : | |
1667 : | Date Programmer Description |
1668 : | ====== ============ ================================================= |
1669 : | Jun 96 Joel Gales Original Programmer |
1670 : | Oct 96 Joel Gales Pass Vgroup id as routine parameter |
1671 : | Oct 96 Joel Gales Remove Vdetach call |
1672 : | |
1673 : | END_PROLOG |
1674 : -----------------------------------------------------------------------------*/
1675 : intn
1676 0 : EHattr(int32 fid, int32 attrVgrpID, const char *attrname, int32 numbertype,
1677 : int32 count, const char *wrcode, VOIDP datbuf)
1678 :
1679 : {
1680 0 : intn status = 0; /* routine return status variable */
1681 : int32 vdataID; /* Attribute Vdata ID */
1682 :
1683 : /*
1684 : * Attributes are stored as Vdatas with name given by the user, class:
1685 : * "Attr0.0" and fieldname: "AttrValues"
1686 : */
1687 :
1688 :
1689 : /* Get Attribute Vdata ID and "open" with appropriate I/O code */
1690 : /* ----------------------------------------------------------- */
1691 0 : vdataID = EHgetid(fid, attrVgrpID, attrname, 1, wrcode);
1692 :
1693 : /* Write Attribute Section */
1694 : /* ----------------------- */
1695 0 : if (strcmp(wrcode, "w") == 0)
1696 : {
1697 : /* Create Attribute Vdata (if it doesn't exist) */
1698 : /* -------------------------------------------- */
1699 0 : if (vdataID == -1)
1700 : {
1701 0 : vdataID = VSattach(fid, -1, "w");
1702 0 : VSsetname(vdataID, attrname);
1703 0 : VSsetclass(vdataID, "Attr0.0");
1704 :
1705 0 : VSfdefine(vdataID, "AttrValues", numbertype, count);
1706 0 : Vinsert(attrVgrpID, vdataID);
1707 : }
1708 : /* Write Attribute */
1709 : /* --------------- */
1710 0 : VSsetfields(vdataID, "AttrValues");
1711 0 : (void) VSsizeof(vdataID, (char*) "AttrValues");
1712 0 : VSwrite(vdataID, datbuf, 1, FULL_INTERLACE);
1713 :
1714 0 : VSdetach(vdataID);
1715 : }
1716 : /* Read Attribute Section */
1717 : /* ---------------------- */
1718 0 : if (strcmp(wrcode, "r") == 0)
1719 : {
1720 : /* If attribute doesn't exist report error */
1721 : /* --------------------------------------- */
1722 0 : if (vdataID == -1)
1723 : {
1724 0 : status = -1;
1725 0 : HEpush(DFE_GENAPP, "EHattr", __FILE__, __LINE__);
1726 0 : HEreport("Attribute %s not defined.\n", attrname);
1727 : } else
1728 : {
1729 0 : VSsetfields(vdataID, "AttrValues");
1730 0 : (void) VSsizeof(vdataID, (char*) "AttrValues");
1731 0 : VSread(vdataID, datbuf, 1, FULL_INTERLACE);
1732 0 : VSdetach(vdataID);
1733 : }
1734 : }
1735 0 : return (status);
1736 : }
1737 :
1738 :
1739 :
1740 :
1741 : /*----------------------------------------------------------------------------|
1742 : | BEGIN_PROLOG |
1743 : | |
1744 : | FUNCTION: EHattrinfo |
1745 : | |
1746 : | DESCRIPTION: Returns numbertype and count of given HDF-EOS attribute |
1747 : | |
1748 : | |
1749 : | Return Value Type Units Description |
1750 : | ============ ====== ========= ===================================== |
1751 : | status intn return status (0) SUCCEED, (-1) FAIL |
1752 : | |
1753 : | INPUTS: |
1754 : | fid int32 HDF-EOS file ID |
1755 : | attrVgrpID int32 Attribute Vgroup ID |
1756 : | attrname char attribute name |
1757 : | |
1758 : | OUTPUTS: |
1759 : | numbertype int32 attribute HDF numbertype |
1760 : | count int32 Number of attribute elements |
1761 : | |
1762 : | NOTES: |
1763 : | |
1764 : | |
1765 : | Date Programmer Description |
1766 : | ====== ============ ================================================= |
1767 : | Jun 96 Joel Gales Original Programmer |
1768 : | Oct 96 Joel Gales Pass Vgroup id as routine parameter |
1769 : | Oct 96 Joel Gales Remove Vdetach call |
1770 : | |
1771 : | END_PROLOG |
1772 : -----------------------------------------------------------------------------*/
1773 : intn
1774 0 : EHattrinfo(int32 fid, int32 attrVgrpID, const char *attrname, int32 * numbertype,
1775 : int32 * count)
1776 :
1777 : {
1778 0 : intn status = 0; /* routine return status variable */
1779 : int32 vdataID; /* Attribute Vdata ID */
1780 :
1781 : /* Get Attribute Vdata ID */
1782 : /* ---------------------- */
1783 0 : vdataID = EHgetid(fid, attrVgrpID, attrname, 1, "r");
1784 :
1785 : /* If attribute not defined then report error */
1786 : /* ------------------------------------------ */
1787 0 : if (vdataID == -1)
1788 : {
1789 0 : status = -1;
1790 0 : HEpush(DFE_GENAPP, "EHattr", __FILE__, __LINE__);
1791 0 : HEreport("Attribute %s not defined.\n", attrname);
1792 : } else
1793 : {
1794 : /* Get attribute info */
1795 : /* ------------------ */
1796 0 : VSsetfields(vdataID, "AttrValues");
1797 0 : *count = VSsizeof(vdataID, (char*) "AttrValues");
1798 0 : *numbertype = VFfieldtype(vdataID, 0);
1799 0 : VSdetach(vdataID);
1800 : }
1801 :
1802 0 : return (status);
1803 : }
1804 :
1805 :
1806 :
1807 :
1808 :
1809 : /*----------------------------------------------------------------------------|
1810 : | BEGIN_PROLOG |
1811 : | |
1812 : | FUNCTION: EHattrcat |
1813 : | |
1814 : | DESCRIPTION: Returns a listing of attributes within an HDF-EOS structure |
1815 : | |
1816 : | |
1817 : | Return Value Type Units Description |
1818 : | ============ ====== ========= ===================================== |
1819 : | nattr int32 Number of attributes in swath struct |
1820 : | |
1821 : | INPUTS: |
1822 : | fid int32 HDF-EOS file ID |
1823 : | attrVgrpID int32 Attribute Vgroup ID |
1824 : | structcode char Structure Code ("s/g/p") |
1825 : | |
1826 : | OUTPUTS: |
1827 : | attrnames char Attribute names in swath struct |
1828 : | (Comma-separated list) |
1829 : | strbufsize int32 Attributes name list string length |
1830 : | |
1831 : | NOTES: |
1832 : | |
1833 : | |
1834 : | Date Programmer Description |
1835 : | ====== ============ ================================================= |
1836 : | Jun 96 Joel Gales Original Programmer |
1837 : | Oct 96 Joel Gales Pass Vgroup id as routine parameter |
1838 : | Oct 96 Joel Gales Remove Vdetach call |
1839 : | |
1840 : | END_PROLOG |
1841 : -----------------------------------------------------------------------------*/
1842 : int32
1843 0 : EHattrcat(int32 fid, int32 attrVgrpID, char *attrnames, int32 * strbufsize)
1844 : {
1845 : intn i; /* Loop index */
1846 :
1847 : int32 nObjects; /* # of objects in Vgroup */
1848 : int32 *tags; /* Pnt to Vgroup object tags array */
1849 : int32 *refs; /* Pnt to Vgroup object refs array */
1850 : int32 vdataID; /* Attribute Vdata ID */
1851 :
1852 0 : int32 nattr = 0; /* Number of attributes */
1853 : int32 slen; /* String length */
1854 :
1855 : char name[80]; /* Attribute name */
1856 : static const char indxstr[] = "INDXMAP:"; /* Index Mapping reserved
1857 : string */
1858 : static const char fvstr[] = "_FV_"; /* Flag Value reserved string */
1859 : static const char bsom[] = "_BLKSOM:";/* Block SOM Offset reserved string */
1860 :
1861 :
1862 : /* Set string buffer size to 0 */
1863 : /* --------------------------- */
1864 0 : *strbufsize = 0;
1865 :
1866 :
1867 : /* Get number of attributes within Attribute Vgroup */
1868 : /* ------------------------------------------------ */
1869 0 : nObjects = Vntagrefs(attrVgrpID);
1870 :
1871 :
1872 : /* If attributes exist ... */
1873 : /* ----------------------- */
1874 0 : if (nObjects > 0)
1875 : {
1876 : /* Get tags and references of attribute Vdatas */
1877 : /* ------------------------------------------- */
1878 0 : tags = (int32 *) malloc(sizeof(int32) * nObjects);
1879 0 : if(tags == NULL)
1880 : {
1881 0 : HEpush(DFE_NOSPACE,"EHattrcat", __FILE__, __LINE__);
1882 0 : return(-1);
1883 : }
1884 0 : refs = (int32 *) malloc(sizeof(int32) * nObjects);
1885 0 : if(refs == NULL)
1886 : {
1887 0 : HEpush(DFE_NOSPACE,"EHattrcat", __FILE__, __LINE__);
1888 0 : free(tags);
1889 0 : return(-1);
1890 : }
1891 :
1892 0 : Vgettagrefs(attrVgrpID, tags, refs, nObjects);
1893 :
1894 : /* Get attribute vdata IDs and names */
1895 : /* --------------------------------- */
1896 0 : for (i = 0; i < nObjects; i++)
1897 : {
1898 0 : vdataID = VSattach(fid, *(refs + i), "r");
1899 0 : VSgetname(vdataID, name);
1900 :
1901 : /*
1902 : * Don't return fill value, index mapping & block SOM attributes
1903 : */
1904 0 : if (memcmp(name, indxstr, strlen(indxstr)) != 0 &&
1905 0 : memcmp(name, fvstr, strlen(fvstr)) != 0 &&
1906 0 : memcmp(name, bsom, strlen(bsom)) != 0)
1907 : {
1908 : /* Increment attribute counter and add name to list */
1909 : /* ------------------------------------------------ */
1910 0 : nattr++;
1911 0 : if (attrnames != NULL)
1912 : {
1913 0 : if (nattr == 1)
1914 : {
1915 0 : strcpy(attrnames, name);
1916 : } else
1917 : {
1918 0 : strcat(attrnames, ",");
1919 0 : strcat(attrnames, name);
1920 : }
1921 : }
1922 : /* Increment attribute names string length */
1923 : /* --------------------------------------- */
1924 0 : slen = (nattr == 1) ? (int)strlen(name) : (int)strlen(name) + 1;
1925 0 : *strbufsize += slen;
1926 : }
1927 0 : VSdetach(vdataID);
1928 : }
1929 0 : free(tags);
1930 0 : free(refs);
1931 : }
1932 0 : return (nattr);
1933 : }
1934 :
1935 :
1936 :
1937 : /*----------------------------------------------------------------------------|
1938 : | BEGIN_PROLOG |
1939 : | |
1940 : | FUNCTION: EHinquire |
1941 : | |
1942 : | DESCRIPTION: Returns number and names of HDF-EOS structures in file |
1943 : | |
1944 : | |
1945 : | Return Value Type Units Description |
1946 : | ============ ====== ========= ===================================== |
1947 : | nobj int32 Number of HDF-EOS structures in file |
1948 : | |
1949 : | INPUTS: |
1950 : | filename char HDF-EOS filename |
1951 : | type char Object Type ("SWATH/GRID/POINT") |
1952 : | |
1953 : | OUTPUTS: |
1954 : | objectlist char List of object names (comma-separated) |
1955 : | strbufsize int32 Length of objectlist |
1956 : | |
1957 : | NOTES: |
1958 : | |
1959 : | |
1960 : | Date Programmer Description |
1961 : | ====== ============ ================================================= |
1962 : | Jun 96 Joel Gales Original Programmer |
1963 : | |
1964 : | END_PROLOG |
1965 : -----------------------------------------------------------------------------*/
1966 : int32
1967 8 : EHinquire(const char *filename, const char *type, char *objectlist, int32 * strbufsize)
1968 : {
1969 : int32 HDFfid; /* HDF file ID */
1970 : int32 vgRef; /* Vgroup reference number */
1971 : int32 vGrpID; /* Vgroup ID */
1972 8 : int32 nobj = 0; /* Number of HDFEOS objects in file */
1973 : int32 slen; /* String length */
1974 :
1975 : char name[512]; /* Object name */
1976 : char class[80]; /* Object class */
1977 :
1978 :
1979 : /* Open HDFEOS file of read-only access */
1980 : /* ------------------------------------ */
1981 8 : HDFfid = Hopen(filename, DFACC_READ, 0);
1982 :
1983 :
1984 : /* Start Vgroup Interface */
1985 : /* ---------------------- */
1986 8 : Vstart(HDFfid);
1987 :
1988 :
1989 : /* If string buffer size is requested then zero out counter */
1990 : /* -------------------------------------------------------- */
1991 8 : if (strbufsize != NULL)
1992 : {
1993 8 : *strbufsize = 0;
1994 : }
1995 : /* Search for objects from beginning of HDF file */
1996 : /* -------------------------------------------- */
1997 8 : vgRef = -1;
1998 :
1999 : /* Loop through all objects */
2000 : /* ------------------------ */
2001 : while (1)
2002 : {
2003 : /* Get Vgroup reference number */
2004 : /* --------------------------- */
2005 36 : vgRef = Vgetid(HDFfid, vgRef);
2006 :
2007 : /* If no more then exist search loop */
2008 : /* --------------------------------- */
2009 36 : if (vgRef == -1)
2010 : {
2011 8 : break;
2012 : }
2013 : /* Get Vgroup ID, name, and class */
2014 : /* ------------------------------ */
2015 28 : vGrpID = Vattach(HDFfid, vgRef, "r");
2016 28 : Vgetname(vGrpID, name);
2017 28 : Vgetclass(vGrpID, class);
2018 :
2019 :
2020 : /* If object of desired type (SWATH, POINT, GRID) ... */
2021 : /* -------------------------------------------------- */
2022 28 : if (strcmp(class, type) == 0)
2023 : {
2024 :
2025 : /* Increment counter */
2026 : /* ----------------- */
2027 0 : nobj++;
2028 :
2029 :
2030 : /* If object list requested add name to list */
2031 : /* ----------------------------------------- */
2032 0 : if (objectlist != NULL)
2033 : {
2034 0 : if (nobj == 1)
2035 : {
2036 0 : strcpy(objectlist, name);
2037 : } else
2038 : {
2039 0 : strcat(objectlist, ",");
2040 0 : strcat(objectlist, name);
2041 : }
2042 : }
2043 : /* Compute string length of object entry */
2044 : /* ------------------------------------- */
2045 0 : slen = (nobj == 1) ? (int)strlen(name) : (int)strlen(name) + 1;
2046 :
2047 :
2048 : /* If string buffer size is requested then increment buffer size */
2049 : /* ------------------------------------------------------------- */
2050 0 : if (strbufsize != NULL)
2051 : {
2052 0 : *strbufsize += slen;
2053 : }
2054 : }
2055 : /* Detach Vgroup */
2056 : /* ------------- */
2057 28 : Vdetach(vGrpID);
2058 : }
2059 :
2060 : /* "Close" Vgroup interface and HDFEOS file */
2061 : /* ---------------------------------------- */
2062 8 : Vend(HDFfid);
2063 8 : Hclose(HDFfid);
2064 :
2065 8 : return (nobj);
2066 : }
2067 :
2068 :
2069 :
2070 : /*----------------------------------------------------------------------------|
2071 : | BEGIN_PROLOG |
2072 : | |
2073 : | FUNCTION: EHclose |
2074 : | |
2075 : | DESCRIPTION: Closes HDF-EOS file |
2076 : | |
2077 : | |
2078 : | Return Value Type Units Description |
2079 : | ============ ====== ========= ===================================== |
2080 : | status intn return status (0) SUCCEED, (-1) FAIL |
2081 : | |
2082 : | INPUTS: |
2083 : | fid int32 HDF-EOS File ID |
2084 : | |
2085 : | OUTPUTS: |
2086 : | None |
2087 : | |
2088 : | NOTES: |
2089 : | |
2090 : | |
2091 : | Date Programmer Description |
2092 : | ====== ============ ================================================= |
2093 : | Jun 96 Joel Gales Original Programmer |
2094 : | Jul 96 Joel Gales Add file id offset EHIDOFFSET |
2095 : | Aug 96 Joel Gales Add HE error report if file id out of bounds |
2096 : | Nov 96 Joel Gales Add EHXacsTable array to "garbage collection" |
2097 : | |
2098 : | END_PROLOG |
2099 : -----------------------------------------------------------------------------*/
2100 : intn
2101 8 : EHclose(int32 fid)
2102 : {
2103 8 : intn status = 0; /* routine return status variable */
2104 :
2105 : int32 HDFfid; /* HDF file ID */
2106 : int32 sdInterfaceID; /* HDF SDS interface ID */
2107 : int32 fid0; /* HDF EOS file id - offset */
2108 :
2109 :
2110 : /* Check for valid HDFEOS file ID range */
2111 : /* ------------------------------------ */
2112 8 : if (fid >= EHIDOFFSET && fid < EHXmaxfilecount + EHIDOFFSET)
2113 : {
2114 : /* Compute "reduced" file ID */
2115 : /* ------------------------- */
2116 8 : fid0 = fid % EHIDOFFSET;
2117 :
2118 :
2119 : /* Get HDF file ID and SD interface ID */
2120 : /* ----------------------------------- */
2121 8 : HDFfid = EHXfidTable[fid0];
2122 8 : sdInterfaceID = EHXsdTable[fid0];
2123 :
2124 : /* "Close" SD interface, Vgroup interface, and HDF file */
2125 : /* ---------------------------------------------------- */
2126 8 : status = SDend(sdInterfaceID);
2127 8 : status = Vend(HDFfid);
2128 8 : status = Hclose(HDFfid);
2129 :
2130 : /* Clear out external array entries */
2131 : /* -------------------------------- */
2132 8 : EHXtypeTable[fid0] = 0;
2133 8 : EHXacsTable[fid0] = 0;
2134 8 : EHXfidTable[fid0] = 0;
2135 8 : EHXsdTable[fid0] = 0;
2136 8 : if (EHget_numfiles() == 0)
2137 : {
2138 8 : free(EHXtypeTable);
2139 8 : EHXtypeTable = NULL;
2140 8 : free(EHXacsTable);
2141 8 : EHXacsTable = NULL;
2142 8 : free(EHXfidTable);
2143 8 : EHXfidTable = NULL;
2144 8 : free(EHXsdTable);
2145 8 : EHXsdTable = NULL;
2146 8 : EHXmaxfilecount = 0;
2147 : }
2148 : } else
2149 : {
2150 0 : status = -1;
2151 0 : HEpush(DFE_RANGE, "EHclose", __FILE__, __LINE__);
2152 0 : HEreport("Invalid file id: %d. ID must be >= %d and < %d.\n",
2153 : fid, EHIDOFFSET, EHXmaxfilecount + EHIDOFFSET);
2154 : }
2155 :
2156 8 : return (status);
2157 : }
2158 :
2159 : /*----------------------------------------------------------------------------|
2160 : | BEGIN_PROLOG |
2161 : | |
2162 : | FUNCTION: EHnumstr |
2163 : | |
2164 : | DESCRIPTION: Returns numerical type code of the given string |
2165 : | representation. |
2166 : | |
2167 : | |
2168 : | Return Value Type Units Description |
2169 : | ============ ====== ========= ===================================== |
2170 : | numbertype int32 numerical type code |
2171 : | |
2172 : | INPUTS: |
2173 : | strcode const char string representation of the type code |
2174 : | |
2175 : | |
2176 : | OUTPUTS: |
2177 : | None |
2178 : | |
2179 : | NOTES: |
2180 : | |
2181 : | |
2182 : | Date Programmer Description |
2183 : | ====== ============ ================================================= |
2184 : | Nov 07 Andrey Kiselev Original Programmer |
2185 : | |
2186 : | END_PROLOG |
2187 : -----------------------------------------------------------------------------*/
2188 : int32
2189 0 : EHnumstr(const char *strcode)
2190 : {
2191 0 : if (strcmp(strcode, "DFNT_UCHAR8") == 0)
2192 0 : return DFNT_UCHAR8;
2193 0 : else if (strcmp(strcode, "DFNT_CHAR8") == 0)
2194 0 : return DFNT_CHAR8;
2195 0 : else if (strcmp(strcode, "DFNT_FLOAT32") == 0)
2196 0 : return DFNT_FLOAT32;
2197 0 : else if (strcmp(strcode, "DFNT_FLOAT64") == 0)
2198 0 : return DFNT_FLOAT64;
2199 0 : else if (strcmp(strcode, "DFNT_INT8") == 0)
2200 0 : return DFNT_INT8;
2201 0 : else if (strcmp(strcode, "DFNT_UINT8") == 0)
2202 0 : return DFNT_UINT8;
2203 0 : else if (strcmp(strcode, "DFNT_INT16") == 0)
2204 0 : return DFNT_INT16;
2205 0 : else if (strcmp(strcode, "DFNT_UINT16") == 0)
2206 0 : return DFNT_UINT16;
2207 0 : else if (strcmp(strcode, "DFNT_INT32") == 0)
2208 0 : return DFNT_INT32;
2209 0 : else if (strcmp(strcode, "DFNT_UINT32") == 0)
2210 0 : return DFNT_UINT32;
2211 : else
2212 0 : return DFNT_NONE;
2213 : }
2214 :
2215 : /*----------------------------------------------------------------------------|
2216 : | BEGIN_PROLOG |
2217 : | |
2218 : | FUNCTION: EHreset_maxopenfiles |
2219 : | |
2220 : | DESCRIPTION: Change the allowed number of opened HDFEOS files. |
2221 : | |
2222 : | |
2223 : | Return Value Type Units Description |
2224 : | ============ ====== ========= ===================================== |
2225 : | numbertype intn The current maximum number of opened |
2226 : | files allowed, or -1, if unable |
2227 : | to reset it. |
2228 : | |
2229 : | INPUTS: |
2230 : | strcode intn Requested number of opened files. |
2231 : | |
2232 : | |
2233 : | OUTPUTS: |
2234 : | None |
2235 : | |
2236 : | NOTES: |
2237 : | |
2238 : | |
2239 : | Date Programmer Description |
2240 : | ========== ============ ============================================== |
2241 : | 2013.04.03 Andrey Kiselev Original Programmer |
2242 : | |
2243 : | END_PROLOG |
2244 : -----------------------------------------------------------------------------*/
2245 : static intn
2246 8 : EHreset_maxopenfiles(intn req_max)
2247 : {
2248 : intn ret_value;
2249 :
2250 8 : if (req_max <= EHXmaxfilecount)
2251 0 : return EHXmaxfilecount;
2252 :
2253 : /* Falback to built-in NEOSHDF constant if */
2254 : /* SDreset_maxopenfiles() interface is not available */
2255 : /* ------------------------------------------------- */
2256 : #ifdef HDF4_HAS_MAXOPENFILES
2257 8 : ret_value = SDreset_maxopenfiles(req_max);
2258 : #else
2259 : ret_value = NEOSHDF;
2260 : #endif /* HDF4_HAS_MAXOPENFILES */
2261 :
2262 8 : if (ret_value > 0)
2263 : {
2264 8 : EHXtypeTable = realloc(EHXtypeTable, ret_value * sizeof(*EHXtypeTable));
2265 8 : memset(EHXtypeTable + EHXmaxfilecount, 0,
2266 8 : (ret_value - EHXmaxfilecount) * sizeof(*EHXtypeTable));
2267 8 : EHXacsTable = realloc(EHXacsTable, ret_value * sizeof(*EHXacsTable));
2268 8 : memset(EHXacsTable + EHXmaxfilecount, 0,
2269 8 : (ret_value - EHXmaxfilecount) * sizeof(*EHXacsTable));
2270 8 : EHXfidTable = realloc(EHXfidTable, ret_value * sizeof(*EHXfidTable));
2271 8 : memset(EHXfidTable + EHXmaxfilecount, 0,
2272 8 : (ret_value - EHXmaxfilecount) * sizeof(*EHXfidTable));
2273 8 : EHXsdTable = realloc(EHXsdTable, ret_value * sizeof(*EHXsdTable));
2274 8 : memset(EHXsdTable + EHXmaxfilecount, 0,
2275 8 : (ret_value - EHXmaxfilecount) * sizeof(*EHXsdTable));
2276 8 : EHXmaxfilecount = ret_value;
2277 : }
2278 :
2279 8 : return ret_value;
2280 : }
2281 :
2282 : /*----------------------------------------------------------------------------|
2283 : | BEGIN_PROLOG |
2284 : | |
2285 : | FUNCTION: EHget_maxopenfiles |
2286 : | |
2287 : | DESCRIPTION: Request the allowed number of opened HDFEOS files and maximum |
2288 : | number of opened files allowed in the system. |
2289 : | |
2290 : | |
2291 : | Return Value Type Units Description |
2292 : | ============ ====== ========= ===================================== |
2293 : | status intn return status (0) SUCCEED, (-1) FAIL |
2294 : | |
2295 : | INPUTS: |
2296 : | None |
2297 : | |
2298 : | |
2299 : | OUTPUTS: |
2300 : | curr_max intn Current number of open files allowed. |
2301 : | sys_limit intn Maximum number of open files allowed |
2302 : | in the system. |
2303 : | |
2304 : | NOTES: |
2305 : | |
2306 : | |
2307 : | Date Programmer Description |
2308 : | ========== ============ ============================================== |
2309 : | 2013.04.03 Andrey Kiselev Original Programmer |
2310 : | |
2311 : | END_PROLOG |
2312 : -----------------------------------------------------------------------------*/
2313 : static intn
2314 8 : EHget_maxopenfiles(intn *curr_max,
2315 : intn *sys_limit)
2316 : {
2317 8 : intn ret_value = 0;
2318 :
2319 : #ifdef HDF4_HAS_MAXOPENFILES
2320 8 : ret_value = SDget_maxopenfiles(curr_max, sys_limit);
2321 : #else
2322 : *sys_limit = NEOSHDF;
2323 : #endif /* HDF4_HAS_MAXOPENFILES */
2324 :
2325 8 : *curr_max = EHXmaxfilecount;
2326 :
2327 8 : return ret_value;
2328 : }
2329 :
2330 : /*----------------------------------------------------------------------------|
2331 : | BEGIN_PROLOG |
2332 : | |
2333 : | FUNCTION: EHget_numfiles |
2334 : | |
2335 : | DESCRIPTION: Request the number of HDFEOS files currently opened. |
2336 : | |
2337 : | |
2338 : | Return Value Type Units Description |
2339 : | ============ ====== ========= ===================================== |
2340 : | nfileopen intn Number of HDFEOS files already opened. |
2341 : | |
2342 : | INPUTS: |
2343 : | None |
2344 : | |
2345 : | |
2346 : | OUTPUTS: |
2347 : | None |
2348 : | in the system. |
2349 : | |
2350 : | NOTES: |
2351 : | |
2352 : | |
2353 : | Date Programmer Description |
2354 : | ========== ============ ============================================== |
2355 : | 2013.04.03 Andrey Kiselev Original Programmer |
2356 : | |
2357 : | END_PROLOG |
2358 : -----------------------------------------------------------------------------*/
2359 : static intn
2360 16 : EHget_numfiles()
2361 : {
2362 : intn i; /* Loop index */
2363 16 : intn nfileopen = 0; /* # of HDF files open */
2364 :
2365 16 : if (EHXtypeTable)
2366 : {
2367 : /* Determine number of files currently opened */
2368 : /* ------------------------------------------ */
2369 320016 : for (i = 0; i < EHXmaxfilecount; i++)
2370 : {
2371 320000 : nfileopen += EHXtypeTable[i];
2372 : }
2373 : }
2374 :
2375 16 : return nfileopen;
2376 : }
|
