jdk-sandbox: comparison jdk/src/share/native/sun/java2d/cmm/lcms/cmsio0.c

equal deleted inserted replaced

-:ea28f24e1708
+:404cbe399601
 // However, the following notice accompanied the original version of this
 // file:
 //
 //
 //  Little cms
-//  Copyright (C) 1998-2006 Marti Maria
+//  Copyright (C) 1998-2007 Marti Maria
 //
 // Permission is hereby granted, free of charge, to any person obtaining
 // a copy of this software and associated documentation files (the "Software"),
 // to deal in the Software without restriction, including without limitation
 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
 // Memory-based stream ---------------------------------------------------
 typedef struct {
 LPBYTE Block;           // Points to allocated memory
 size_t Size;            // Size of allocated memory
-int Pointer;            // Points to current location
+size_t Pointer;         // Points to current location
 int FreeBlockOnClose;   // As title
 } FILEMEM;
 static
 LPVOID MemoryOpen(LPBYTE Block, size_t Size, char Mode)
 {
-FILEMEM* fm = (FILEMEM*) malloc(sizeof(FILEMEM));
+FILEMEM* fm = (FILEMEM*) _cmsMalloc(sizeof(FILEMEM));
+if (fm == NULL) return NULL;
 ZeroMemory(fm, sizeof(FILEMEM));
 if (Mode == 'r') {
-fm ->Block   = (LPBYTE) malloc(Size);
+fm ->Block   = (LPBYTE) _cmsMalloc(Size);
 if (fm ->Block == NULL) {
-free(fm);
+_cmsFree(fm);
 return NULL;
 }
 CopyMemory(fm->Block, Block, Size);
 fm ->FreeBlockOnClose = TRUE;
 }
 else {
 size_t MemoryRead(LPVOID buffer, size_t size, size_t count, struct _lcms_iccprofile_struct* Icc)
 {
 FILEMEM* ResData = (FILEMEM*) Icc ->stream;
 LPBYTE Ptr;
 size_t len = size * count;
+size_t extent = ResData -> Pointer + len;
-if (ResData -> Pointer + len > ResData -> Size){
+if (len == 0) {
+return 0;
+}
+if (len / size != count) {
+cmsSignalError(LCMS_ERRC_ABORTED, "Read from memory error. Integer overflow with count / size.");
+return 0;
+}
+if (extent < len || extent < ResData -> Pointer) {
+cmsSignalError(LCMS_ERRC_ABORTED, "Read from memory error. Integer overflow with len.");
+return 0;
+}
+if (ResData -> Pointer + len > ResData -> Size) {
 len = (ResData -> Size - ResData -> Pointer);
-cmsSignalError(LCMS_ERRC_WARNING, "Read from memory error. Got %d bytes, block should be of %d bytes", len * size, count * size);
+cmsSignalError(LCMS_ERRC_ABORTED, "Read from memory error. Got %d bytes, block should be of %d bytes", len * size, count * size);
+return 0;
 }
 Ptr  = ResData -> Block;
 Ptr += ResData -> Pointer;
 CopyMemory(buffer, Ptr, len);
 }
 // SEEK_CUR is assumed
 static
-BOOL MemorySeek(struct _lcms_iccprofile_struct* Icc, size_t offset)
+LCMSBOOL MemorySeek(struct _lcms_iccprofile_struct* Icc, size_t offset)
 {
 FILEMEM* ResData = (FILEMEM*) Icc ->stream;
 if (offset > ResData ->Size) {
 cmsSignalError(LCMS_ERRC_ABORTED,  "Pointer error; probably corrupted file");
 return ResData -> Pointer;
 }
-// Writes data to memory, also keeps used space for further reference
+// Writes data to memory, also keeps used space for further reference. NO CHECK IS PERFORMED
 static
-BOOL MemoryWrite(struct _lcms_iccprofile_struct* Icc, size_t size, void *Ptr)
+LCMSBOOL MemoryWrite(struct _lcms_iccprofile_struct* Icc, size_t size, void *Ptr)
 {
 FILEMEM* ResData = (FILEMEM*) Icc ->stream;
 if (size == 0) return TRUE;
 return TRUE;
 }
 static
-BOOL MemoryGrow(struct _lcms_iccprofile_struct* Icc, size_t size)
+LCMSBOOL MemoryGrow(struct _lcms_iccprofile_struct* Icc, size_t size)
 {
 FILEMEM* ResData = (FILEMEM*) Icc->stream;
-void* newBlock = realloc(ResData->Block, ResData->Size + size);
+void* newBlock = NULL;
+/* Follow same policies as functions in lcms.h  */
+if (ResData->Size + size < 0) return NULL;
+if (ResData->Size + size > (size_t)1024*1024*500))) return NULL;
+newBlock = realloc(ResData->Block, ResData->Size + size);
 if (!newBlock) {
 return FALSE;
 }
 ResData->Block = newBlock;
 return TRUE;
 }
 static
-BOOL MemoryClose(struct _lcms_iccprofile_struct* Icc)
+LCMSBOOL MemoryClose(struct _lcms_iccprofile_struct* Icc)
 {
 FILEMEM* ResData = (FILEMEM*) Icc ->stream;
 if (ResData ->FreeBlockOnClose) {
-if (ResData ->Block) free(ResData ->Block);
+if (ResData ->Block)  _cmsFree(ResData ->Block);
 }
-free(ResData);
+_cmsFree(ResData);
 return 0;
 }
 // File-based stream -------------------------------------------------------
 static
 size_t FileRead(void *buffer, size_t size, size_t count, struct _lcms_iccprofile_struct* Icc)
 {
 size_t nReaded = fread(buffer, size, count, (FILE*) Icc->stream);
 if (nReaded != count) {
-cmsSignalError(LCMS_ERRC_WARNING, "Read error. Got %d bytes, block should be of %d bytes", nReaded * size, count * size);
+cmsSignalError(LCMS_ERRC_ABORTED, "Read error. Got %d bytes, block should be of %d bytes", nReaded * size, count * size);
 return 0;
 }
 return nReaded;
 }
 static
-BOOL FileSeek(struct _lcms_iccprofile_struct* Icc, size_t offset)
+LCMSBOOL FileSeek(struct _lcms_iccprofile_struct* Icc, size_t offset)
 {
 if (fseek((FILE*) Icc ->stream, (long) offset, SEEK_SET) != 0) {
 cmsSignalError(LCMS_ERRC_ABORTED, "Seek error; probably corrupted file");
 return TRUE;
 // Writes data to stream, also keeps used space for further reference
 static
-BOOL FileWrite(struct _lcms_iccprofile_struct* Icc, size_t size, LPVOID Ptr)
+LCMSBOOL FileWrite(struct _lcms_iccprofile_struct* Icc, size_t size, LPVOID Ptr)
 {
 if (size == 0) return TRUE;
 Icc->UsedSpace += size;
 return (fwrite(Ptr, size, 1, (FILE*) Icc->stream) == 1);
 }
 static
-BOOL FileGrow(struct _lcms_iccprofile_struct* Icc, size_t size)
+LCMSBOOL FileGrow(struct _lcms_iccprofile_struct* Icc, size_t size)
 {
 return TRUE;
 }
 static
-BOOL FileClose(struct _lcms_iccprofile_struct* Icc)
+LCMSBOOL FileClose(struct _lcms_iccprofile_struct* Icc)
 {
 return fclose((FILE*) Icc ->stream);
 }
 // ----------------------------------------------------------------------------------------------------
 // Creates an empty structure holding all required parameters
 cmsHPROFILE _cmsCreateProfilePlaceholder(void)
 {
-LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) malloc(sizeof(LCMSICCPROFILE));
+LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) _cmsMalloc(sizeof(LCMSICCPROFILE));
 if (Icc == NULL) return NULL;
 // Empty values
 ZeroMemory(Icc, sizeof(LCMSICCPROFILE));
 // Search for a specific tag in tag dictionary
 // Returns position or -1 if tag not found
-icInt32Number _cmsSearchTag(LPLCMSICCPROFILE Profile, icTagSignature sig, BOOL lSignalError)
+icInt32Number _cmsSearchTag(LPLCMSICCPROFILE Profile, icTagSignature sig, LCMSBOOL lSignalError)
 {
 icInt32Number i;
 if (sig == 0) return -1;     // 0 identifies a special tag holding raw memory.
 }
 // Check existance
-BOOL LCMSEXPORT cmsIsTag(cmsHPROFILE hProfile, icTagSignature sig)
+LCMSBOOL LCMSEXPORT cmsIsTag(cmsHPROFILE hProfile, icTagSignature sig)
 {
 LPLCMSICCPROFILE  Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
 return _cmsSearchTag(Icc, sig, FALSE) >= 0;
 }
 i = _cmsSearchTag(Icc, sig, FALSE);
 if (i >=0) {
-if (Icc -> TagPtrs[i]) free(Icc -> TagPtrs[i]);
+if (Icc -> TagPtrs[i]) _cmsFree(Icc -> TagPtrs[i]);
 }
 else  {
 i = Icc -> TagCount;
 Icc -> TagCount++;
 if (Icc ->TagCount >= MAX_TABLE_TAG) {
 cmsSignalError(LCMS_ERRC_ABORTED, "Too many tags (%d)", MAX_TABLE_TAG);
 Icc ->TagCount = MAX_TABLE_TAG-1;
+return NULL;
 }
 }
-Ptr = malloc(size);
+Ptr = _cmsMalloc(size);
+if (Ptr == NULL) return NULL;
 CopyMemory(Ptr, Init, size);
 Icc ->TagNames[i] = sig;
 Icc ->TagSizes[i] = size;
 Icc ->TagPtrs[i]  = Ptr;
 NewIcc = (LPLCMSICCPROFILE) _cmsCreateProfilePlaceholder();
 if (NewIcc == NULL) return NULL;
 strncpy(NewIcc -> PhysicalFile, FileName, MAX_PATH-1);
+NewIcc -> PhysicalFile[MAX_PATH-1] = 0;
 NewIcc ->stream = ICCfile;
 NewIcc ->Read  = FileRead;
 NewIcc ->Seek  = FileSeek;
 NewIcc ->Tell  = FileTell;
 // ----------------------------------------------------------------------- Set/Get several struct members
-BOOL LCMSEXPORT cmsTakeMediaWhitePoint(LPcmsCIEXYZ Dest, cmsHPROFILE hProfile)
+LCMSBOOL LCMSEXPORT cmsTakeMediaWhitePoint(LPcmsCIEXYZ Dest, cmsHPROFILE hProfile)
 {
 LPLCMSICCPROFILE    Icc = (LPLCMSICCPROFILE) hProfile;
 *Dest = Icc -> MediaWhitePoint;
 return TRUE;
 }
-BOOL LCMSEXPORT cmsTakeMediaBlackPoint(LPcmsCIEXYZ Dest, cmsHPROFILE hProfile)
+LCMSBOOL LCMSEXPORT cmsTakeMediaBlackPoint(LPcmsCIEXYZ Dest, cmsHPROFILE hProfile)
 {
 LPLCMSICCPROFILE    Icc = (LPLCMSICCPROFILE) hProfile;
 *Dest = Icc -> MediaBlackPoint;
 return TRUE;
 }
-BOOL  LCMSEXPORT cmsTakeIluminant(LPcmsCIEXYZ Dest, cmsHPROFILE hProfile)
+LCMSBOOL  LCMSEXPORT cmsTakeIluminant(LPcmsCIEXYZ Dest, cmsHPROFILE hProfile)
 {
 LPLCMSICCPROFILE  Icc = (LPLCMSICCPROFILE) hProfile;
 *Dest = Icc -> Illuminant;
 return TRUE;
 }
 LPLCMSICCPROFILE  Icc = (LPLCMSICCPROFILE) hProfile;
 CopyMemory(Icc -> ProfileID, ProfileID, 16);
 }
-BOOL LCMSEXPORT cmsTakeCreationDateTime(struct tm *Dest, cmsHPROFILE hProfile)
+LCMSBOOL LCMSEXPORT cmsTakeCreationDateTime(struct tm *Dest, cmsHPROFILE hProfile)
 {
 LPLCMSICCPROFILE  Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
 CopyMemory(Dest, &Icc ->Created, sizeof(struct tm));
 return TRUE;
 }
 {
 LPLCMSICCPROFILE  Icc = (LPLCMSICCPROFILE) hProfile;
 Icc -> PCS = pcs;
 }
 icColorSpaceSignature LCMSEXPORT cmsGetColorSpace(cmsHPROFILE hProfile)
 {
 LPLCMSICCPROFILE  Icc = (LPLCMSICCPROFILE) hProfile;
 return Icc -> ColorSpace;
 }
 void LCMSEXPORT cmsSetColorSpace(cmsHPROFILE hProfile, icColorSpaceSignature sig)
 {
 LPLCMSICCPROFILE  Icc = (LPLCMSICCPROFILE) hProfile;
 Icc -> ColorSpace = sig;
 }
 icProfileClassSignature LCMSEXPORT cmsGetDeviceClass(cmsHPROFILE hProfile)
 {
 LPLCMSICCPROFILE  Icc = (LPLCMSICCPROFILE) hProfile;
 return Icc -> DeviceClass;
 }
 DWORD LCMSEXPORT cmsGetProfileICCversion(cmsHPROFILE hProfile)
 {
 LPLCMSICCPROFILE  Icc = (LPLCMSICCPROFILE) hProfile;
 return (DWORD) Icc -> Version;
 }
 void LCMSEXPORT cmsSetProfileICCversion(cmsHPROFILE hProfile, DWORD Version)
 {
 LPLCMSICCPROFILE  Icc = (LPLCMSICCPROFILE) hProfile;
 Icc -> Version = Version;
 }
 // This is tricky, since LUT structs does have pointers
-BOOL LCMSEXPORT _cmsAddLUTTag(cmsHPROFILE hProfile, icTagSignature sig, const void* lut)
+LCMSBOOL LCMSEXPORT _cmsAddLUTTag(cmsHPROFILE hProfile, icTagSignature sig, const void* lut)
 {
 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
 LPLUT Orig, Stored;
 unsigned int i;
 Stored ->CLut16params.p8 = NULL;
 return TRUE;
 }
-BOOL LCMSEXPORT _cmsAddXYZTag(cmsHPROFILE hProfile, icTagSignature sig, const cmsCIEXYZ* XYZ)
+LCMSBOOL LCMSEXPORT _cmsAddXYZTag(cmsHPROFILE hProfile, icTagSignature sig, const cmsCIEXYZ* XYZ)
 {
 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
 _cmsInitTag(Icc, sig, sizeof(cmsCIEXYZ), XYZ);
 return TRUE;
 }
-BOOL LCMSEXPORT _cmsAddTextTag(cmsHPROFILE hProfile, icTagSignature sig, const char* Text)
+LCMSBOOL LCMSEXPORT _cmsAddTextTag(cmsHPROFILE hProfile, icTagSignature sig, const char* Text)
 {
 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
 _cmsInitTag(Icc, sig, strlen(Text)+1, (LPVOID) Text);
 return TRUE;
 }
-BOOL LCMSEXPORT _cmsAddGammaTag(cmsHPROFILE hProfile, icTagSignature sig, LPGAMMATABLE TransferFunction)
+LCMSBOOL LCMSEXPORT _cmsAddGammaTag(cmsHPROFILE hProfile, icTagSignature sig, LPGAMMATABLE TransferFunction)
 {
 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
 _cmsInitTag(Icc, sig, SizeOfGammaTab(TransferFunction), TransferFunction);
 return TRUE;
 }
-BOOL LCMSEXPORT _cmsAddChromaticityTag(cmsHPROFILE hProfile, icTagSignature sig, LPcmsCIExyYTRIPLE Chrm)
+LCMSBOOL LCMSEXPORT _cmsAddChromaticityTag(cmsHPROFILE hProfile, icTagSignature sig, LPcmsCIExyYTRIPLE Chrm)
 {
 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
 _cmsInitTag(Icc, sig, sizeof(cmsCIExyYTRIPLE), Chrm);
 return TRUE;
 }
-BOOL LCMSEXPORT _cmsAddSequenceDescriptionTag(cmsHPROFILE hProfile, icTagSignature sig, LPcmsSEQ pseq)
+LCMSBOOL LCMSEXPORT _cmsAddSequenceDescriptionTag(cmsHPROFILE hProfile, icTagSignature sig, LPcmsSEQ pseq)
 {
 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
 _cmsInitTag(Icc, sig, sizeof(int) + pseq -> n * sizeof(cmsPSEQDESC), pseq);
 return TRUE;
 }
-BOOL LCMSEXPORT _cmsAddNamedColorTag(cmsHPROFILE hProfile, icTagSignature sig, LPcmsNAMEDCOLORLIST nc)
+LCMSBOOL LCMSEXPORT _cmsAddNamedColorTag(cmsHPROFILE hProfile, icTagSignature sig, LPcmsNAMEDCOLORLIST nc)
 {
 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
 _cmsInitTag(Icc, sig, sizeof(cmsNAMEDCOLORLIST) + (nc ->nColors - 1) * sizeof(cmsNAMEDCOLOR), nc);
-return FALSE;
+return TRUE;
 }
-BOOL LCMSEXPORT _cmsAddDateTimeTag(cmsHPROFILE hProfile, icTagSignature sig, struct tm *DateTime)
+LCMSBOOL LCMSEXPORT _cmsAddDateTimeTag(cmsHPROFILE hProfile, icTagSignature sig, struct tm *DateTime)
 {
 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
 _cmsInitTag(Icc, sig, sizeof(struct tm), DateTime);
-return FALSE;
+return TRUE;
 }
-BOOL LCMSEXPORT _cmsAddColorantTableTag(cmsHPROFILE hProfile, icTagSignature sig, LPcmsNAMEDCOLORLIST nc)
+LCMSBOOL LCMSEXPORT _cmsAddColorantTableTag(cmsHPROFILE hProfile, icTagSignature sig, LPcmsNAMEDCOLORLIST nc)
 {
 LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
 _cmsInitTag(Icc, sig, sizeof(cmsNAMEDCOLORLIST) + (nc ->nColors - 1) * sizeof(cmsNAMEDCOLOR), nc);
-return FALSE;
+return TRUE;
 }
+LCMSBOOL LCMSEXPORT _cmsAddChromaticAdaptationTag(cmsHPROFILE hProfile, icTagSignature sig, const cmsCIEXYZ* mat)
+{
+LPLCMSICCPROFILE Icc = (LPLCMSICCPROFILE) (LPSTR) hProfile;
+_cmsInitTag(Icc, sig, 3*sizeof(cmsCIEXYZ), mat);
+return TRUE;
+}

changeset 2394	404cbe399601
parent 2392	738be5224b3f
child 2395	f5bcb8ee6555