~ubuntu-branches/ubuntu/karmic/lcms/karmic-security

LCMSAPI LCMSBOOL        LCMSEXPORT cmsIT8SetPropertyMulti(LCMSHANDLE hIT8, const char* cProp, const char* cSubProp, const char *Val);

LCMSAPI const char*     LCMSEXPORT cmsIT8GetPropertyMulti(LCMSHANDLE hIT8, const char* cProp, const char *cSubProp);

LCMSAPI int             LCMSEXPORT cmsIT8EnumProperties(LCMSHANDLE IT8, const char ***PropertyNames);

LCMSAPI int             LCMSEXPORT cmsIT8EnumPropertyMulti(LCMSHANDLE hIT8, const char* cProp, const char*** SubpropertyNames);

#define MAXSTR      1024     // Max lenght of string

#define DIR_CHAR    '\\'

#define DIR_CHAR    '/'

        SDATA_FORMAT_ID,

        WRITE_BINARY,

        WRITE_PAIR

        struct _KeyVal*  NextSubkey;    // If key is a dictionary, points to the next item

        char*            Subkey;        // If key is a dictionary, points to the subkey name

    } FILECTX, *LPFILECTX;

        LPFILECTX      FileStack[MAXINCLUDE]; // Stack of files being parsed

        FILE* stream;   // For save-to-file behaviour

 

        LPBYTE Base;

        LPBYTE Ptr;     // For save-to-mem behaviour

        size_t Used;

        size_t Max;

 

    } SAVESTREAM, FAR* LPSAVESTREAM;

        {"DATA_FORMAT_IDENTIFIER", SDATA_FORMAT_ID},

// A property

typedef struct {

        const char *id;

        WRITEMODE as;

    } PROPERTY;

 

