IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 14414


Ignore:
Timestamp:
Aug 6, 2007, 1:54:24 PM (19 years ago)
Author:
Paul Price
Message:

Fixing endian bug in psMetadataConfigParse:

Function parseMetadataItem declares tempInt and tempUint as 64-bit at
the top, and then parses values of various types. If the type is not
64- bit, it is converted to 64-bit and then passed to psMetadataAdd
which attempts to read the value at the lower precision. If the
endianness is wrong, then it will read the wrong value (as zero,
usually). Fix the problem by declaring the values as the appropriate
type.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/types/psMetadataConfig.c

    r14030 r14414  
    1111*  @author Joshua Hoblitt, University of Hawaii 2006-2007
    1212*
    13 *  @version $Revision: 1.137 $ $Name: not supported by cvs2svn $
    14 *  @date $Date: 2007-07-06 02:07:57 $
     13*  @version $Revision: 1.138 $ $Name: not supported by cvs2svn $
     14*  @date $Date: 2007-08-06 23:54:24 $
    1515*
    1616*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    678678    psS32                status        = 0;
    679679    psMetadata*          md            = NULL;
    680     psF64                tempDbl       = 0.0;
    681     bool               tempBool      = false;
    682     psS64                tempInt       = 0;
    683     psU64                tempUint      = 0;
    684     psVector*            tempVec       = NULL;
    685     char*                tempStr       = NULL;
    686680    psArray*             nonUniqueKeys = NULL;
    687681    psMetadata*          tempMeta      = NULL;
    688682    p_psParseLevelInfo*  nextLevelInfo = NULL;
    689     psTime *mTime;
    690     psTimeType timeType = PS_TIME_TAI;
    691683
    692684    long level = psArrayLength(levelArray) - 1;
    … …  
    845837    }
    846838
     839#define PARSE_ADD_CASE(NAME, TYPE, PARSEFUNC) \
     840  case PS_DATA_##NAME: { \
     841      ps##TYPE value = PARSEFUNC(strValue, &status); \
     842      if (!status) { \
     843          addStatus = psMetadataAdd##TYPE(md, PS_LIST_TAIL, keyName, flags, strComment, value); \
     844      } else { \
     845          psError(PS_ERR_IO, true, \
     846                  _("Failed to parse the value '%s' of metadata item %s, type %s."), \
     847                  strValue, keyName, strType); \
     848          returnValue = false; \
     849      } \
     850      break; \
     851  }
     852
    847853    // Need to add item to metadata so get pointer to metadata
    848854    status = 0;
    … …  
    850856    nonUniqueKeys = ((p_psParseLevelInfo*)(levelArray->data[level]))->nonUniqueKeyArray;
    851857    switch(mdType) {
    852     case PS_DATA_STRING:
    853         addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName,
    854                                   mdType | flags,
    855                                   strComment, strValue);
    856         break;
    857     case PS_DATA_BOOL:
    858         tempBool = parseBool(strValue, &status);
    859         if(!status) {
    860             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName,
    861                                       mdType | flags,
    862                                       strComment, tempBool);
    863         } else {
    864             psError(PS_ERR_IO, true,
    865                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
     858        PARSE_ADD_CASE(BOOL,   Bool,   parseBool);
     859        PARSE_ADD_CASE(F32,    F32,    parseDouble);
     860        PARSE_ADD_CASE(F64,    F64,    parseDouble);
     861        PARSE_ADD_CASE(S8,     S8,     parseSignedInt);
     862        PARSE_ADD_CASE(S16,    S16,    parseSignedInt);
     863        PARSE_ADD_CASE(S32,    S32,    parseSignedInt);
     864        PARSE_ADD_CASE(S64,    S64,    parseSignedInt);
     865        PARSE_ADD_CASE(U8,     U8,     parseUnsignedInt);
     866        PARSE_ADD_CASE(U16,    U16,    parseUnsignedInt);
     867        PARSE_ADD_CASE(U32,    U32,    parseUnsignedInt);
     868        PARSE_ADD_CASE(U64,    U64,    parseUnsignedInt);
     869      case PS_DATA_STRING:
     870        addStatus = psMetadataAddStr(md, PS_LIST_TAIL, keyName, flags, strComment, strValue);
     871        break;
     872      case PS_DATA_TIME: {
     873          psTimeType timeType = PS_TIME_TAI;
     874          if(!strncmp(strType, "UTC", 3)) {
     875              timeType = PS_TIME_UTC;
     876          } else if(!strncmp(strType, "TAI", 3)) {
     877              timeType = PS_TIME_TAI;
     878          } else if(!strncmp(strType, "UT1", 3)) {
     879              timeType = PS_TIME_UT1;
     880          } else if(!strncmp(strType, "TT", 3)) {
     881              timeType = PS_TIME_TT;
     882          }
     883
     884          psTime *mTime = parseTime(strValue, timeType, &status);
     885          if(!status) {
     886              addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName,
     887                                        mdType | flags,
     888                                        strComment, mTime);
     889          } else {
     890              psError(PS_ERR_IO, true,
     891                      _("Failed to parse the value '%s' of metadata item %s, type %s."),
    866892                      strValue, keyName, strType);
    867             returnValue = false;
    868         }
    869         break;
    870     case PS_DATA_F32:
    871     case PS_DATA_F64:
    872         tempDbl = parseDouble(strValue, &status);
    873         if(!status) {
    874             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName,
    875                                       mdType | flags,
    876                                       strComment, tempDbl);
    877         } else {
    878             psError(PS_ERR_IO, true,
    879                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
     893              returnValue = false;
     894          }
     895          psFree(mTime);
     896          break;
     897      }
     898      case PS_DATA_VECTOR: {
     899          psVector *tempVec = parseVector(strValue, vectorType, &status);
     900          if(!status) {
     901              addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName+1,
     902                                        mdType | flags,
     903                                        strComment, tempVec);
     904          } else {
     905              psError(PS_ERR_IO, true,
     906                      _("Failed to parse the value '%s' of metadata item %s, type %s."),
    880907                      strValue, keyName, strType);
    881             returnValue = false;
    882         }
    883         break;
    884     case PS_DATA_S8:
    885         tempInt = (psS8) parseSignedInt(strValue, &status);
    886         if(!status) {
    887             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags,
    888                                       strComment, tempInt);
    889         } else {
    890             psError(PS_ERR_IO, true,
    891                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
    892                     strValue, keyName, strType);
    893             returnValue = false;
    894         }
    895         break;
    896     case PS_DATA_S16:
    897         tempInt = (psS16) parseSignedInt(strValue, &status);
    898         if(!status) {
    899             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags,
    900                                       strComment, tempInt);
    901         } else {
    902             psError(PS_ERR_IO, true,
    903                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
    904                     strValue, keyName, strType);
    905             returnValue = false;
    906         }
    907         break;
    908     case PS_DATA_S32:
    909         tempInt = (psS32) parseSignedInt(strValue, &status);
    910         if(!status) {
    911             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags,
    912                                       strComment, tempInt);
    913         } else {
    914             psError(PS_ERR_IO, true,
    915                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
    916                     strValue, keyName, strType);
    917             returnValue = false;
    918         }
    919         break;
    920     case PS_DATA_S64:
    921         tempInt = (psS64) parseSignedInt(strValue, &status);
    922         if(!status) {
    923             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags,
    924                                       strComment, tempInt);
    925         } else {
    926             psError(PS_ERR_IO, true,
    927                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
    928                     strValue, keyName, strType);
    929             returnValue = false;
    930         }
    931         break;
    932     case PS_DATA_U8:
    933         tempUint = (psU8)parseUnsignedInt(strValue, &status);
    934         if(!status) {
    935             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags,
    936                                       strComment, tempUint);
    937         } else {
    938             psError(PS_ERR_IO, true,
    939                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
    940                     strValue, keyName, strType);
    941             returnValue = false;
    942         }
    943         break;
    944     case PS_DATA_U16:
    945         tempUint = (psU16)parseUnsignedInt(strValue, &status);
    946         if(!status) {
    947             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags,
    948                                       strComment, tempUint);
    949         } else {
    950             psError(PS_ERR_IO, true,
    951                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
    952                     strValue, keyName, strType);
    953             returnValue = false;
    954         }
    955         break;
    956     case PS_DATA_U32:
    957         tempUint = (psU32)parseUnsignedInt(strValue, &status);
    958         if(!status) {
    959             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags,
    960                                       strComment, tempUint);
    961         } else {
    962             psError(PS_ERR_IO, true,
    963                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
    964                     strValue, keyName, strType);
    965             returnValue = false;
    966         }
    967         break;
    968     case PS_DATA_U64:
    969         tempUint = (psU64)parseUnsignedInt(strValue, &status);
    970         if(!status) {
    971             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName, mdType | flags,
    972                                       strComment, tempUint);
    973         } else {
    974             psError(PS_ERR_IO, true,
    975                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
    976                     strValue, keyName, strType);
    977             returnValue = false;
    978         }
    979         break;
    980     case PS_DATA_TIME:
    981         if(!strncmp(strType, "UTC", 3)) {
    982             timeType = PS_TIME_UTC;
    983         } else if(!strncmp(strType, "TAI", 3)) {
    984             timeType = PS_TIME_TAI;
    985         } else if(!strncmp(strType, "UT1", 3)) {
    986             timeType = PS_TIME_UT1;
    987         } else if(!strncmp(strType, "TT", 3)) {
    988             timeType = PS_TIME_TT;
    989         }
    990 
    991         mTime = parseTime(strValue, timeType, &status);
    992         if(!status) {
    993             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName,
    994                                       mdType | flags,
    995                                       strComment, mTime);
    996         } else {
    997             psError(PS_ERR_IO, true,
    998                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
    999                     strValue, keyName, strType);
    1000             returnValue = false;
    1001         }
    1002         psFree(mTime);
    1003         break;
    1004     case PS_DATA_VECTOR:
    1005         tempVec = parseVector(strValue, vectorType, &status);
    1006         if(!status) {
    1007             addStatus = psMetadataAdd(md, PS_LIST_TAIL, keyName+1,
    1008                                       mdType | flags,
    1009                                       strComment, tempVec);
    1010         } else {
    1011             psError(PS_ERR_IO, true,
    1012                     _("Failed to parse the value '%s' of metadata item %s, type %s."),
    1013                     strValue, keyName, strType);
    1014             returnValue = false;
    1015         }
    1016         psFree(tempVec);
    1017         break;
     908              returnValue = false;
     909          }
     910          psFree(tempVec);
     911          break;
     912      }
    1018913    case PS_DATA_METADATA_MULTI:
    1019914        // Add key to non-unique array of keys
    … …  
    1027922            }
    1028923        }
    1029         tempStr = psStringCopy(keyName);
     924        psString tempStr = psStringCopy(keyName);
    1030925        nonUniqueKeys = psArrayAdd(nonUniqueKeys,0,tempStr);
    1031926        addStatus = true;
    … …  
    15471442        break;
    15481443      case PS_DATA_STRING: {
    1549           bool valid = false;
    1550           if (item->data.str && strlen(item->data.str) > 0) {
    1551               char *p = item->data.str;
    1552               while (*p && isblank(*p)) p++;
    1553               if (*p) valid = true;
    1554           }
    1555           if (valid) {
    1556               psStringAppend(&content, "%-15s  %-8s  %-15s",
    1557                              item->name, "STR", item->data.str);
    1558           } else {
    1559               psStringAppend(&content, "%-15s  %-8s  %-15s",
    1560                              item->name, "STR", "NULL");
    1561           }
    1562           if (item->comment && strncmp(item->comment,"",2)) {
    1563               psStringAppend(&content, "  # %s", item->comment);
    1564           }
    1565           psStringAppend(&content, " \n");
    1566           break;
     1444          bool valid = false;
     1445          if (item->data.str && strlen(item->data.str) > 0) {
     1446              char *p = item->data.str;
     1447              while (*p && isblank(*p)) p++;
     1448              if (*p) valid = true;
     1449          }
     1450          if (valid) {
     1451              psStringAppend(&content, "%-15s  %-8s  %-15s",
     1452                             item->name, "STR", item->data.str);
     1453          } else {
     1454              psStringAppend(&content, "%-15s  %-8s  %-15s",
     1455                             item->name, "STR", "NULL");
     1456          }
     1457          if (item->comment && strncmp(item->comment,"",2)) {
     1458              psStringAppend(&content, "  # %s", item->comment);
     1459          }
     1460          psStringAppend(&content, " \n");
     1461          break;
    15671462      }
    15681463    case PS_DATA_METADATA: {
Note: See TracChangeset for help on using the changeset viewer.