static CDFstatus ValidateCCR (vFILE *fp, OFF_T offset, Logical debug)
{
struct CCRstruct64 CCR;
CDFstatus status;
if (debug)
#if defined(win32) || defined(__MINGW32__)
printf(" Checking CCR...@%I64d\n", offset);
#else
printf(" Checking CCR...@%lld\n", offset);
#endif
status = ReadCCR64 (fp, offset,
CCR_RECORD, &CCR,
CCR_NULL);
if (status != CDF_OK) return status;
if (CCR.RecordType != CCR_)
return QuitCDF ("CDF(CCR): record type is invalid ", offset,
4, 1, &(CCR.RecordType), 0, debug);
if (CCR.RecordSize < CCR_BASE_SIZE64)
return QuitCDF ("CDF(CCR): record size is invalid ", offset,
8, 1, &(CCR.RecordSize), 0, debug);
if (CCR.uSize < 0)
return QuitCDF ("CDF(CCR): uncompressed file size is invalid ", offset,
8, 1, &(CCR.uSize), 0, debug);
if (CCR.CPRoffset < 0)
return QuitCDF ("CDF(CCR): offset to CPR is invalid ", offset,
8, 1, &(CCR.CPRoffset), 0, debug);
return CDF_OK;
}
static CDFstatus ValidateSPR (vFILE *fp, OFF_T offset, Logical debug)
{
struct SPRstruct64 SPR;
int i;
CDFstatus status;
if (debug)
#if defined(win32) || defined(__MINGW32__)
printf(" Checking SPR...@%I64d\n", offset);
#else
printf(" Checking SPR...@%lld\n", offset);
#endif
status = ReadSPR64 (fp, offset,
SPR_RECORD, &SPR,
SPR_NULL);
if (status != CDF_OK) return status;
if (SPR.RecordType != SPR_)
return QuitCDF ("CDF(SPR): record type is invalid ", offset,
4, 1, &(SPR.RecordType), 0, debug);
if (SPR.RecordSize != (SPR_BASE_SIZE64 + SPR.pCount * sizeof(Int32)))
return QuitCDF ("CDF(SPR): record size is invalid ", offset,
8, 1, &(SPR.RecordSize), 0, debug);
if (SPR.pCount < 1 || SPR.pCount > CDF_MAX_PARMS)
return QuitCDF ("CDF(SPR): sparseness parameter count is invalid ", offset,
4, 1, &(SPR.pCount), 0, debug);
return CDF_OK;
}
static CDFstatus ValidateCPR (vFILE *fp, OFF_T offset, Logical debug)
{
struct CPRstruct64 CPR;
int i;
CDFstatus status;
long cType, cParms[1];
if (debug)
#if defined(win32) || defined(__MINGW32__)
printf(" Checking CPR...@%I64d\n", offset);
#else
printf(" Checking CPR...@%lld\n", offset);
#endif
status = ReadCPR64 (fp, offset,
CPR_RECORD, &CPR,
CPR_NULL);
if (status != CDF_OK) return status;
if (CPR.RecordType != CPR_)
return QuitCDF ("CDF(CPR): record type is invalid ", offset,
4, 1, &(CPR.RecordType), 0, debug);
if (CPR.RecordSize != (CPR_BASE_SIZE64 + CPR.pCount * sizeof(Int32)))
return QuitCDF ("CDF(CPR): reocrd size is invalid ", offset,
8, 1, &(CPR.RecordSize), 0, debug);
if (CPR.pCount != 1)
return QuitCDF ("CDF(CPR): compression parameter count is invalid ", offset,
4, 1, &(CPR.pCount), 0, debug);
cType = (long) CPR.cType;
cParms[0] = (long) CPR.cParms[0];
if (ValidateCompression64(cType, cParms) != CDF_OK)
return QuitCDF ("CDF(CPR): compression parameter is invalid ", offset,
4, 1, &(CPR.cType), 0, debug);
return CDF_OK;
}
CDFstatus ValidateCPR (vFILE *fp, Int32 offset, Logical debug)
{
struct CPRstruct CPR;
int i;
CDFstatus status;
long cType, cParms[1];
if (debug)
printf(" Checking CPR...@%d\n", (int) offset);
status = ReadCPR (fp, offset,
CPR_RECORD, &CPR,
CPR_NULL);
if (status != CDF_OK) return status;
if (CPR.RecordType != CPR_)
return QuitCDF ("CDF: record type is invalid ",
4, 1, &(CPR.RecordType), 0, debug);
if (CPR.RecordSize != (CPR_BASE_SIZE + CPR.pCount * sizeof(Int32)))
return QuitCDF ("CDF: reocrd size is invalid ",
4, 1, &(CPR.RecordSize), 0, debug);
if (CPR.pCount != 1)
return QuitCDF ("CDF: compression parameter count is invalid ",
4, 1, &(CPR.pCount), 0, debug);
cType = (long) CPR.cType;
cParms[0] = (long) CPR.cParms[0];
if (ValidateCompression(cType, cParms) != CDF_OK)
return QuitCDF ("CDF: compression parameter is invalid ",
4, 1, &(CPR.cType), 0, debug);
return CDF_OK;
}
static CDFstatus ValidateUIR (vFILE *fp, OFF_T offset, Logical debug)
{
struct UIRstruct64 UIR;
CDFstatus status;
if (debug)
#if defined(win32) || defined(__MINGW32__)
printf(" Checking UIR...@%I64d\n", offset);
#else
printf(" Checking UIR...@%lld\n", offset);
#endif
status = ReadUIR64 (fp, offset,
UIR_RECORD, &UIR,
UIR_NULL);
if (status != CDF_OK) return status;
if (UIR.RecordType != UIR_)
return QuitCDF ("CDF(UIR): record type is invalid ", offset,
4, 1, &(UIR.RecordType), 0, debug);
if (UIR.RecordSize < UIR_BASE_SIZE64)
return QuitCDF ("CDF(UIR): record size is invalid ", offset,
8, 1, &(UIR.RecordSize), 0, debug);
if (UIR.NextUIR < 0)
return QuitCDF ("CDF(UIR): offset to next UIR is invalid ", offset,
8, 1, &(UIR.NextUIR), 0, debug);
if (UIR.PrevUIR < 0)
return QuitCDF ("CDF(UIR): offset to previous UIR is invalid ", offset,
8, 1, &(UIR.PrevUIR), 0, debug);
return CDF_OK;
}
CDFstatus ValidateCCR (vFILE *fp, Int32 offset, Logical debug)
{
struct CCRstruct CCR;
CDFstatus status;
if (debug)
printf(" Checking CCR...@%d\n", (int) offset);
status = ReadCCR (fp, offset,
CCR_RECORD, &CCR,
CCR_NULL);
if (status != CDF_OK) return status;
if (CCR.RecordType != CCR_)
return QuitCDF ("CDF: record type is invalid ",
4, 1, &(CCR.RecordType), 0, debug);
if (CCR.RecordSize < CCR_BASE_SIZE)
return QuitCDF ("CDF: record size is invalid ",
4, 1, &(CCR.RecordSize), 0, debug);
if (CCR.uSize < 0)
return QuitCDF ("CDF: uncompressed file size is invalid ",
4, 1, &(CCR.uSize), 0, debug);
if (CCR.CPRoffset < 0)
return QuitCDF ("CDF: offset to CPR is invalid ",
4, 1, &(CCR.CPRoffset), 0, debug);
return CDF_OK;
}
CDFstatus ValidateUIR (vFILE *fp, Int32 offset, Logical debug)
{
struct UIRstruct UIR;
CDFstatus status;
if (debug)
printf(" Checking UIR...@%d\n", (int) offset);
status = ReadUIR (fp, offset,
UIR_RECORD, &UIR,
UIR_NULL);
if (status != CDF_OK) return status;
if (UIR.RecordType != UIR_)
return QuitCDF ("CDF: record type is invalid ",
4, 1, &(UIR.RecordType), 0, debug);
if (UIR.RecordSize < UIR_BASE_SIZE)
return QuitCDF ("CDF: record size is invalid for Unused Internal Record",
4, 1, &(UIR.RecordSize), 0, debug);
if (UIR.NextUIR < 0)
return QuitCDF ("CDF: offset to next UIR is invalid for Unused Internal Record",
4, 1, &(UIR.NextUIR), 0, debug);
if (UIR.PrevUIR < 0)
return QuitCDF ("CDF: offset to previous UIR is invalid for Unused Internal Record",
4, 1, &(UIR.PrevUIR), 0, debug);
return CDF_OK;
}
CDFstatus ValidateAttributeEntryLink (struct CDFstruct *CDF, vFILE *fp,
Int32 num, Logical zEntry, OFF_T EDRhead,
Int32 numEntries, Int32 maxEntry,
Logical debug)
{
CDFstatus status;
OFF_T offset, nextAEDR;
Int32 entryNum, lastNum, *visits;
int ix, iy;
offset = EDRhead;
lastNum = 0;
visits = (Int32 *) cdf_AllocateMemory (numEntries * sizeof(Int32), NULL);
if (visits == NULL) return BAD_MALLOC;
for (ix = 0; ix < numEntries; ++ix)
visits[ix] = 0;
ix = 0;
while (offset != 0) {
status = ValidateAEDR (CDF, fp, offset, num, maxEntry, zEntry, debug);
if (status != CDF_OK) {
cdf_FreeMemory (visits, NULL);
return status;
}
status = ReadAEDR64 (fp, offset,
AEDR_NUM, &entryNum,
AEDR_AEDRNEXT, &nextAEDR,
AEDR_NULL);
if (ix > 0) {
for (iy = 0; iy < ix; ++iy) {
if (visits[iy] == entryNum) {
cdf_FreeMemory (visits, NULL);
return QuitCDF ("CDF: entry number is repeating in an attribute entry link: ",
4, 1, &entryNum, 0, debug);
}
}
}
if (ix == (int) numEntries) {
cdf_FreeMemory (visits, NULL);
return QuitCDF ("CDF: number of entries is more than maximum in an attribute entry link: ",
4, 1, &ix, 0, debug);
}
visits[ix] = entryNum;
++ix;
if (lastNum < entryNum) lastNum = entryNum;
offset = nextAEDR;
}
if (lastNum != maxEntry) {
cdf_FreeMemory (visits, NULL);
return QuitCDF ("CDF: last entry number is not the maximum entry number in an attribute entry link: ",
4, 2, &lastNum, &maxEntry, debug);
}
cdf_FreeMemory (visits, NULL);
return CDF_OK;
}
static CDFstatus ValidateAEDR (struct CDFstruct *CDF, vFILE *fp, OFF_T offset,
Int32 num, Int32 maxEntry, Logical zEntry,
Logical debug)
{
struct AEDRstruct64 AEDR;
size_t nBytes;
CDFstatus status;
if (debug)
#if defined(win32) || defined(__MINGW32__)
printf(" Checking AEDR...@%I64d\n", offset);
#else
printf(" Checking AEDR...@%lld\n", offset);
#endif
status = ReadAEDR64 (fp, offset,
AEDR_RECORD, &AEDR, NULL,
AEDR_NULL);
if (status != CDF_OK) return status;
if ((!zEntry && AEDR.RecordType != AgrEDR_) ||
(zEntry && AEDR.RecordType != AzEDR_))
return QuitCDF ("CDF(AEDR): record type is invalid ", offset,
4, 1, &(AEDR.RecordType), 0, debug);
if (AEDR.RecordSize < AEDR_BASE_SIZE64)
return QuitCDF ("CDF(AEDR): record size is invalid ", offset,
8, 1, &(AEDR.RecordSize), 0, debug);
if (AEDR.AEDRnext < 0)
return QuitCDF ("CDF(AEDR): offset to next AEDR is invalid ", offset,
8, 1, &(AEDR.AEDRnext), 0, debug);
/* Check for "AEDR.AttrNum != num" is not included as some CDFs fail this
check. Don't know why.... */
/*
if (AEDR.AttrNum < 0 || AEDR.AttrNum > GDR.NumAttr)
return QuitCDF ("CDF(AEDR): attribute number is invalid ", offset,
4, 2, &(AEDR.AttrNum), &(GDR.NumAttr), debug);
*/
if (!ValidDataType(AEDR.DataType))
return QuitCDF ("CDF(AEDR): data type is invalid ", offset,
4, 1, &(AEDR.DataType), 0, debug);
if (AEDR.Num < 0 || AEDR.Num > maxEntry)
return QuitCDF ("CDF(AEDR): entry number is invalid ", offset,
4, 2, &(AEDR.Num), &(maxEntry), debug);
if (AEDR.AEDRnext < 0)
return QuitCDF ("CDF(AEDR): next AEDR offset is invalid : ", offset,
8, 1, &(AEDR.AEDRnext), 0, debug);
if (AEDR.NumElems < 1 ||
(STRINGdataType(AEDR.DataType) &&
AEDR.NumElems > (AEDR.RecordSize - AEDR_VALUE_OFFSET64)))
return QuitCDF ("CDF(AEDR): number of elements is invalid ", offset,
4, 1, &(AEDR.NumElems), 0, debug);
nBytes = (size_t) (CDFelemSize(AEDR.DataType) * AEDR.NumElems);
if (nBytes < 1 ||
nBytes > (AEDR.RecordSize - AEDR_VALUE_OFFSET64))
return QuitCDF ("CDF(AEDR): entry value size is invalid ", offset,
4, 1, &nBytes, 0, debug);
if (AEDR.RecordSize > (AEDR_MAX_SIZE64 + nBytes))
return QuitCDF ("CDF(AEDR): record size is invalid ", offset,
8, 1, &(AEDR.RecordSize), 0, debug);
return CDF_OK;
}
static CDFstatus ValidateVXR (vFILE *fp, OFF_T offset, Int32 lastRec, Logical debug)
{
struct VXRstruct64 VXR;
int i;
Int32 irType;
CDFstatus status;
if (debug)
#if defined(win32) || defined(__MINGW32__)
printf(" Checking VXR...@%I64d\n", offset);
#else
printf(" Checking VXR...@%lld\n", offset);
#endif
status = ReadVXR64 (fp, offset,
VXR_RECORD, &VXR,
VXR_NULL);
if (status != CDF_OK) return status;
if (VXR.RecordType != VXR_)
return QuitCDF ("CDF(VXR): record type is invalid ", offset,
4, 1, &(VXR.RecordType), 0, debug);
if (VXR.RecordSize != (VXR_FIRSTREC_OFFSET64 + 16 * VXR.Nentries))
return QuitCDF ("CDF(VXR): record size is invalid ", offset,
8, 1, &(VXR.RecordSize), 0, debug);
if (VXR.Nentries < 0 || VXR.Nentries > MAX_VXR_ENTRIES)
return QuitCDF ("CDF(VXR): number of entries is invalid ", offset,
4, 1, &(VXR.Nentries), 0, debug);
if (VXR.NusedEntries < 0 || VXR.NusedEntries > VXR.Nentries)
return QuitCDF ("CDF(VXR): number of used entries is invalid ", offset,
4, 2, &(VXR.NusedEntries), &(VXR.Nentries), debug);
if (VXR.VXRnext > 0) {
if (VXR.Last[VXR.NusedEntries-1] > lastRec)
return QuitCDF ("CDF(VXR): a variable last record does not match in a Variable Index Record: ", offset,
4, 2, &(VXR.Last[VXR.NusedEntries-1]), &lastRec, debug);
status = ValidateVXR (fp, VXR.VXRnext, lastRec, debug);
if (status != CDF_OK) return status;
} else if (VXR.VXRnext < 0) {
return QuitCDF ("CDF(VXR): a link offset to next record is negative in a Variable Index Record: ", offset,
8, 1, &(VXR.VXRnext), 0, debug);
}
for (i = 0; i < VXR.NusedEntries; ++i) {
if (VXR.First[i] < 0 || VXR.Last[i] < 0 || VXR.First[i] > VXR.Last[i])
return QuitCDF ("CDF(VXR): entry value for first/last is invalid ", offset,
4, 2, &(VXR.First[i]), &(VXR.Last[i]), debug);
if (VXR.Offset[i] < 1)
return QuitCDF ("CDF(VXR): entry offset is invalid ", offset,
8, 1, &(VXR.Offset[i]), 0, debug);
status = ReadIrType64 (fp, VXR.Offset[i], &irType);
if (status != CDF_OK) return status;
if (irType != VXR_ && irType != VVR_ && irType != CVVR_)
return QuitCDF ("CDF(VXR): entry value for offset is invalid ", offset,
8, 1, &(VXR.Offset[i]), 0, debug);
if (irType == VXR_ && VXR.Offset[i] != offset) {
status = ValidateVXR (fp, VXR.Offset[i], lastRec, debug);
if (status != CDF_OK) return status;
}
}
return CDF_OK;
}
CDFstatus ValidateAttributeLinks (struct CDFstruct *CDF, vFILE *fp,
Logical debug)
{
CDFstatus status;
OFF_T offset, nextADR, AgrEDRhead, AzEDRhead;
Int32 num, numgrEntries, maxgrEntry, numzEntries, maxzEntry, scope;
int ix, *visit;
visit = (int *) cdf_AllocateMemory (GDR.NumAttr * sizeof(Int32), NULL);
if (visit == NULL) return BAD_MALLOC;
for (ix = 0; ix < GDR.NumAttr; ++ix)
visit[ix] = 0;
offset = GDR.ADRhead;
for (ix = 0; ix < GDR.NumAttr; ++ix) {
status = ValidateADR (CDF, fp, offset, debug);
if (status != CDF_OK) {
cdf_FreeMemory (visit, NULL);
return status;
}
status = ReadADR64 (fp, offset,
ADR_NUM, &num,
ADR_ADRNEXT, &nextADR,
ADR_AgrEDRHEAD, &AgrEDRhead,
ADR_NgrENTRIES, &numgrEntries,
ADR_MAXgrENTRY, &maxgrEntry,
ADR_AzEDRHEAD, &AzEDRhead,
ADR_NzENTRIES, &numzEntries,
ADR_MAXzENTRY, &maxzEntry,
ADR_NULL);
if (numgrEntries > 0) {
status = ValidateAttributeEntryLink (CDF, fp, num, FALSE, AgrEDRhead,
numgrEntries, maxgrEntry, debug);
if (status != CDF_OK) {
cdf_FreeMemory (visit, NULL);
return status;
}
}
if (numzEntries > 0) {
status = ValidateAttributeEntryLink (CDF, fp, num, TRUE, AzEDRhead,
numzEntries, maxzEntry, debug);
if (status != CDF_OK) {
cdf_FreeMemory (visit, NULL);
return status;
}
}
visit[num] = 1;
offset = nextADR;
}
for (ix = 0; ix < GDR.NumAttr; ++ix) {
if (visit[ix] == 0) {
cdf_FreeMemory (visit, NULL);
return QuitCDF ("CDF: an attribute unreachable in attribute link: ",
4, 1, &ix, 0, debug);
}
}
cdf_FreeMemory (visit, NULL);
return CDF_OK;
}
CDFstatus ValidateCVVR (vFILE *fp, Int32 offset, Logical debug)
{
struct CVVRstruct CVVR;
CDFstatus status;
if (debug)
printf(" Checking CVVR...@%d\n", (int) offset);
status = ReadCVVR (fp, offset,
CVVR_RECORDx, &CVVR,
CVVR_NULL);
if (status != CDF_OK) return status;
if (CVVR.RecordSize < CVVR_BASE_SIZE)
return QuitCDF ("CDF: record size is invalid ",
4, 1, &(CVVR.RecordSize), 0, debug);
if (CVVR.cSize < 0)
return QuitCDF ("CDF: uncompressed records size is invalid ",
4, 1, &(CVVR.cSize), 0, debug);
return CDF_OK;
}
CDFstatus ValidateVVR (vFILE *fp, Int32 offset, Logical debug)
{
struct VVRstruct VVR;
CDFstatus status;
if (debug)
printf(" Checking VVR...@%d\n", (int) offset);
status = ReadVVR (fp, offset,
VVR_RECORDx, &VVR,
VVR_NULL);
if (status != CDF_OK) return status;
if (VVR.RecordType != VVR_)
return QuitCDF ("CDF: record type is invalid ",
4, 1, &(VVR.RecordType), 0, debug);
if (VVR.RecordSize < VVR_BASE_SIZE)
return QuitCDF ("CDF: record size is invalid for Variable Value Record",
4, 1, &(VVR.RecordSize), 0, debug);
return CDF_OK;
}
CDFstatus ValidateCDR (vFILE *fp, OFF_T offset, Logical debug)
{
Int32 actualEncoding;
/*
char copyRight[CDF_COPYRIGHT_LEN+1];
*/
int i;
CDFstatus status;
if (debug)
#if defined(win32)
printf(" Checking CDR...@%I64d\n", offset);
#else
printf(" Checking CDR...@%lld\n", offset);
#endif
status = ReadCDR64 (fp, offset,
CDR_RECORD, &CDR, NULL,
CDR_NULL);
if (status != CDF_OK) return status;
if (CDR.RecordType != CDR_)
return QuitCDF ("CDF: record type is invalid ",
4, 1, &(CDR.RecordType), 0, debug);
if (CDR.RecordSize < CDR_BASE_SIZE64 ||
CDR.RecordSize > CDR_MAX_SIZE64)
return QuitCDF ("CDF: record size is invalid ",
8, 1, &(CDR.RecordSize), 0, debug);
if (CDR.GDRoffset < 1)
return QuitCDF ("CDF: offset to GDR is invalid ",
8, 1, &(CDR.GDRoffset), 0, debug);
if (CDR.Version != 3)
return QuitCDF ("CDF: version number is invalid ",
4, 1, &(CDR.Version), 0, debug);
if (!ValidEncoding(CDR.Encoding,&actualEncoding))
return QuitCDF ("CDF: encoding is invalid ",
4, 1, &(CDR.Encoding), 0, debug);
/*
for (i = 0; i < strlen(copyRight); ++i)
if (!Printable(copyRight[i]))
return QuitCDF ("CDF: copyright is invalid ", 0, 1, copyRight, 0, debug);
*/
return CDF_OK;
}
static CDFstatus ValidateGDR (vFILE *fp, OFF_T offset, Logical debug)
{
int i;
CDFstatus status;
if (debug)
#if defined(win32) || defined(__MINGW32__)
printf(" Checking GDR...@%I64d\n", offset);
#else
printf(" Checking GDR...@%lld\n", offset);
#endif
status = ReadGDR64 (fp, offset,
GDR_RECORD, &GDR,
GDR_NULL);
if (status != CDF_OK) return status;
if (GDR.RecordType != GDR_)
return QuitCDF ("CDF(GDR): record type is invalid ", offset,
4, 1, &(GDR.RecordType), 0, debug);
if (GDR.RecordSize < GDR_BASE_SIZE64 ||
GDR.RecordSize > GDR_MAX_SIZE64)
return QuitCDF ("CDF(GDR): record size is invalid ", offset,
8, 1, &(GDR.RecordSize), 0, debug);
if (GDR.NrVars < 0 || (GDR.NrVars > 0 && GDR.rVDRhead < 1))
return QuitCDF ("CDF(GDR): NrVars or their link is invalid ", offset,
4, 1, &(GDR.NrVars), 0, debug);
if (GDR.NumAttr < 0 || (GDR.NumAttr > 0 && GDR.ADRhead < 1))
return QuitCDF ("CDF(GDR): number of attributes or their link is invalid ", offset,
4, 1, &(GDR.NumAttr), 0, debug);
if (GDR.rMaxRec < -1)
return QuitCDF ("CDF(GDR): max rVars record is invalid ", offset,
4, 1, &(GDR.rMaxRec), 0, debug);
if (GDR.rNumDims < 0 || GDR.rNumDims > CDF_MAX_DIMS)
return QuitCDF ("CDF(GDR): number of dimensions for rVars is invalid ", offset,
4, 1, &(GDR.rNumDims), 0, debug);
if (GDR.NzVars < 0 || (GDR.NzVars > 0 && GDR.zVDRhead < 1))
return QuitCDF ("CDF(GDR): NzVars or their link is invalid ", offset,
4, 1, &(GDR.NzVars), 0, debug);
if (GDR.UIRhead < 0)
return QuitCDF ("CDF(GDR): offset to UIR is invalid ", offset,
8, 1, &(GDR.UIRhead), 0, debug);
for (i = 0; i < (int)GDR.rNumDims; ++i)
if (GDR.rDimSizes[i] < 1)
return QuitCDF ("CDF(GDR): dimensional size is invalid ", offset,
4, 1, &(GDR.rDimSizes[i]), 0, debug);
return CDF_OK;
}
CDFstatus ValidateCDR (vFILE *fp, Int32 offset, Logical debug)
{
Int32 actualEncoding;
/*
char copyRight[CDF_COPYRIGHT_LEN+1];
*/
int i;
CDFstatus status;
if (debug)
printf(" Checking CDR...@%d\n", (int) offset);
status = ReadCDR (fp, offset,
CDR_RECORD, &CDR, NULL,
CDR_NULL);
if (status != CDF_OK) return status;
if (CDR.RecordType != CDR_)
return QuitCDF ("CDF: record type is invalid ",
4, 1, &(CDR.RecordType), 0, debug);
if (CDR.RecordSize < CDR_BASE_SIZE ||
(!PriorTo("2.5",CDR.Version,CDR.Release,CDR.Increment) &&
CDR.RecordSize > CDR_MAX_SIZE))
return QuitCDF ("CDF: record size is invalid ",
4, 1, &(CDR.RecordSize), 0, debug);
if (CDR.GDRoffset < 1)
return QuitCDF ("CDF: offset to GDR is invalid ",
4, 1, &(CDR.GDRoffset), 0, debug);
if (CDR.Version != 2)
return QuitCDF ("CDF: version number is invalid ",
4, 1, &(CDR.Version), 0, debug);
if (!ValidEncoding(CDR.Encoding,&actualEncoding))
return QuitCDF ("CDF: encoding is invalid ",
4, 1, &(CDR.Encoding), 0, debug);
/*
for (i = 0; i < strlen(copyRight); ++i)
if (!Printable(copyRight[i]))
return QuitCDF ("CDF: copyright is invalid ",
0, copyRight), 0, debug);
*/
return CDF_OK;
}
CDFstatus ValidateSPR (vFILE *fp, Int32 offset, Logical debug)
{
struct SPRstruct SPR;
CDFstatus status;
if (debug)
printf(" Checking SPR...@%d\n", (int) offset);
status = ReadSPR (fp, offset,
SPR_RECORD, &SPR,
SPR_NULL);
if (status != CDF_OK) return status;
if (SPR.RecordType != SPR_)
return QuitCDF ("CDF: record type is invalid ",
4, 1, &(SPR.RecordType), 0, debug);
if (SPR.RecordSize != (SPR_BASE_SIZE + SPR.pCount * sizeof(Int32)))
return QuitCDF ("CDF: record size is invalid ",
4, 1, &(SPR.RecordSize), 0, debug);
if (SPR.pCount < 1 || SPR.pCount > CDF_MAX_PARMS)
return QuitCDF ("CDF: sparseness parameter count is invalid ",
4, 1, &(SPR.pCount), 0, debug);
return CDF_OK;
}
CDFstatus ValidateGDR (vFILE *fp, Int32 offset, Logical debug)
{
int i;
CDFstatus status;
if (debug)
printf(" Checking GDR...@%d\n", (int) offset);
status = ReadGDR (fp, offset,
GDR_RECORD, &GDR,
GDR_NULL);
if (status != CDF_OK) return status;
if (GDR.RecordType != GDR_)
return QuitCDF ("CDF: record type is invalid ",
4, 1, &(GDR.RecordType), 0, debug);
if (GDR.RecordSize < GDR_BASE_SIZE ||
GDR.RecordSize > GDR_MAX_SIZE)
return QuitCDF ("CDF: record size is invalid ",
4, 1, &(GDR.RecordSize), 0, debug);
if (GDR.NrVars < 0 || (GDR.NrVars > 0 && GDR.rVDRhead < 1))
return QuitCDF ("CDF: NrVars or their link is invalid ",
4, 1, &(GDR.NrVars), 0, debug);
if (GDR.NumAttr < 0 || (GDR.NumAttr > 0 && GDR.ADRhead < 1))
return QuitCDF ("CDF: attribute numbers or their link is invalid ",
4, 1, &(GDR.NumAttr), 0, debug);
if (GDR.rMaxRec < -1)
return QuitCDF ("CDF: max rVars record is invalid ",
4, 1, &(GDR.rMaxRec), 0, debug);
if (GDR.rNumDims < 0 ||
GDR.rNumDims > CDF_MAX_DIMS)
return QuitCDF ("CDF: number of dimensions for rVars is invalid ",
4, 1, &(GDR.rNumDims), 0, debug);
if (GDR.NzVars < 0 || (GDR.NzVars > 0 && GDR.zVDRhead < 1))
return QuitCDF ("CDF: NzVars or their link is invalid ",
4, 1, &(GDR.NzVars), 0, debug);
if (GDR.UIRhead < 0)
return QuitCDF ("CDF: offset to UIR is invalid ",
4, 1, &(GDR.UIRhead), 0, debug);
for (i = 0; i < (int)GDR.rNumDims; ++i)
if (GDR.rDimSizes[i] < 1)
return QuitCDF ("CDF: dimensional size is invalid ",
4, 1, &(GDR.rDimSizes[i]), 0, debug);
return CDF_OK;
}
static CDFstatus ValidateCVVR (vFILE *fp, OFF_T offset, Logical debug)
{
struct CVVRstruct64 CVVR;
CDFstatus status;
if (debug)
#if defined(win32) || defined(__MINGW32__)
printf(" Checking CVVR...@%I64d\n", offset);
#else
printf(" Checking CVVR...@%lld\n", offset);
#endif
status = ReadCVVR64 (fp, offset,
CVVR_RECORDx, &CVVR,
CVVR_NULL);
if (status != CDF_OK) return status;
if (CVVR.RecordSize < CVVR_BASE_SIZE64)
return QuitCDF ("CDF(CVVR): record size is invalid ", offset,
8, 1, &(CVVR.RecordSize), 0, debug);
if (CVVR.cSize < 0)
return QuitCDF ("CDF(CVVR): uncompressed records size is invalid ", offset,
8, 1, &(CVVR.cSize), 0, debug);
return CDF_OK;
}
static CDFstatus ValidateVVR (vFILE *fp, OFF_T offset, Logical debug)
{
struct VVRstruct64 VVR;
CDFstatus status;
if (debug)
#if defined(win32) || defined(__MINGW32__)
printf(" Checking VVR...@%I64d\n", offset);
#else
printf(" Checking VVR...@%lld\n", offset);
#endif
status = ReadVVR64 (fp, offset,
VVR_RECORDx, &VVR,
VVR_NULL);
if (status != CDF_OK) return status;
if (VVR.RecordType != VVR_)
return QuitCDF ("CDF(VVR): record type is invalid ", offset,
4, 1, &(VVR.RecordType), 0, debug);
if (VVR.RecordSize < VVR_BASE_SIZE64)
return QuitCDF ("CDF(VVR): record size is invalid ", offset,
8, 1, &(VVR.RecordSize), 0, debug);
return CDF_OK;
}
static CDFstatus ValidateCDR (vFILE *fp, OFF_T offset, Logical debug)
{
Int32 actualEncoding;
int i;
CDFstatus status;
if (debug)
#if defined(win32) || defined(__MINGW32__)
printf(" Checking CDR...@%I64d\n", offset);
#else
printf(" Checking CDR...@%lld\n", offset);
#endif
status = ReadCDR64 (fp, offset,
CDR_RECORD, &CDR, NULL,
CDR_NULL);
if (status != CDF_OK) return status;
if (CDR.RecordType != CDR_)
return QuitCDF ("CDF: record type is invalid ", offset,
4, 1, &(CDR.RecordType), 0, debug);
if (CDR.RecordSize < CDR_BASE_SIZE64 ||
CDR.RecordSize > CDR_MAX_SIZE64)
return QuitCDF ("CDF: record size is invalid ", offset,
8, 1, &(CDR.RecordSize), 0, debug);
if (CDR.GDRoffset < 1)
return QuitCDF ("CDF: offset to GDR is invalid ", offset,
8, 1, &(CDR.GDRoffset), 0, debug);
if (CDR.Version != 3)
return QuitCDF ("CDF: version number is invalid ", offset,
4, 1, &(CDR.Version), 0, debug);
if (CDR.Release < 0)
return QuitCDF ("CDF: release number is invalid ", offset,
4, 1, &(CDR.Release), 0, debug);
if (CDR.Increment < 0)
return QuitCDF ("CDF: increment number is invalid ", offset,
4, 1, &(CDR.Increment), 0, debug);
if (!ValidEncoding(CDR.Encoding,&actualEncoding))
return QuitCDF ("CDF: encoding is invalid ", offset,
4, 1, &(CDR.Encoding), 0, debug);
return CDF_OK;
}
int main () {
CDFid id;
CDFstatus status;
long varnum;
long variance = { VARY };
long dimSizes[1] = {0}, dimVary[1] = {VARY};
long indices[1] = {0}, counts[1]= {1}, intervals[1] = {1};
long long tt2000[8], mm[8];
double year1=2008, month1=12, day1=31, hour1=23, minute1=59, second1=57,
msec1=100, usec1=200, nsec1=300;
double year=2008, month=12, day=31, hour=23, minute=59, second=57,
msec=100, usec=200, nsec=300;
double yearOut, monthOut, dayOut, hourOut, minuteOut, secondOut, msecOut,
usecOut, nsecOut;
int ix;
char string[TT2000_3_STRING_LEN+1];
long long int8[3][2], int8o[3][2], nn;
/******************************************************************************
* Display title.
******************************************************************************/
printf ("Testing Internal/C interface for CDF_TIME_TT2000 ...\n");
tt2000[0] = computeTT2000 (2000., 1., 1., 12., 0., 0., TT2000END);
breakdownTT2000 (tt2000[0], &yearOut, &monthOut, &dayOut, &hourOut, &minuteOut,
&secondOut, &msecOut, &usecOut, &nsecOut);
printf ("Base: 2000-01-01T12:00.00.000 => %lld nanoseconds\n", tt2000[0]);
encodeTT2000 (tt2000[0], string, 3);
printf (" %lld => %s\n", tt2000[0], string);
/******************************************************************************
* Create CDF.
******************************************************************************/
status = CDFlib (CREATE_, CDF_, "TEST", 0, dimSizes, &id,
NULL_);
if (status < CDF_OK) {
if (status == CDF_EXISTS) {
status = CDFlib (OPEN_, CDF_, "TEST", &id,
NULL_);
if (status < CDF_OK) QuitCDF ("1.0", status);
status = CDFlib (DELETE_, CDF_,
NULL_);
if (status < CDF_OK) QuitCDF ("1.1", status);
status = CDFlib (CREATE_, CDF_, "TEST", 0L, dimSizes, &id,
NULL_);
if (status < CDF_OK) QuitCDF ("6.0", status);
}
}
/******************************************************************************
* Create variables.
******************************************************************************/
status = CDFlib (CREATE_, zVAR_, "myTT2000", CDF_TIME_TT2000, 1L,
0L, dimSizes, variance,
dimVary, &varnum,
NULL_);
if (status < CDF_OK) QuitCDF ("7.0", status);
dimSizes[0] = 2;
status = CDFlib (CREATE_, zVAR_, "myINT8", CDF_INT8, 1L,
1L, dimSizes, variance,
dimVary, &varnum,
NULL_);
if (status < CDF_OK) QuitCDF ("7.1", status);
/******************************************************************************
* PUT to variables.
******************************************************************************/
tt2000[0] = computeTT2000 (year, month, day, hour, minute, second,
msec, usec, nsec);
if (tt2000[0] == ILLEGAL_TT2000_VALUE) QuitCDF ("9.0", TT2000_TIME_ERROR);
for (ix = 1; ix < 8; ++ix)
tt2000[ix] = tt2000[0] + (long long) ix*1000000000;
varnum = CDFgetVarNum (id, "myTT2000");
status = CDFlib (SELECT_, zVAR_, varnum,
zVAR_RECNUMBER_, 0L,
zVAR_RECCOUNT_, 8L,
zVAR_RECINTERVAL_, 1L,
zVAR_DIMINDICES_, indices,
zVAR_DIMCOUNTS_, counts,
zVAR_DIMINTERVALS_, intervals,
PUT_, zVAR_HYPERDATA_, tt2000,
NULL_);
if (status < CDF_OK) QuitCDF ("10.0", status);
/******************************************************************************
* HyperGET from variables.
******************************************************************************/
status = CDFlib (GET_, zVAR_HYPERDATA_, mm,
NULL_);
if (status < CDF_OK) QuitCDF ("11.0", status);
for (ix= 0; ix < 8; ix++) {
breakdownTT2000 (mm[ix], &yearOut, &monthOut, &dayOut,
&hourOut, &minuteOut, &secondOut, &msecOut,
&usecOut, &nsecOut);
if (year != yearOut) QuitCDF("11.1", status);
if (month != monthOut) QuitCDF("11.2", status);
if (day != dayOut) QuitCDF("11.3", status);
if (hour != hourOut) QuitCDF("11.4", status);
if (minute != minuteOut) QuitCDF("11.5", status);
if (second != secondOut) QuitCDF("11.6", status);
if (msec != msecOut) QuitCDF("11.7", status);
if (usec != usecOut) QuitCDF("11.8", status);
if (nsec != nsecOut) QuitCDF("11.9", status);
++second;
if (second > 60) {
year = 2009;
month = 1;
day = 1;
hour = 0;
minute = 0;
second = 0;
}
}
varnum = CDFgetVarNum (id, "myINT8");
nn = 88888888888LL;
for (ix = 0; ix < 3; ++ix) {
int8[ix][0] = nn;
int8[ix][1] = -nn;
++nn;
}
counts[0] = 2;
status = CDFlib (SELECT_, zVAR_, varnum,
zVAR_RECNUMBER_, 0L,
zVAR_RECCOUNT_, 3L,
zVAR_RECINTERVAL_, 1L,
zVAR_DIMINDICES_, indices,
zVAR_DIMCOUNTS_, counts,
zVAR_DIMINTERVALS_, intervals,
PUT_, zVAR_HYPERDATA_, int8,
NULL_);
if (status < CDF_OK) QuitCDF ("12.0", status);
status = CDFlib (GET_, zVAR_HYPERDATA_, int8o,
NULL_);
if (status < CDF_OK) QuitCDF ("13.0", status);
nn = 88888888888LL;
for (ix = 0; ix < 3; ++ix) {
if (int8o[ix][0] != nn) QuitCDF ("14.0", status);;
if (int8o[ix][1] != -nn) QuitCDF ("14.1", status);;
++nn;
}
/******************************************************************************
* Close CDF.
******************************************************************************/
status = CDFlib (CLOSE_, CDF_,
NULL_);
if (status < CDF_OK) QuitCDF ("26.2", status);
/******************************************************************************
* Re-open the CDF.
******************************************************************************/
status = CDFlib (OPEN_, CDF_, "TEST", &id,
NULL_);
if (status < CDF_OK) QuitCDF ("30.1", status);
varnum = CDFvarNum (id, "myTT2000");
if (varnum < CDF_OK) QuitCDF ("31.1", status);
/******************************************************************************
* HyperGET from variables.
******************************************************************************/
status = CDFlib (SELECT_, zVAR_, varnum,
zVAR_RECNUMBER_, 0L,
zVAR_RECCOUNT_, 8L,
zVAR_RECINTERVAL_, 1L,
zVAR_DIMINDICES_, indices,
zVAR_DIMCOUNTS_, counts,
zVAR_DIMINTERVALS_, intervals,
GET_, zVAR_HYPERDATA_, mm,
NULL_);
if (status < CDF_OK) QuitCDF ("32.1", status);
for (ix= 0; ix < 8; ix++) {
breakdownTT2000 (mm[ix], &yearOut, &monthOut, &dayOut,
&hourOut, &minuteOut, &secondOut, &msecOut,
&usecOut, &nsecOut);
encodeTT2000 (mm[ix], string, 3);
printf ("%s\n",string);
if (year1 != yearOut) QuitCDF("33.1", status);
if (month1 != monthOut) QuitCDF("33.2", status);
if (day1 != dayOut) QuitCDF("33.3", status);
if (hour1 != hourOut) QuitCDF("33.4", status);
if (minute1 != minuteOut) QuitCDF("33.5", status);
if (second1 != secondOut) QuitCDF("33.6", status);
if (msec1 != msecOut) QuitCDF("33.7", status);
if (usec1 != usecOut) QuitCDF("33.8", status);
if (nsec1 != nsecOut) QuitCDF("33.9", status);
++second1;
if (second1 > 60) {
year1 = 2009;
month1 = 1;
day1 = 1;
hour1 = 0;
minute1 = 0;
second1 = 0;
}
}
/******************************************************************************
* Close CDF.
******************************************************************************/
status = CDFlib (CLOSE_, CDF_,
NULL_);
if (status < CDF_OK) QuitCDF ("26.2", status);
/******************************************************************************
* Successful completion.
******************************************************************************/
return EXIT_SUCCESS_;
}
CDFstatus ValidateADR (struct CDFstruct *CDF, vFILE *fp, Int32 offset,
Logical debug)
{
struct ADRstruct ADR;
CDFstatus status;
if (debug)
printf(" Checking ADR...@%d\n", (int) offset);
status = ReadADR (fp, offset,
ADR_RECORD, &ADR,
ADR_NULL);
if (status != CDF_OK) return status;
if (ADR.RecordType != ADR_)
return QuitCDF ("CDF: record type is invalid ",
4, 1, &(ADR.RecordType), 0, debug);
if (ADR.RecordSize < ADR_BASE_SIZE ||
ADR.RecordSize > ADR_MAX_SIZE)
return QuitCDF ("CDF: record size is invalid ",
4, 1, &(ADR.RecordSize), 0, debug);
if (ADR.ADRnext < 0 || ((ADR.Num < (GDR.NumAttr-1)) && ADR.ADRnext == 0))
return QuitCDF ("CDF: offset to next ADR is invalid ",
4, 1, &(ADR.ADRnext), 0, debug);
if (ADR.AgrEDRhead < 0 || (ADR.NgrEntries > 0 && ADR.AgrEDRhead == 0))
return QuitCDF ("CDF: record size is invalid ",
4, 1, &(ADR.AgrEDRhead), 0, debug);
/*
if ((ADR.Scope == GLOBAL_SCOPE) && (ADR.NzEntries > 0))
return QuitCDF ("CDF: attribute zEntries exist for a global attribute ",
4, 1, &(ADR.NzEntries), 0, debug);
*/
if (!ValidAttrScope(ADR.Scope))
return QuitCDF ("CDF: scope is invalid ",
4, 1, &(ADR.Scope), 0, debug);
if (ADR.Num < 0 || ADR.Num > GDR.NumAttr)
return QuitCDF ("CDF: attribute number is invalid ",
4, 2, &(ADR.Num), &(GDR.NumAttr), debug);
if (ADR.NgrEntries < 0)
return QuitCDF ("CDF: number of g/rEntries is invalid ",
4, 1, &(ADR.NgrEntries), 0, debug);
/*
if ((ADR.Scope == VARIABLE_SCOPE) && (ADR.NgrEntries > CDF->NrVars))
return QuitCDF ("CDF: number of rEntries is invalid ",
4, 1, &(ADR.NgrEntries), 0, debug);
*/
if (ADR.MAXgrEntry < -1)
return QuitCDF ("CDF: max g/rEntry is invalid ",
4, 1, &(ADR.MAXgrEntry), 0, debug);
if ((ADR.Scope == VARIABLE_SCOPE) && (ADR.MAXgrEntry < (ADR.NgrEntries-1)))
return QuitCDF ("CDF: max rEntry is invalid ",
4, 2, &(ADR.MAXgrEntry), &(ADR.NgrEntries), debug);
if (ADR.AzEDRhead < 0 || (ADR.NzEntries > 0 && ADR.AzEDRhead == 0))
return QuitCDF ("CD2: offset to next AzEDR is invalid ",
4, 1, &(ADR.AzEDRhead), 0, debug);
/*
if (ADR.NzEntries < 0 || ((ADR.Scope == VARIABLE_SCOPE) &&
(ADR.NzEntries > CDF->NzVars)))
return QuitCDF ("CDF: number of zEntries is invalid ",
4, 2, &(ADR.NzEntries), &(CDF->NzVars), debug);
if (ADR.MAXzEntry < -1 || ((ADR.Scope == VARIABLE_SCOPE) &&
(ADR.MAXzEntry > CDF->NzVars)))
return QuitCDF ("CDF: max zEntry is invalid ",
4, 2, &(ADR.MAXzEntry), &(CDF->NzVars), debug);
*/
if ((ADR.Scope == VARIABLE_SCOPE) && (ADR.MAXzEntry < (ADR.NzEntries-1)))
return QuitCDF ("CDF: max zEntry is invalid ",
4, 2, &(ADR.MAXzEntry), &(ADR.NzEntries), debug);
if (!ValidAttrName(ADR.Name))
return QuitCDF ("CDF: attribute name is invalid ",
0, 1, ADR.Name, 0, debug);
return CDF_OK;
}
CDFstatus ValidateAEDR (struct CDFstruct *CDF, vFILE *fp, Int32 offset,
Int32 num, Int32 maxEntry, Logical zEntry,
Logical debug)
{
struct AEDRstruct AEDR;
size_t nBytes;
CDFstatus status;
if (debug)
printf(" Checking AEDR...@%d\n", (int) offset);
status = ReadAEDR (fp, offset,
AEDR_RECORD, &AEDR, NULL,
AEDR_NULL);
if (status != CDF_OK) return status;
if ((!zEntry && AEDR.RecordType != AgrEDR_) ||
(zEntry && AEDR.RecordType != AzEDR_))
return QuitCDF ("CDF: record type is invalid ",
4, 1, &(AEDR.RecordType), 0, debug);
if (AEDR.RecordSize < AEDR_BASE_SIZE)
return QuitCDF ("CDF: record size is invalid ",
4, 1, &(AEDR.RecordSize), 0, debug);
if (AEDR.AEDRnext < 0)
return QuitCDF ("CDF: offset to next AEDR is invalid ",
4, 1, &(AEDR.AEDRnext), 0, debug);
/* Check for "AEDR.AttrNum != num" is not included as some CDFs fail this
check. Don't know why.... */
/* if (AEDR.AttrNum < 0 || AEDR.AttrNum > GDR.NumAttr || AEDR.AttrNum != num) */
/*
if (AEDR.AttrNum < 0 || AEDR.AttrNum > GDR.NumAttr)
return QuitCDF ("CDF: attribute number is invalid ",
4, 2, &(AEDR.AttrNum), &(GDR.NumAttr), debug);
*/
if (!ValidDataType(AEDR.DataType) || InValidDataType(AEDR.DataType))
return QuitCDF ("CDF: data type is invalid ",
4, 1, &(AEDR.DataType), 0, debug);
if (AEDR.Num < 0 || AEDR.Num > maxEntry)
return QuitCDF ("CDF: entry number is invalid ",
4, 2, &(AEDR.Num), &maxEntry, debug);
if (AEDR.AEDRnext < 0)
return QuitCDF ("CDF: next AEDR offset is invalid : ",
4, 1, &(AEDR.AEDRnext), 0, debug);
/*
if (zEntry && AEDR.EntryNum > GDR->NzVars)
return QuitCDF ("CDF: entry number is invalid ",
4, 2, &(AEDR.Num), &(GDR->NzVars), debug);
*/
if (AEDR.NumElems < 1 ||
(STRINGdataType(AEDR.DataType) &&
AEDR.NumElems > (AEDR.RecordSize - AEDR_VALUE_OFFSET)))
return QuitCDF ("CDF: number of elements is invalid ",
4, 1, &(AEDR.NumElems), 0, debug);
nBytes = (size_t) (CDFelemSize(AEDR.DataType) * AEDR.NumElems);
if (nBytes < 1 ||
nBytes > (AEDR.RecordSize - AEDR_VALUE_OFFSET))
return QuitCDF ("CDF: entry value size is invalid ",
4, 1, &nBytes, 0, debug);
if (AEDR.RecordSize > (AEDR_MAX_SIZE + nBytes))
return QuitCDF ("CDF: record size is invalid ",
4, 1, &(AEDR.RecordSize), 0, debug);
return CDF_OK;
}
CDFstatus ValidateVDR (struct CDFstruct *CDF, vFILE *fp, Int32 offset,
Logical zVar, Logical debug)
{
struct VDRstruct VDR;
void *padValue;
Int32 nDims, numVars;
int ix;
CDFstatus status;
size_t nBytes;
if (debug)
printf(" Checking VDR...@%d\n", (int) offset);
status = ReadVDR (CDF, fp, offset, zVar,
VDR_RECORD, &VDR, NULL,
VDR_NULL);
if (status != CDF_OK) return status;
if ((!zVar && VDR.RecordType != rVDR_) || (zVar && VDR.RecordType != zVDR_))
return QuitCDF ("CDF: record type is invalid ",
4, 1, &(VDR.RecordType), 0, debug);
if (VDR.RecordSize < (zVar ? zVDR_BASE_SIZE : rVDR_BASE_SIZE))
return QuitCDF ("CDF: record size is invalid ",
4, 1, &(VDR.RecordSize), 0, debug);
if (!ValidDataType(VDR.DataType) || InValidDataType(VDR.DataType))
return QuitCDF ("CDF: data type is invalid ",
4, 1, &(VDR.DataType), 0, debug);
if (VDR.MaxRec < -1)
return QuitCDF ("CDF: max record is invalid ",
4, 1, &(VDR.MaxRec), 0, debug);
if (VDR.NumElems < 1 || (!STRINGdataType(VDR.DataType) && VDR.NumElems != 1))
return QuitCDF ("CDF: number of elements is invalid ",
4, 1, &(VDR.NumElems), 0, debug);
if (zVar) numVars = CDF->NzVars;
else numVars = CDF->NrVars;
if (VDR.Num < 0 || VDR.Num > numVars)
return QuitCDF ("CDF: variable number is invalid ",
4, 2, &(VDR.Num), &numVars, debug);
if ((VDR.Num < (numVars-1)) && VDR.VDRnext < 1)
return QuitCDF ("CDF: offset to next VDR is invalid ",
4, 1, &(VDR.VDRnext), 0, debug);
if (VARcompressionBITset(VDR.Flags) && VDR.CPRorSPRoffset <= (int) NO_OFFSET)
return QuitCDF ("CDF: offset to CPRorSPR is invalid ",
4, 1, &(VDR.CPRorSPRoffset), 0, debug);
if (VDR.blockingFactor < 0)
return QuitCDF ("CDF: blocking factor is invalid ",
4, 1, &(VDR.blockingFactor), 0, debug);
if (!ValidVarName(VDR.Name))
return QuitCDF ("CDF: variable name is invalid ",
0, 1, VDR.Name, 0, debug);
if (zVar) {
if (VDR.zNumDims < 0 || VDR.zNumDims > CDF_MAX_DIMS)
return QuitCDF ("CDF: number of dimensions is invalid ",
4, 1, &(VDR.zNumDims), 0, debug);
for (ix = 0; ix < (int)VDR.zNumDims; ++ix)
if (VDR.zDimSizes[ix] < 1)
return QuitCDF ("CDF: dimensional size is invalid ",
4, 1, &(VDR.zDimSizes[ix]), 0, debug);
}
nBytes = (size_t) (CDFelemSize(VDR.DataType)*VDR.NumElems);
if (nBytes < 1)
return QuitCDF ("CDF: pad value size is invalid ",
4, 1, &nBytes, 0, debug);
if (VDR.RecordSize > ((zVar ? zVDR_MAX_SIZE : rVDR_MAX_SIZE) + nBytes +
(CDF->wastedSpace ? VDR_WASTED_SIZE : 0)))
return QuitCDF ("CDF: record size is invalid ",
4, 1, &(VDR.RecordSize), 0, debug);
return CDF_OK;
}
static CDFstatus ValidateVariableLinks (struct CDFstruct *CDF, vFILE *fp,
Logical zVar, Logical debug)
{
CDFstatus status;
OFF_T offset, headVXR, tailVXR, nextVXR, nextVDR, cprOffset;
Int32 num, lastRec, flags;
int ix, numVars, *visit;
numVars = (zVar ? GDR.NzVars : GDR.NrVars);
visit = (int *) cdf_AllocateMemory(numVars * sizeof(Int32), NULL);
for (ix = 0; ix < numVars; ++ix) visit[ix] = 0;
offset = (zVar ? GDR.zVDRhead : GDR.rVDRhead);
for (ix = 0; ix < numVars; ++ix) {
status = ValidateVDR (CDF, fp, offset, zVar, debug);
if (status != CDF_OK) {
cdf_FreeMemory (visit, NULL);
return status;
}
status = ReadVDR64 (CDF, fp, offset, zVar,
VDR_NUM, &num,
VDR_FLAGS, &flags,
VDR_MAXREC, &lastRec,
VDR_VDRNEXT, &nextVDR,
VDR_CPRorSPR, &cprOffset,
VDR_VXRHEAD, &headVXR,
VDR_VXRTAIL, &tailVXR,
VDR_NULL);
if (CDF->singleFile && lastRec > -1) {
status = ValidateVariableValueLinks (CDF, fp, lastRec, headVXR, debug);
if (status != CDF_OK) {
cdf_FreeMemory (visit, NULL);
return status;
}
}
if (VARcompressionBITset(flags)) {
status = ValidateCPR (fp, cprOffset, debug);
if (status != CDF_OK) {
cdf_FreeMemory (visit, NULL);
return status;
}
}
visit[num] = 1;
offset = nextVDR;
}
for (ix = 0; ix < numVars; ++ix) {
if (visit[ix] == 0) {
cdf_FreeMemory (visit, NULL);
if (zVar)
return QuitCDF ("CDF: a zVariable unreachable in the variable chain: ", (OFF_T) -1,
4, 1, &ix, 0, debug);
else
return QuitCDF ("CDF: a rVariable unreachable in the variable chain: ", (OFF_T) -1,
4, 1, &ix, 0, debug);
}
}
cdf_FreeMemory (visit, NULL);
if (offset != 0) {
status = ReadVDR64 (CDF, fp, offset, zVar,
VDR_NUM, &num,
VDR_VDRNEXT, &nextVDR,
VDR_NULL);
if (status == CDF_OK) {
if (num >= numVars) {
if (zVar)
return QuitCDF ("CDF(VDR): a zVariable unreachable in the variable chain: ", offset,
4, 1, &num, 0, debug);
else
return QuitCDF ("CDF(VDR): a rVariable unreachable in the variable chain: ", offset,
4, 1, &num, 0, debug);
} else {
if (zVar)
return QuitCDF ("CDF(VDR): a zVariable is repeated in the variable chain: ", offset,
4, 1, &num, 0, debug);
else
return QuitCDF ("CDF(VDR): a rVariable unreachable in the variable chain: ", offset,
4, 1, &num, 0, debug);
}
}
}
return CDF_OK;
}
STATICforIDL CDFstatus ValidateCDF64 (struct CDFstruct *CDF, vFILE *CDFfp,
OFF_T offset, OFF_T fileSize64,
Logical debug)
{
OFF_T recordSize;
Int32 recordType;
CDFstatus status;
/****************************************************************************
* Read internal records from beginning of the file until EOF (or illegal
* record) reached.
****************************************************************************/
if (!SEEKv64(CDFfp,offset,vSEEK_SET)) return CRE;
for (;;) {
/*************************************************************************
* Read record size.
*************************************************************************/
offset = V_tell64 (CDFfp);
if (offset == fileSize64) break;
if (!Read64_64(CDFfp,&recordSize)) return CRE;
if (recordSize < 1 || recordSize > fileSize64)
return QuitCDF ("CDF: an invalid internal record size ", offset,
8, 1, &recordSize, 0, debug);
/*************************************************************************
* Read record type.
*************************************************************************/
if (!Read32_64(CDFfp,&recordType)) return CRE;
/*************************************************************************
* Based on the record type...
*************************************************************************/
switch ((int)recordType) {
/**********************************************************************
* Compressed CDF Record (CCR).
**********************************************************************/
case CCR_: {
offset = offset + recordSize;
if (!SEEKv64(CDFfp,offset,vSEEK_SET)) return CRE;
break;
}
/**********************************************************************
* CDF Descriptor Record (CDR).
**********************************************************************/
case CDR_: {
numAttrs = rVars = zVars = 0;
status = ValidateCDR (CDFfp, offset, debug);
if (status != CDF_OK) return status;
status = ValidateGDR (CDFfp, CDR.GDRoffset, debug);
if (status != CDF_OK) return status;
offset = offset + recordSize;
if (!SEEKv64(CDFfp,offset,vSEEK_SET)) return CRE;
break;
}
/**********************************************************************
* Global Descriptor Record (GDR).
**********************************************************************/
case GDR_: {
offset = offset + recordSize;
if (!SEEKv64(CDFfp,offset,vSEEK_SET)) return CRE;
break;
}
/**********************************************************************
* Attribute Descriptor Record (ADR).
**********************************************************************/
case ADR_: {
++numAttrs;
offset = offset + recordSize;
if (!SEEKv64(CDFfp,offset,vSEEK_SET)) return CRE;
break;
}
/**********************************************************************
* Attribute Entry Descriptor Record (AgrEDR or AzEDR).
**********************************************************************/
case AgrEDR_:
case AzEDR_: {
Logical zEntry = (recordType == AzEDR_);
offset = offset + recordSize;
if (!SEEKv64(CDFfp,offset,vSEEK_SET)) return CRE;
break;
}
/**********************************************************************
* Variable Descriptor Record (rVDR or zVDR).
**********************************************************************/
case rVDR_:
case zVDR_: {
Logical zVar = (recordType == zVDR_);
if (zVar) {
++zVars;
} else {
++rVars;
}
offset = offset + recordSize;
if (!SEEKv64(CDFfp,offset,vSEEK_SET)) return CRE;
break;
}
/**********************************************************************
* Variable indeX Record (VXR).
**********************************************************************/
case VXR_: {
offset = offset + recordSize;
if (!SEEKv64(CDFfp,offset,vSEEK_SET)) return CRE;
break;
}
/**********************************************************************
* Variable Values Record (VVR).
**********************************************************************/
case VVR_: {
status = ValidateVVR (CDFfp, offset, debug);
if (status != CDF_OK) return status;
if (recordSize < VVR_BASE_SIZE64)
return QuitCDF ("CDF(VVR): record size is invalid ", offset,
8, 1, &recordSize, 0, debug);
offset = offset + recordSize;
if (!SEEKv64(CDFfp,offset,vSEEK_SET)) return CRE;
break;
}
/**********************************************************************
* Compressed Variable Values Record (CVVR).
**********************************************************************/
case CVVR_: {
status = ValidateCVVR (CDFfp, offset, debug);
if (status != CDF_OK) return status;
offset = offset + recordSize;
if (!SEEKv64(CDFfp,offset,vSEEK_SET)) return CRE;
break;
}
/**********************************************************************
* Compressed Parameters Record (CPR).
**********************************************************************/
case CPR_: {
offset = offset + recordSize;
if (!SEEKv64(CDFfp,offset,vSEEK_SET)) return CRE;
break;
}
/**********************************************************************
* Sparseness Parameters Record (SPR).
**********************************************************************/
case SPR_: {
offset = offset + recordSize;
if (!SEEKv64(CDFfp,offset,vSEEK_SET)) return CRE;
break;
}
/**********************************************************************
* Unused internal record
**********************************************************************/
case UIR_: {
offset = offset + recordSize;
if (!SEEKv64(CDFfp,offset,vSEEK_SET)) return CRE;
break;
}
/**********************************************************************
* Illegal record type.
**********************************************************************/
default: {
return QuitCDF ("CDF: an invalid internal record type", offset,
4, 1, &recordType, 0, debug);
}
}
}
/****************************************************************************
* Check attribute links and their attribute entries.
****************************************************************************/
if (GDR.NumAttr != numAttrs)
return QuitCDF ("CDF: number of attributes does not match: ", (OFF_T) -1,
4, 2, &GDR.NumAttr, &numAttrs, debug);
if (numAttrs > 0) {
status = ValidateAttributeLinks(CDF, CDFfp, debug);
if (status != CDF_OK) return status;
}
/****************************************************************************
* Check rVariable links and their data.
****************************************************************************/
if (GDR.NrVars != rVars)
return QuitCDF ("CDF: number of rVariables does not match: ", (OFF_T) -1,
4, 2, &GDR.NrVars, &rVars, debug);
if (rVars > 0) {
status = ValidateVariableLinks(CDF, CDFfp, FALSE, debug);
if (status != CDF_OK) return status;
}
/****************************************************************************
* Check zVariable links and their data.
****************************************************************************/
if (GDR.NzVars != zVars)
return QuitCDF ("CDF: number of zVariables does not match: ", (OFF_T) -1,
4, 2, &GDR.NzVars, &zVars, debug);
if (zVars > 0) {
status = ValidateVariableLinks(CDF, CDFfp, TRUE, debug);
if (status != CDF_OK) return status;
}
return CDF_OK;
}
static CDFstatus ValidateVDR (struct CDFstruct *CDF, vFILE *fp, OFF_T offset,
Logical zVar, Logical debug)
{
struct VDRstruct64 VDR;
void *padValue;
Int32 nDims, numVars;
int ix;
CDFstatus status;
size_t nBytes;
if (debug)
#if defined(win32) || defined(__MINGW32__)
printf(" Checking VDR...@%I64d\n", offset);
#else
printf(" Checking VDR...@%lld\n", offset);
#endif
status = ReadVDR64 (CDF, fp, offset, zVar,
VDR_RECORD, &VDR, NULL,
VDR_NULL);
if (status != CDF_OK) return status;
if ((zVar && VDR.RecordType != zVDR_) || (!zVar && VDR.RecordType != rVDR_))
return QuitCDF ("CDF(VDR): record type is invalid ", offset,
4, 1, &(VDR.RecordType), 0, debug);
if (VDR.RecordSize < (zVar ? zVDR_BASE_SIZE64 : rVDR_BASE_SIZE64))
return QuitCDF ("CDF(VDR): record size is invalid ", offset,
8, 1, &(VDR.RecordSize), 0, debug);
if (!ValidDataType(VDR.DataType))
return QuitCDF ("CDF(VDR): data type is invalid ", offset,
4, 1, &(VDR.DataType), 0, debug);
if (VDR.MaxRec < -1)
return QuitCDF ("CDF(VDR): max record is invalid ", offset,
4, 1, &(VDR.MaxRec), 0, debug);
if (VDR.NumElems < 1 || (!STRINGdataType(VDR.DataType) && VDR.NumElems != 1))
return QuitCDF ("CDF(VDR): number of elements is invalid ", offset,
4, 1, &(VDR.NumElems), 0, debug);
if (zVar) numVars = CDF->NzVars;
else numVars = CDF->NrVars;
if (VDR.Num < 0 || VDR.Num > numVars)
return QuitCDF ("CDF(VDR): variable number is invalid ", offset,
4, 2, &(VDR.Num), &numVars, debug);
if ((VDR.Num < (numVars-1)) && (VDR.VDRnext < 1))
return QuitCDF ("CDF(VDR): offset to next VDR is invalid ", offset,
8, 1, &(VDR.VDRnext), 0, debug);
if (VARcompressionBITset(VDR.Flags) && VDR.CPRorSPRoffset <= NO_OFFSET64)
return QuitCDF ("CDF(VDR): offset to CPRorSPR is invalid ", offset,
8, 1, &(VDR.CPRorSPRoffset), 0, debug);
if (VDR.blockingFactor < 0)
return QuitCDF ("CDF(VDR): blocking factor is invalid ", offset,
4, 1, &(VDR.blockingFactor), 0, debug);
if (!ValidVarName(VDR.Name))
return QuitCDF ("CDF(VDR): variable name is invalid ", offset,
0, 1, VDR.Name, 0, debug);
if (zVar) {
if (VDR.zNumDims < 0 || VDR.zNumDims > CDF_MAX_DIMS)
return QuitCDF ("CDF(VDR): number of dimensions is invalid ", offset,
4, 1, &(VDR.zNumDims), 0, debug);
for (ix = 0; ix < (int)VDR.zNumDims; ++ix)
if (VDR.zDimSizes[ix] < 1)
return QuitCDF ("CDF(VDR): dimensional size is invalid ", offset,
4, 1, &(VDR.zDimSizes[ix]), 0, debug);
}
nBytes = (size_t) (CDFelemSize(VDR.DataType)*VDR.NumElems);
if (nBytes < 1)
return QuitCDF ("CDF(VDR): pad value size is invalid ", offset,
4, 1, &nBytes, 0, debug);
if (VDR.RecordSize > ((zVar ? zVDR_MAX_SIZE64 : rVDR_MAX_SIZE64) + nBytes))
return QuitCDF ("CDF(VDR): record size is invalid ", offset,
8, 1, &(VDR.RecordSize), 0, debug);
return CDF_OK;
}
static CDFstatus ValidateADR (struct CDFstruct *CDF, vFILE *fp, OFF_T offset,
Logical debug)
{
struct ADRstruct64 ADR;
CDFstatus status;
if (debug)
#if defined(win32) || defined(__MINGW32__)
printf(" Checking ADR...@%I64d\n", offset);
#else
printf(" Checking ADR...@%lld\n", offset);
#endif
status = ReadADR64 (fp, offset,
ADR_RECORD, &ADR,
ADR_NULL);
if (status != CDF_OK) return status;
if (ADR.RecordType != ADR_)
return QuitCDF ("CDF(ADR): record type is invalid ", offset,
4, 1, &(ADR.RecordType), 0, debug);
if (ADR.RecordSize < ADR_BASE_SIZE64 ||
ADR.RecordSize > ADR_MAX_SIZE64)
return QuitCDF ("CDF(ADR): record size is invalid ", offset,
8, 1, &(ADR.RecordSize), 0, debug);
if (ADR.ADRnext < 0 || ((ADR.Num < (GDR.NumAttr-1)) && ADR.ADRnext == 0))
return QuitCDF ("CDF(ADR): offset to next ADR is invalid ", offset,
8, 1, &(ADR.ADRnext), 0, debug);
if (ADR.AgrEDRhead < 0 || (ADR.NgrEntries > 0 && ADR.AgrEDRhead == 0))
return QuitCDF ("CDF(ADR): offset to AgrEDR is invalid ", offset,
8, 1, &(ADR.AgrEDRhead), 0, debug);
if (!ValidAttrScope(ADR.Scope))
return QuitCDF ("CDF(ADR): scope is invalid ", offset,
4, 1, &(ADR.Scope), 0, debug);
if (ADR.Num < 0 || ADR.Num > GDR.NumAttr)
return QuitCDF ("CDF(ADR): attribute number is invalid ", offset,
4, 2, &(ADR.Num), &(GDR.NumAttr), debug);
if (ADR.NgrEntries < 0)
return QuitCDF ("CDF(ADR): number of g/rEntries is invalid ", offset,
4, 1, &(ADR.NgrEntries), 0, debug);
if (ADR.MAXgrEntry < -1)
return QuitCDF ("CDF(ADR): max g/rEntry is invalid ", offset,
4, 1, &(ADR.MAXgrEntry), 0, debug);
if ((ADR.Scope == VARIABLE_SCOPE) && (ADR.MAXgrEntry < (ADR.NgrEntries-1)))
return QuitCDF ("CDF(ADR): max rEntry is invalid ", offset,
4, 2, &(ADR.MAXgrEntry), &(ADR.NgrEntries), debug);
if (ADR.AzEDRhead < 0 || (ADR.NzEntries > 0 && ADR.AzEDRhead == 0))
return QuitCDF ("CDF(ADR): offset to next AzEDR is invalid ", offset,
8, 1, &(ADR.AzEDRhead), 0, debug);
if ((ADR.Scope == VARIABLE_SCOPE) && (ADR.MAXzEntry < (ADR.NzEntries-1)))
return QuitCDF ("CDF(ADR): max zEntry is invalid ", offset,
4, 2, &(ADR.MAXzEntry), &(ADR.NzEntries), debug);
if (!ValidAttrName(ADR.Name))
return QuitCDF ("CDF(ADR): attribute name is invalid ", offset,
0, 1, ADR.Name, 0, debug);
return CDF_OK;
}