static PROPERTY PredefinedProperties[] = {

 

        {"NUMBER_OF_FIELDS", WRITE_UNCOOKED},    // Required - NUMBER OF FIELDS

        {"NUMBER_OF_SETS",   WRITE_UNCOOKED},    // Required - NUMBER OF SETS

        {"ORIGINATOR",       WRITE_STRINGIFY},   // Required - Identifies the specific system, organization or individual that created the data file.

        {"FILE_DESCRIPTOR",  WRITE_STRINGIFY},   // Required - Describes the purpose or contents of the data file.

        {"CREATED",          WRITE_STRINGIFY},   // Required - Indicates date of creation of the data file.

        {"DESCRIPTOR",       WRITE_STRINGIFY},   // Required  - Describes the purpose or contents of the data file.

        {"DIFFUSE_GEOMETRY", WRITE_STRINGIFY},   // The diffuse geometry used. Allowed values are "sphere" or "opal".

        {"MANUFACTURER",     WRITE_STRINGIFY},

        {"MANUFACTURE",      WRITE_STRINGIFY},   // Some broken Fuji targets does store this value

        {"PROD_DATE",        WRITE_STRINGIFY},   // Identifies year and month of production of the target in the form yyyy:mm.

        {"SERIAL",           WRITE_STRINGIFY},   // Uniquely identifies individual physical target.

 

        {"MATERIAL",         WRITE_STRINGIFY},   // Identifies the material on which the target was produced using a code

        {"INSTRUMENTATION",  WRITE_STRINGIFY},   // Used to report the specific instrumentation used (manufacturer and

        {"MEASUREMENT_SOURCE", WRITE_STRINGIFY}, // Illumination used for spectral measurements. This data helps provide

        {"PRINT_CONDITIONS", WRITE_STRINGIFY},   // Used to define the characteristics of the printed sheet being reported.

        {"SAMPLE_BACKING",   WRITE_STRINGIFY},   // Identifies the backing material used behind the sample during

                               // measurement. Allowed values are �black�, �white�, or {"na".

 

        {"CHISQ_DOF",        WRITE_STRINGIFY},   // Degrees of freedom associated with the Chi squared statistic

 

//    new in recent specs:

        {"MEASUREMENT_GEOMETRY", WRITE_STRINGIFY}, // The type of measurement, either reflection or transmission, should be indicated 

                               // along with details of the geometry and the aperture size and shape. For example, 

                               // for transmission measurements it is important to identify 0/diffuse, diffuse/0, 

                               // opal or integrating sphere, etc. For reflection it is important to identify 0/45, 

                               // 45/0, sphere (specular included or excluded), etc.

 

       {"FILTER",            WRITE_STRINGIFY},   // Identifies the use of physical filter(s) during measurement. Typically used to 

                               // denote the use of filters such as none, D65, Red, Green or Blue.

 

       {"POLARIZATION",      WRITE_STRINGIFY},   // Identifies the use of a physical polarization filter during measurement. Allowed 

                               // values are {"yes�, �white�, �none� or �na�.

 

       {"WEIGHTING_FUNCTION", WRITE_PAIR},   // Indicates such functions as: the CIE standard observer functions used in the 

                               // calculation of various data parameters (2 degree and 10 degree), CIE standard 

                               // illuminant functions used in the calculation of various data parameters (e.g., D50,

                               // D65, etc.), density status response, etc. If used there shall be at least one 

                               // name-value pair following the WEIGHTING_FUNCTION tag/keyword. The first attribute 

                               // in the set shall be {"name" and shall identify the particular parameter used.

                               // The second shall be {"value" and shall provide the value associated with that name. 

                               // For ASCII data, a string containing the Name and Value attribute pairs shall follow 

                               // the weighting function keyword. A semi-colon separates attribute pairs from each 

                               // other and within the attribute the name and value are separated by a comma.

 

       {"COMPUTATIONAL_PARAMETER", WRITE_PAIR}, // Parameter that is used in computing a value from measured data. Name is the name 

                               // of the calculation, parameter is the name of the parameter used in the calculation 

                               // and value is the value of the parameter.

 

       {"TARGET_TYPE",        WRITE_STRINGIFY},  // The type of target being measured, e.g. IT8.7/1, IT8.7/3, user defined, etc.

 

       {"COLORANT",           WRITE_STRINGIFY},  // Identifies the colorant(s) used in creating the target.

 

       {"TABLE_DESCRIPTOR",   WRITE_STRINGIFY},  // Describes the purpose or contents of a data table.

 

       {"TABLE_NAME",         WRITE_STRINGIFY}   // Provides a short name for a data table.

#define NUMPREDEFINEDPROPS (sizeof(PredefinedProperties)/sizeof(PROPERTY))

        "SAMPLE_ID",      // Identifies sample that data represents

        "STRING",         // Identifies label, or other non-machine readable value. 

                          // Value must begin and end with a " symbol

        "LAB_DE",         //  CIE dE

        "STDEV_A",        // Standard deviation of a*

//Forward declaration of some internal functions        

static

void* AllocChunk(LPIT8 it8, size_t size);

    if(path == NULL)

        return FALSE;

    

        return TRUE;

#ifndef NON_WINDOWS

    if(isalpha(path[0]) && path[1] == ':')

        return TRUE;

    return FALSE;

    if (!isabsolutepath(relPath)) {

        char *tail;

        

        tail = strrchr(buffer, DIR_CHAR);

        if (tail != NULL) {

            size_t len = tail - buffer;

            strncpy(tail + 1, relPath, MAX_PATH - len -1);

            //  TODO: if combined path is longer than MAX_PATH, this should return FALSE!

            return TRUE;

        }

    }

    strncpy(buffer, relPath, MAX_PATH - 1);

        buffer[MAX_PATH-1] = 0;

    return TRUE;

                if(it8 -> IncludeSP >= (MAXINCLUDE-1))

                {

                    SynError(it8, "Too many recursion levels");

                    return;

                }

                FileNest = it8 -> FileStack[it8 -> IncludeSP + 1];

                if(FileNest == NULL)

                {

                    FileNest = it8 ->FileStack[it8 -> IncludeSP + 1] = (LPFILECTX)AllocChunk(it8, sizeof(FILECTX));

                    //if(FileNest == NULL)

                        //  TODO: how to manage out-of-memory conditions?

                }

                if(_cmsMakePath(it8->str, it8->FileStack[it8->IncludeSP]->FileName, FileNest->FileName) == FALSE)

                {

                    SynError(it8, "File path too long");

                    return;

                }

                it8->IncludeSP++;

    case SIDENT:  strncpy(Buffer, it8->id, max); 

                  Buffer[max-1]=0;

                  break;

    case SSTRING: strncpy(Buffer, it8->str, max); 

                  Buffer[max-1] = 0;

                  break;

LCMSBOOL IsAvailableOnList(LPKEYVALUE p, const char* Key, const char* Subkey, LPKEYVALUE* LastPtr)

    if (LastPtr) *LastPtr = p;

                    break;

        }

        }

 

    if (p == NULL)

        return FALSE;

 

    if (Subkey == 0)

        return TRUE;

 

    for (; p != NULL; p = p->NextSubkey) {

 

        if (LastPtr) *LastPtr = p;

 

        if (stricmp(Subkey, p->Subkey) == 0)

            return TRUE;

LPKEYVALUE AddToList(LPIT8 it8, LPKEYVALUE* Head, const char *Key, const char *Subkey, const char* xValue, WRITEMODE WriteAs)

    if (IsAvailableOnList(*Head, Key, Subkey, &p)) {

 

            // This may work for editing properties

 

        //     return SynError(it8, "duplicate key <%s>", Key);                                        

    else {

        LPKEYVALUE last = p;

            SynError(it8, "AddToList: out of memory");

            return NULL;

        p->Subkey = (Subkey == NULL) ? NULL : AllocString(it8, Subkey);

 

        // Keep the container in our list

        if (*Head == NULL)

            *Head = p;

        else

        {

            if(Subkey != 0 && last != 0) {

                last->NextSubkey = p;

 

                // If Subkey is not null, then last is the last property with the same key,

                // but not necessarily is the last property in the list, so we need to move

                // to the actual list end

                while(last->Next != 0) 

                    last = last->Next;

    }

            last->Next = p;

    }

 

    p->Next    = NULL;

        p->NextSubkey = NULL;

    }

 

    p->WriteAs = WriteAs;

    return p;

}

 

static

LPKEYVALUE AddAvailableProperty(LPIT8 it8, const char* Key, WRITEMODE as)

{

        return AddToList(it8, &it8->ValidKeywords, Key, NULL, NULL, as);

}

 

 

static

LPKEYVALUE AddAvailableSampleID(LPIT8 it8, const char* Key)

{

        return AddToList(it8, &it8->ValidSampleID, Key, NULL, NULL, WRITE_UNCOOKED);

    it8 = (LPIT8) malloc(sizeof(IT8));

    it8->FileStack[0] = (LPFILECTX)AllocChunk(it8, sizeof(FILECTX));

            AddAvailableProperty(it8, PredefinedProperties[i].id, PredefinedProperties[i].as);

        it8 ->SheetType[MAXSTR-1] = 0;

    return AddToList(it8, &GetTable(it8)->HeaderList, "# ", NULL, Val, WRITE_UNCOOKED) != NULL;

    return AddToList(it8, &GetTable(it8)->HeaderList, Key, NULL, Val, WRITE_STRINGIFY) != NULL;

    return AddToList(it8, &GetTable(it8)->HeaderList, cProp, NULL, Buffer, WRITE_UNCOOKED) != NULL;    

    return AddToList(it8, &GetTable(it8)->HeaderList, cProp, NULL, Buffer, WRITE_HEXADECIMAL) != NULL;    

    return AddToList(it8, &GetTable(it8)->HeaderList, Key, NULL, Buffer, WRITE_UNCOOKED) != NULL;

}

 

LCMSBOOL LCMSEXPORT cmsIT8SetPropertyMulti(LCMSHANDLE hIT8, const char* Key, const char* SubKey, const char *Buffer)

{

    LPIT8 it8 = (LPIT8) hIT8;

 

    return AddToList(it8, &GetTable(it8)->HeaderList, Key, SubKey, Buffer, WRITE_PAIR) != NULL;

}

    if (IsAvailableOnList(GetTable(it8) -> HeaderList, Key, NULL, &p))

const char* LCMSEXPORT cmsIT8GetPropertyMulti(LCMSHANDLE hIT8, const char* Key, const char *SubKey)

{

    LPIT8 it8 = (LPIT8) hIT8;

    LPKEYVALUE p;

 

    if (IsAvailableOnList(GetTable(it8) -> HeaderList, Key, SubKey, &p))

    {

        return p -> Value;

    }

    return NULL;

}

 

#ifdef  STRICT_CGATS

    if (!IsAvailableOnList(it8-> ValidSampleID, label, NULL, NULL)) {

        SynError(it8, "Invalid data format '%s'.", label);

        return FALSE;

    }

#endif

 

    

    size_t len;

    if (str == NULL) 

        str = " ";

    

    // Lenghth to write

    len = strlen(str);

    

 

    if (f ->stream) {   // Should I write it to a file?

 

        fwrite(str, 1, len, f->stream);

        

    }

    else {  // Or to a memory block?

                        

 

        if (f ->Base) {   // Am I just counting the bytes?

            

            if (f ->Used > f ->Max) {

 

                cmsSignalError(LCMS_ERRC_ABORTED, "Write to memory overflows in CGATS parser");

                return;

            }

            

            CopyMemory(f ->Ptr, str, len);

            f->Ptr += len;

            

        }

                        

    }   

                Writef(fp, "%c", *Pt);                

        if (!IsAvailableOnList(it8-> ValidKeywords, p->Keyword, NULL, NULL)) {

            AddAvailableProperty(it8, p->Keyword, WRITE_UNCOOKED);

            case WRITE_PAIR:

                    Writef(fp, "\t\"%s,%s\"", p->Subkey, p->Value);

                    break;

 

    SAVESTREAM sd;  

    ZeroMemory(&sd, sizeof(SAVESTREAM));

    fclose(sd.stream);

    SAVESTREAM sd;  

    ZeroMemory(&sd, sizeof(SAVESTREAM));

    sd.Base   = (LPBYTE) MemPtr;

    sd.Ptr    = sd.Base;

 

    sd.Used = 0;

 

    if (sd.Base) 

        sd.Max  = *BytesNeeded;     // Write to memory?

    else 

        sd.Max  = 0;                // Just counting the needed bytes

    sd.Used++;  // The \0 at the very end

 

    if (sd.Base)

        sd.Ptr = 0;

 

    *BytesNeeded = sd.Used;

    char Buffer[MAXSTR];

    LPKEYVALUE Key;

                if (!AddAvailableProperty(it8, Buffer, WRITE_UNCOOKED)) return FALSE;

                InSymbol(it8);

                break;

 

 

        case SDATA_FORMAT_ID:

                InSymbol(it8);

                if (!GetVal(it8, Buffer, MAXSTR-1, "Keyword expected")) return FALSE;                

                if (!AddAvailableSampleID(it8, Buffer)) return FALSE;

                VarName[MAXID-1] = 0;

                if (!IsAvailableOnList(it8-> ValidKeywords, VarName, NULL, &Key)) {

                    Key = AddAvailableProperty(it8, VarName, WRITE_UNCOOKED);

                    if (Key == NULL) return FALSE;

                if(Key->WriteAs != WRITE_PAIR) {

                    AddToList(it8, &GetTable(it8)->HeaderList, VarName, NULL, Buffer, 

                                (it8->sy == SSTRING) ? WRITE_STRINGIFY : WRITE_UNCOOKED);

                }

                else {

                    const char *Subkey;

                    char *Nextkey;

                    if (it8->sy != SSTRING)

                        return SynError(it8, "Invalid value '%s' for property '%s'.", Buffer, VarName);

 

                    // chop the string as a list of "subkey, value" pairs, using ';' as a separator

                    for(Subkey = Buffer; Subkey != NULL; Subkey = Nextkey)

                    {

                        char *Value, *temp;

 

                        //  identify token pair boundary

                        Nextkey = (char*) strchr(Subkey, ';');

                        if(Nextkey)

                            *Nextkey++ = '\0';

 

                        // for each pair, split the subkey and the value

                        Value = (char*) strrchr(Subkey, ',');

                        if(Value == NULL)

                            return SynError(it8, "Invalid value for property '%s'.", VarName);

 

                        // gobble the spaces before the coma, and the coma itself

                        temp = Value++;

                        do *temp-- = '\0'; while(temp >= Subkey && *temp == ' ');

 

                        // gobble any space at the right

                        temp = Value + strlen(Value) - 1;

                        while(*temp == ' ') *temp-- = '\0'; 

 

                        // trim the strings from the left

                        Subkey += strspn(Subkey, " ");

                        Value += strspn(Value, " ");

 

                        if(Subkey[0] == 0 || Value[0] == 0)

                            return SynError(it8, "Invalid value for property '%s'.", VarName);

                        AddToList(it8, &GetTable(it8)->HeaderList, VarName, Subkey, Value, WRITE_PAIR);

                    }

                }

                

LCMSBOOL ParseIT8(LPIT8 it8, LCMSBOOL nosheet)

    char* SheetTypePtr = it8 ->SheetType;

 

    if (nosheet == 0) {

    }

                    Buffer[255] = 0;

                                    if (IsAvailableOnList(Table->HeaderList, Label, NULL, &p)) {

int IsMyBlock(LPBYTE Buffer, size_t n)

    int cols = 1, space = 0, quot = 0;

        switch(Buffer[i])

        {

        case '\n':

        case '\r':

            return quot == 1 || cols > 2 ? 0 : cols;

        case '\t':

        case ' ':

            if(!quot && !space)

                space = 1;

            break;

        case '\"':

            quot = !quot;

            break;

        default:

            if (Buffer[i] < 32) return 0;

            if (Buffer[i] > 127) return 0;

            cols += space;

            space = 0;

            break;

        }

int IsMyFile(const char* FileName)

    int type = IsMyBlock((LPBYTE) Ptr, len);

    if (type == 0) return NULL;

    if (!ParseIT8(it8, type-1)) { 

     int type = IsMyFile(cFileName);

     if (type == 0) return NULL;

    it8->FileStack[0]->FileName[MAX_PATH-1] = 0;

    if (!ParseIT8(it8, type-1)) { 

int LCMSEXPORT cmsIT8EnumProperties(LCMSHANDLE hIT8, const char ***PropertyNames)

    const char **Props;

    Props = (const char **) AllocChunk(it8, sizeof(char *) * n);

int LCMSEXPORT cmsIT8EnumPropertyMulti(LCMSHANDLE hIT8, const char* cProp, const char ***SubpropertyNames)

{

    LPIT8 it8 = (LPIT8) hIT8;

    LPKEYVALUE p, tmp;

    int n;

    const char **Props;

    LPTABLE t = GetTable(it8);

 

    if(!IsAvailableOnList(t->HeaderList, cProp, NULL, &p)) {

        *SubpropertyNames = 0;

        return 0;

    }

 

    // Pass#1 - count properties

 

    n = 0;

    for (tmp = p;  tmp != NULL; tmp = tmp->NextSubkey) {

        if(tmp->Subkey != NULL)

            n++;

    }

 

 

    Props = (const char **) AllocChunk(it8, sizeof(char *) * n);

 

    // Pass#2 - Fill pointers

    n = 0;

    for (tmp = p;  tmp != NULL; tmp = tmp->NextSubkey) {

        if(tmp->Subkey != NULL)

            Props[n++] = p ->Subkey;

    }

 

    *SubpropertyNames = Props;

    return n;

}

 

        buffer[MAXSTR-1] = 0;

int LCMSEXPORT cmsIT8GetPatchByName(LCMSHANDLE hIT8, const char *cPatch)

{

    return LocatePatch((LPIT8)hIT8, cPatch);

}

 

LCMSBOOL LCMSEXPORT cmsIT8SetIndexColumn(LCMSHANDLE hIT8, const char* cSample)

{

    LPIT8 it8 = (LPIT8) hIT8;

 

    int pos = LocateSample(it8, cSample);

    if(pos == -1)

        return FALSE;

 

    it8->Tab[it8->nTable].SampleID = pos;

    return TRUE;

}