47 #include "magick/studio.h"
48 #include "magick/blob.h"
49 #include "magick/blob-private.h"
50 #include "magick/cache.h"
51 #include "magick/client.h"
52 #include "magick/constitute.h"
53 #include "magick/delegate.h"
54 #include "magick/exception.h"
55 #include "magick/exception-private.h"
56 #include "magick/geometry.h"
57 #include "magick/image-private.h"
58 #include "magick/list.h"
59 #include "magick/locale_.h"
60 #include "magick/log.h"
61 #include "magick/magick.h"
62 #include "magick/memory_.h"
63 #include "magick/nt-base-private.h"
64 #include "magick/option.h"
65 #include "magick/policy.h"
66 #include "magick/resource_.h"
67 #include "magick/semaphore.h"
68 #include "magick/string_.h"
69 #include "magick/string-private.h"
70 #include "magick/timer-private.h"
71 #include "magick/token.h"
72 #include "magick/utility.h"
73 #include "magick/utility-private.h"
74 #if defined(MAGICKCORE_ZLIB_DELEGATE)
77 #if defined(MAGICKCORE_BZLIB_DELEGATE)
84 #define MagickMaxBlobExtent (8*8192)
85 #if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
86 # define MAP_ANONYMOUS MAP_ANON
88 #if !defined(MAP_FAILED)
89 #define MAP_FAILED ((void *) -1)
93 #define _O_BINARY O_BINARY
104 #if defined(MAGICKCORE_ZLIB_DELEGATE)
109 #if defined(MAGICKCORE_BZLIB_DELEGATE)
206 MagickExport
void AttachBlob(
BlobInfo *blob_info,
const void *blob,
209 assert(blob_info != (
BlobInfo *) NULL);
210 if (IsEventLogging() != MagickFalse)
211 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"...");
212 blob_info->length=length;
213 blob_info->extent=length;
214 blob_info->quantum=(size_t) MagickMaxBlobExtent;
216 blob_info->type=BlobStream;
217 blob_info->file_info.file=(FILE *) NULL;
218 blob_info->data=(
unsigned char *) blob;
219 blob_info->mapped=MagickFalse;
252 MagickExport MagickBooleanType BlobToFile(
char *filename,
const void *blob,
264 assert(filename != (
const char *) NULL);
265 assert(blob != (
const void *) NULL);
266 if (IsEventLogging() != MagickFalse)
267 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",filename);
268 if (*filename ==
'\0')
269 file=AcquireUniqueFileResource(filename);
271 file=open_utf8(filename,O_RDWR | O_CREAT | O_EXCL | O_BINARY,S_MODE);
274 ThrowFileException(exception,BlobError,
"UnableToWriteBlob",filename);
277 for (i=0; i < length; i+=count)
279 count=write(file,(
const char *) blob+i,MagickMin(length-i,(
size_t)
289 if ((file == -1) || (i < length))
291 ThrowFileException(exception,BlobError,
"UnableToWriteBlob",filename);
328 MagickExport
Image *BlobToImage(
const ImageInfo *image_info,
const void *blob,
344 assert(image_info != (
ImageInfo *) NULL);
345 assert(image_info->signature == MagickCoreSignature);
347 if (IsEventLogging() != MagickFalse)
348 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
349 image_info->filename);
350 if ((blob == (
const void *) NULL) || (length == 0))
352 (void) ThrowMagickException(exception,GetMagickModule(),BlobError,
353 "ZeroLengthBlobNotPermitted",
"`%s'",image_info->filename);
354 return((
Image *) NULL);
356 blob_info=CloneImageInfo(image_info);
357 blob_info->blob=(
void *) blob;
358 blob_info->length=length;
359 if (*blob_info->magick ==
'\0')
360 (void) SetImageInfo(blob_info,0,exception);
361 magick_info=GetMagickInfo(blob_info->magick,exception);
364 (void) ThrowMagickException(exception,GetMagickModule(),
365 MissingDelegateError,
"NoDecodeDelegateForThisImageFormat",
"`%s'",
367 blob_info=DestroyImageInfo(blob_info);
368 return((
Image *) NULL);
370 if (GetMagickBlobSupport(magick_info) != MagickFalse)
373 filename[MagickPathExtent];
378 (void) CopyMagickString(filename,blob_info->filename,MagickPathExtent);
379 (void) FormatLocaleString(blob_info->filename,MagickPathExtent,
"%s:%s",
380 blob_info->magick,filename);
381 image=ReadImage(blob_info,exception);
382 if (image != (
Image *) NULL)
383 (void) DetachBlob(image->blob);
384 blob_info=DestroyImageInfo(blob_info);
390 blob_info->blob=(
void *) NULL;
392 *blob_info->filename=
'\0';
393 status=BlobToFile(blob_info->filename,blob,length,exception);
394 if (status == MagickFalse)
396 (void) RelinquishUniqueFileResource(blob_info->filename);
397 blob_info=DestroyImageInfo(blob_info);
398 return((
Image *) NULL);
400 clone_info=CloneImageInfo(blob_info);
401 (void) FormatLocaleString(clone_info->filename,MagickPathExtent,
"%s:%s",
402 blob_info->magick,blob_info->filename);
403 image=ReadImage(clone_info,exception);
404 if (image != (
Image *) NULL)
412 for (images=GetFirstImageInList(image); images != (
Image *) NULL; )
414 (void) CopyMagickString(images->filename,image_info->filename,
416 (void) CopyMagickString(images->magick_filename,image_info->filename,
418 (void) CopyMagickString(images->magick,magick_info->name,
420 images=GetNextImageInList(images);
423 clone_info=DestroyImageInfo(clone_info);
424 (void) RelinquishUniqueFileResource(blob_info->filename);
425 blob_info=DestroyImageInfo(blob_info);
460 clone_info=(
BlobInfo *) AcquireCriticalMemory(
sizeof(*clone_info));
461 GetBlobInfo(clone_info);
464 semaphore=clone_info->semaphore;
465 (void) memcpy(clone_info,blob_info,
sizeof(*clone_info));
466 if (blob_info->mapped != MagickFalse)
467 (void) AcquireMagickResource(MapResource,blob_info->length);
468 clone_info->semaphore=semaphore;
469 LockSemaphoreInfo(clone_info->semaphore);
470 clone_info->reference_count=1;
471 UnlockSemaphoreInfo(clone_info->semaphore);
498 static inline void ThrowBlobException(
BlobInfo *blob_info)
500 if ((blob_info->status == MagickFalse) && (errno != 0))
501 blob_info->error_number=errno;
502 blob_info->status=MagickTrue;
505 MagickExport MagickBooleanType CloseBlob(
Image *image)
508 *magick_restrict blob_info;
516 assert(image != (
Image *) NULL);
517 assert(image->signature == MagickCoreSignature);
518 if (IsEventLogging() != MagickFalse)
519 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
520 blob_info=image->blob;
521 if ((blob_info == (
BlobInfo *) NULL) || (blob_info->type == UndefinedStream))
523 status=SyncBlob(image);
524 switch (blob_info->type)
526 case UndefinedStream:
532 if (blob_info->synchronize != MagickFalse)
534 status=fflush(blob_info->file_info.file);
536 ThrowBlobException(blob_info);
537 status=fsync(fileno(blob_info->file_info.file));
539 ThrowBlobException(blob_info);
541 if ((status != 0) && (ferror(blob_info->file_info.file) != 0))
542 ThrowBlobException(blob_info);
547 #if defined(MAGICKCORE_ZLIB_DELEGATE)
549 (void) gzerror(blob_info->file_info.gzfile,&status);
551 ThrowBlobException(blob_info);
557 #if defined(MAGICKCORE_BZLIB_DELEGATE)
559 (void) BZ2_bzerror(blob_info->file_info.bzfile,&status);
561 ThrowBlobException(blob_info);
569 if (blob_info->file_info.file != (FILE *) NULL)
571 if (blob_info->synchronize != MagickFalse)
573 status=fflush(blob_info->file_info.file);
575 ThrowBlobException(blob_info);
576 status=fsync(fileno(blob_info->file_info.file));
578 ThrowBlobException(blob_info);
580 if ((status != 0) && (ferror(blob_info->file_info.file) != 0))
581 ThrowBlobException(blob_info);
586 blob_info->size=GetBlobSize(image);
587 image->extent=blob_info->size;
588 blob_info->eof=MagickFalse;
590 blob_info->mode=UndefinedBlobMode;
591 if (blob_info->exempt != MagickFalse)
593 blob_info->type=UndefinedStream;
594 return(blob_info->status);
596 switch (blob_info->type)
598 case UndefinedStream:
603 if (blob_info->file_info.file != (FILE *) NULL)
605 status=fclose(blob_info->file_info.file);
607 ThrowBlobException(blob_info);
613 #if defined(MAGICKCORE_HAVE_PCLOSE)
614 status=pclose(blob_info->file_info.file);
616 ThrowBlobException(blob_info);
622 #if defined(MAGICKCORE_ZLIB_DELEGATE)
623 status=gzclose(blob_info->file_info.gzfile);
625 ThrowBlobException(blob_info);
631 #if defined(MAGICKCORE_BZLIB_DELEGATE)
632 BZ2_bzclose(blob_info->file_info.bzfile);
640 if (blob_info->file_info.file != (FILE *) NULL)
642 status=fclose(blob_info->file_info.file);
644 ThrowBlobException(blob_info);
649 (void) DetachBlob(blob_info);
650 return(blob_info->status);
675 MagickExport
void DestroyBlob(
Image *image)
678 *magick_restrict blob_info;
683 assert(image != (
Image *) NULL);
684 assert(image->signature == MagickCoreSignature);
685 assert(image->blob != (
BlobInfo *) NULL);
686 assert(image->blob->signature == MagickCoreSignature);
687 if (IsEventLogging() != MagickFalse)
688 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
689 blob_info=image->blob;
691 LockSemaphoreInfo(blob_info->semaphore);
692 blob_info->reference_count--;
693 assert(blob_info->reference_count >= 0);
694 if (blob_info->reference_count == 0)
696 UnlockSemaphoreInfo(blob_info->semaphore);
697 if (destroy == MagickFalse)
702 (void) CloseBlob(image);
703 if (blob_info->mapped != MagickFalse)
705 (void) UnmapBlob(blob_info->data,blob_info->length);
706 RelinquishMagickResource(MapResource,blob_info->length);
709 DestroySemaphoreInfo(&blob_info->semaphore);
710 blob_info->signature=(~MagickCoreSignature);
711 image->blob=(
BlobInfo *) RelinquishMagickMemory(blob_info);
736 MagickExport
unsigned char *DetachBlob(
BlobInfo *blob_info)
741 assert(blob_info != (
BlobInfo *) NULL);
742 if (IsEventLogging() != MagickFalse)
743 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"...");
744 if (blob_info->mapped != MagickFalse)
746 (void) UnmapBlob(blob_info->data,blob_info->length);
747 blob_info->data=NULL;
748 RelinquishMagickResource(MapResource,blob_info->length);
750 blob_info->mapped=MagickFalse;
753 blob_info->eof=MagickFalse;
755 blob_info->exempt=MagickFalse;
756 blob_info->type=UndefinedStream;
757 blob_info->file_info.file=(FILE *) NULL;
758 data=blob_info->data;
759 blob_info->data=(
unsigned char *) NULL;
760 blob_info->stream=(StreamHandler) NULL;
788 MagickPrivate
void DisassociateBlob(
Image *image)
791 *magick_restrict blob_info,
797 assert(image != (
Image *) NULL);
798 assert(image->signature == MagickCoreSignature);
799 assert(image->blob != (
BlobInfo *) NULL);
800 assert(image->blob->signature == MagickCoreSignature);
801 if (IsEventLogging() != MagickFalse)
802 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
803 blob_info=image->blob;
805 LockSemaphoreInfo(blob_info->semaphore);
806 assert(blob_info->reference_count >= 0);
807 if (blob_info->reference_count > 1)
809 UnlockSemaphoreInfo(blob_info->semaphore);
810 if (clone == MagickFalse)
812 clone_info=CloneBlobInfo(blob_info);
814 image->blob=clone_info;
842 MagickExport MagickBooleanType DiscardBlobBytes(
Image *image,
843 const MagickSizeType length)
855 buffer[MagickMinBufferExtent >> 1];
857 assert(image != (
Image *) NULL);
858 assert(image->signature == MagickCoreSignature);
859 if (length != (MagickSizeType) ((MagickOffsetType) length))
862 for (i=0; i < (MagickOffsetType) length; i+=count)
864 quantum=(size_t) MagickMin(length-i,
sizeof(buffer));
865 (void) ReadBlobStream(image,quantum,buffer,&count);
873 return(i < (MagickOffsetType) length ? MagickFalse : MagickTrue);
900 MagickExport
void DuplicateBlob(
Image *image,
const Image *duplicate)
902 assert(image != (
Image *) NULL);
903 assert(image->signature == MagickCoreSignature);
904 assert(duplicate != (
Image *) NULL);
905 assert(duplicate->signature == MagickCoreSignature);
906 if (IsEventLogging() != MagickFalse)
907 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
909 image->blob=ReferenceBlob(duplicate->blob);
935 MagickExport
int EOFBlob(
const Image *image)
938 *magick_restrict blob_info;
940 assert(image != (
Image *) NULL);
941 assert(image->signature == MagickCoreSignature);
942 assert(image->blob != (
BlobInfo *) NULL);
943 assert(image->blob->type != UndefinedStream);
944 if (IsEventLogging() != MagickFalse)
945 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"...");
946 blob_info=image->blob;
947 switch (blob_info->type)
949 case UndefinedStream:
955 blob_info->eof=feof(blob_info->file_info.file) != 0 ? MagickTrue :
961 #if defined(MAGICKCORE_ZLIB_DELEGATE)
962 blob_info->eof=gzeof(blob_info->file_info.gzfile) != 0 ? MagickTrue :
969 #if defined(MAGICKCORE_BZLIB_DELEGATE)
974 (void) BZ2_bzerror(blob_info->file_info.bzfile,&status);
975 blob_info->eof=status == BZ_UNEXPECTED_EOF ? MagickTrue : MagickFalse;
981 blob_info->eof=MagickFalse;
987 return((
int) blob_info->eof);
1013 MagickExport
int ErrorBlob(
const Image *image)
1016 *magick_restrict blob_info;
1018 assert(image != (
Image *) NULL);
1019 assert(image->signature == MagickCoreSignature);
1020 assert(image->blob != (
BlobInfo *) NULL);
1021 assert(image->blob->type != UndefinedStream);
1022 if (IsEventLogging() != MagickFalse)
1023 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"...");
1024 blob_info=image->blob;
1025 switch (blob_info->type)
1027 case UndefinedStream:
1028 case StandardStream:
1033 blob_info->error=ferror(blob_info->file_info.file);
1038 #if defined(MAGICKCORE_ZLIB_DELEGATE)
1039 (void) gzerror(blob_info->file_info.gzfile,&blob_info->error);
1045 #if defined(MAGICKCORE_BZLIB_DELEGATE)
1046 (void) BZ2_bzerror(blob_info->file_info.bzfile,&blob_info->error);
1058 return(blob_info->error);
1096 MagickExport
unsigned char *FileToBlob(
const char *filename,
const size_t extent,
1123 assert(filename != (
const char *) NULL);
1125 assert(exception->signature == MagickCoreSignature);
1126 if (IsEventLogging() != MagickFalse)
1127 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",filename);
1129 status=IsRightsAuthorized(PathPolicyDomain,ReadPolicyRights,filename);
1130 if (status == MagickFalse)
1133 (void) ThrowMagickException(exception,GetMagickModule(),PolicyError,
1134 "NotAuthorized",
"`%s'",filename);
1138 if (LocaleCompare(filename,
"-") != 0)
1140 status=GetPathAttributes(filename,&attributes);
1141 if ((status == MagickFalse) || (S_ISDIR(attributes.st_mode) != 0))
1143 ThrowFileException(exception,BlobError,
"UnableToReadBlob",filename);
1146 file=open_utf8(filename,O_RDONLY | O_BINARY,0);
1150 ThrowFileException(exception,BlobError,
"UnableToOpenFile",filename);
1151 return((
unsigned char *) NULL);
1153 offset=(MagickOffsetType) lseek(file,0,SEEK_END);
1155 if ((file == fileno(stdin)) || (offset < 0) ||
1156 (offset != (MagickOffsetType) ((ssize_t) offset)))
1167 offset=(MagickOffsetType) lseek(file,0,SEEK_SET);
1168 quantum=(size_t) MagickMaxBufferExtent;
1169 if ((fstat(file,&file_stats) == 0) && (file_stats.st_size > 0))
1170 quantum=(
size_t) MagickMin(file_stats.st_size,MagickMaxBufferExtent);
1171 blob=(
unsigned char *) AcquireQuantumMemory(quantum,
sizeof(*blob));
1172 for (i=0; blob != (
unsigned char *) NULL; i+=count)
1174 count=read(file,blob+i,quantum);
1181 if (~((
size_t) i) < (count+quantum+1))
1183 blob=(
unsigned char *) RelinquishMagickMemory(blob);
1186 blob=(
unsigned char *) ResizeQuantumMemory(blob,i+count+quantum+1,
1188 if ((
size_t) (i+count) >= extent)
1191 if (LocaleCompare(filename,
"-") != 0)
1193 if (blob == (
unsigned char *) NULL)
1195 (void) ThrowMagickException(exception,GetMagickModule(),
1196 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",filename);
1197 return((
unsigned char *) NULL);
1201 blob=(
unsigned char *) RelinquishMagickMemory(blob);
1202 ThrowFileException(exception,BlobError,
"UnableToReadBlob",filename);
1203 return((
unsigned char *) NULL);
1205 *length=(size_t) MagickMin(i+count,extent);
1209 *length=(size_t) MagickMin(offset,(MagickOffsetType)
1210 MagickMin(extent,(
size_t) MAGICK_SSIZE_MAX));
1211 blob=(
unsigned char *) NULL;
1212 if (~(*length) >= (MagickPathExtent-1))
1213 blob=(
unsigned char *) AcquireQuantumMemory(*length+MagickPathExtent,
1215 if (blob == (
unsigned char *) NULL)
1218 (void) ThrowMagickException(exception,GetMagickModule(),
1219 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",filename);
1220 return((
unsigned char *) NULL);
1222 map=MapBlob(file,ReadMode,0,*length);
1223 if (map != (
unsigned char *) NULL)
1225 (void) memcpy(blob,map,*length);
1226 (void) UnmapBlob(map,*length);
1230 (void) lseek(file,0,SEEK_SET);
1231 for (i=0; i < *length; i+=count)
1233 count=read(file,blob+i,(
size_t) MagickMin(*length-i,(
size_t)
1245 blob=(
unsigned char *) RelinquishMagickMemory(blob);
1246 ThrowFileException(exception,BlobError,
"UnableToReadBlob",filename);
1247 return((
unsigned char *) NULL);
1251 if (LocaleCompare(filename,
"-") != 0)
1255 blob=(
unsigned char *) RelinquishMagickMemory(blob);
1256 ThrowFileException(exception,BlobError,
"UnableToReadBlob",filename);
1286 static inline ssize_t WriteBlobStream(
Image *image,
const size_t length,
1287 const unsigned char *magick_restrict data)
1290 *magick_restrict blob_info;
1298 assert(image->blob != (
BlobInfo *) NULL);
1299 assert(image->blob->type != UndefinedStream);
1300 assert(data != (
void *) NULL);
1301 blob_info=image->blob;
1302 if (blob_info->type != BlobStream)
1303 return(WriteBlob(image,length,data));
1304 extent=(MagickSizeType) (blob_info->offset+(MagickOffsetType) length);
1305 if (extent >= blob_info->extent)
1307 extent=blob_info->extent+blob_info->quantum+length;
1308 blob_info->quantum<<=1;
1309 if (SetBlobExtent(image,extent) == MagickFalse)
1312 q=blob_info->data+blob_info->offset;
1313 (void) memcpy(q,data,length);
1314 blob_info->offset+=length;
1315 if (blob_info->offset >= (MagickOffsetType) blob_info->length)
1316 blob_info->length=(
size_t) blob_info->offset;
1317 return((ssize_t) length);
1320 MagickExport MagickBooleanType FileToImage(
Image *image,
const char *filename)
1341 assert(image != (
const Image *) NULL);
1342 assert(image->signature == MagickCoreSignature);
1343 assert(filename != (
const char *) NULL);
1344 if (IsEventLogging() != MagickFalse)
1345 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",filename);
1346 status=IsRightsAuthorized(PathPolicyDomain,WritePolicyRights,filename);
1347 if (status == MagickFalse)
1350 (void) ThrowMagickException(&image->exception,GetMagickModule(),
1351 PolicyError,
"NotAuthorized",
"`%s'",filename);
1352 return(MagickFalse);
1355 if (LocaleCompare(filename,
"-") != 0)
1356 file=open_utf8(filename,O_RDONLY | O_BINARY,0);
1359 ThrowFileException(&image->exception,BlobError,
"UnableToOpenBlob",
1361 return(MagickFalse);
1363 quantum=(size_t) MagickMaxBufferExtent;
1364 if ((fstat(file,&file_stats) == 0) && (file_stats.st_size > 0))
1365 quantum=(size_t) MagickMin(file_stats.st_size,MagickMaxBufferExtent);
1366 blob=(
unsigned char *) AcquireQuantumMemory(quantum,
sizeof(*blob));
1367 if (blob == (
unsigned char *) NULL)
1370 ThrowFileException(&image->exception,ResourceLimitError,
1371 "MemoryAllocationFailed",filename);
1372 return(MagickFalse);
1376 count=read(file,blob,quantum);
1383 length=(size_t) count;
1384 count=WriteBlobStream(image,length,blob);
1385 if (count != (ssize_t) length)
1387 ThrowFileException(&image->exception,BlobError,
"UnableToWriteBlob",
1394 ThrowFileException(&image->exception,BlobError,
"UnableToWriteBlob",
1396 blob=(
unsigned char *) RelinquishMagickMemory(blob);
1423 MagickExport MagickBooleanType GetBlobError(
const Image *image)
1425 assert(image != (
const Image *) NULL);
1426 assert(image->signature == MagickCoreSignature);
1427 if (IsEventLogging() != MagickFalse)
1428 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1429 if ((image->blob->status != MagickFalse) && (image->blob->error_number != 0))
1430 errno=image->blob->error_number;
1431 return(image->blob->status);
1456 MagickExport FILE *GetBlobFileHandle(
const Image *image)
1458 assert(image != (
const Image *) NULL);
1459 assert(image->signature == MagickCoreSignature);
1460 return(image->blob->file_info.file);
1485 MagickExport
void GetBlobInfo(
BlobInfo *blob_info)
1487 assert(blob_info != (
BlobInfo *) NULL);
1488 (void) memset(blob_info,0,
sizeof(*blob_info));
1489 blob_info->type=UndefinedStream;
1490 blob_info->quantum=(size_t) MagickMaxBlobExtent;
1491 blob_info->properties.st_mtime=GetMagickTime();
1492 blob_info->properties.st_ctime=blob_info->properties.st_mtime;
1493 blob_info->debug=GetLogEventMask() & BlobEvent ? MagickTrue : MagickFalse;
1494 blob_info->reference_count=1;
1495 blob_info->semaphore=AllocateSemaphoreInfo();
1496 blob_info->signature=MagickCoreSignature;
1521 MagickExport
const struct stat *GetBlobProperties(
const Image *image)
1523 assert(image != (
Image *) NULL);
1524 assert(image->signature == MagickCoreSignature);
1525 if (IsEventLogging() != MagickFalse)
1526 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1527 return(&image->blob->properties);
1553 MagickExport MagickSizeType GetBlobSize(
const Image *image)
1556 *magick_restrict blob_info;
1561 assert(image != (
Image *) NULL);
1562 assert(image->signature == MagickCoreSignature);
1563 assert(image->blob != (
BlobInfo *) NULL);
1564 if (IsEventLogging() != MagickFalse)
1565 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1566 blob_info=image->blob;
1568 switch (blob_info->type)
1570 case UndefinedStream:
1571 case StandardStream:
1573 extent=blob_info->size;
1581 extent=(MagickSizeType) blob_info->properties.st_size;
1583 extent=blob_info->size;
1584 file_descriptor=fileno(blob_info->file_info.file);
1585 if (file_descriptor == -1)
1587 if (fstat(file_descriptor,&blob_info->properties) == 0)
1588 extent=(MagickSizeType) blob_info->properties.st_size;
1593 extent=blob_info->size;
1602 status=GetPathAttributes(image->filename,&blob_info->properties);
1603 if (status != MagickFalse)
1604 extent=(MagickSizeType) blob_info->properties.st_size;
1611 extent=(MagickSizeType) blob_info->length;
1640 MagickExport
unsigned char *GetBlobStreamData(
const Image *image)
1642 assert(image != (
const Image *) NULL);
1643 assert(image->signature == MagickCoreSignature);
1644 return(image->blob->data);
1669 MagickExport StreamHandler GetBlobStreamHandler(
const Image *image)
1671 assert(image != (
const Image *) NULL);
1672 assert(image->signature == MagickCoreSignature);
1673 if (IsEventLogging() != MagickFalse)
1674 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
1675 return(image->blob->stream);
1711 MagickExport
unsigned char *ImageToBlob(
const ImageInfo *image_info,
1726 assert(image_info != (
const ImageInfo *) NULL);
1727 assert(image_info->signature == MagickCoreSignature);
1728 assert(image != (
Image *) NULL);
1729 assert(image->signature == MagickCoreSignature);
1731 assert(exception->signature == MagickCoreSignature);
1732 if (IsEventLogging() != MagickFalse)
1733 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
1734 image_info->filename);
1736 blob=(
unsigned char *) NULL;
1737 blob_info=CloneImageInfo(image_info);
1738 blob_info->adjoin=MagickFalse;
1739 (void) SetImageInfo(blob_info,1,exception);
1740 if (*blob_info->magick !=
'\0')
1741 (void) CopyMagickString(image->magick,blob_info->magick,MagickPathExtent);
1742 magick_info=GetMagickInfo(image->magick,exception);
1743 if (magick_info == (
const MagickInfo *) NULL)
1745 (void) ThrowMagickException(exception,GetMagickModule(),
1746 MissingDelegateError,
"NoDecodeDelegateForThisImageFormat",
"`%s'",
1748 blob_info=DestroyImageInfo(blob_info);
1751 (void) CopyMagickString(blob_info->magick,image->magick,MagickPathExtent);
1752 if (GetMagickBlobSupport(magick_info) != MagickFalse)
1757 blob_info->length=0;
1758 blob_info->blob=AcquireQuantumMemory(MagickMaxBlobExtent,
1759 sizeof(
unsigned char));
1760 if (blob_info->blob == NULL)
1761 (void) ThrowMagickException(exception,GetMagickModule(),
1762 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",image->filename);
1765 (void) CloseBlob(image);
1766 image->blob->exempt=MagickTrue;
1767 *image->filename=
'\0';
1768 status=WriteImage(blob_info,image);
1769 InheritException(exception,&image->exception);
1770 *length=image->blob->length;
1771 blob=DetachBlob(image->blob);
1772 if (blob != (
void *) NULL)
1774 if (status == MagickFalse)
1775 blob=(
unsigned char *) RelinquishMagickMemory(blob);
1777 blob=(
unsigned char *) ResizeQuantumMemory(blob,*length+1,
1778 sizeof(
unsigned char));
1785 unique[MagickPathExtent];
1793 file=AcquireUniqueFileResource(unique);
1796 ThrowFileException(exception,BlobError,
"UnableToWriteBlob",
1797 image_info->filename);
1801 blob_info->file=fdopen(file,
"wb");
1802 if (blob_info->file != (FILE *) NULL)
1804 (void) FormatLocaleString(image->filename,MagickPathExtent,
1805 "%s:%s",image->magick,unique);
1806 status=WriteImage(blob_info,image);
1807 (void) CloseBlob(image);
1808 (void) fclose(blob_info->file);
1809 if (status == MagickFalse)
1810 InheritException(exception,&image->exception);
1812 blob=FileToBlob(unique,~0UL,length,exception);
1814 (void) RelinquishUniqueFileResource(unique);
1817 blob_info=DestroyImageInfo(blob_info);
1849 MagickExport MagickBooleanType ImageToFile(
Image *image,
char *filename,
1874 assert(image != (
Image *) NULL);
1875 assert(image->signature == MagickCoreSignature);
1876 assert(image->blob != (
BlobInfo *) NULL);
1877 assert(image->blob->type != UndefinedStream);
1878 assert(filename != (
const char *) NULL);
1879 if (IsEventLogging() != MagickFalse)
1880 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",filename);
1881 if (*filename ==
'\0')
1882 file=AcquireUniqueFileResource(filename);
1884 if (LocaleCompare(filename,
"-") == 0)
1885 file=fileno(stdout);
1887 file=open_utf8(filename,O_RDWR | O_CREAT | O_EXCL | O_BINARY,S_MODE);
1890 ThrowFileException(exception,BlobError,
"UnableToWriteBlob",filename);
1891 return(MagickFalse);
1893 quantum=(size_t) MagickMaxBufferExtent;
1894 if ((fstat(file,&file_stats) == 0) && (file_stats.st_size > 0))
1895 quantum=(size_t) MagickMin(file_stats.st_size,MagickMaxBufferExtent);
1896 buffer=(
unsigned char *) AcquireQuantumMemory(quantum,
sizeof(*buffer));
1897 if (buffer == (
unsigned char *) NULL)
1900 (void) ThrowMagickException(exception,GetMagickModule(),
1901 ResourceLimitError,
"MemoryAllocationError",
"`%s'",filename);
1902 return(MagickFalse);
1905 p=(
const unsigned char *) ReadBlobStream(image,quantum,buffer,&count);
1906 for (i=0; count > 0; )
1908 length=(size_t) count;
1909 for (i=0; i < length; i+=count)
1911 count=write(file,p+i,(
size_t) (length-i));
1921 p=(
const unsigned char *) ReadBlobStream(image,quantum,buffer,&count);
1923 if (LocaleCompare(filename,
"-") != 0)
1925 buffer=(
unsigned char *) RelinquishMagickMemory(buffer);
1926 if ((file == -1) || (i < length))
1930 ThrowFileException(exception,BlobError,
"UnableToWriteBlob",filename);
1931 return(MagickFalse);
1971 MagickExport
unsigned char *ImagesToBlob(
const ImageInfo *image_info,
1986 assert(image_info != (
const ImageInfo *) NULL);
1987 assert(image_info->signature == MagickCoreSignature);
1988 assert(images != (
Image *) NULL);
1989 assert(images->signature == MagickCoreSignature);
1991 if (IsEventLogging() != MagickFalse)
1992 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
1993 image_info->filename);
1995 blob=(
unsigned char *) NULL;
1996 blob_info=CloneImageInfo(image_info);
1997 (void) SetImageInfo(blob_info,(
unsigned int) GetImageListLength(images),
1999 if (*blob_info->magick !=
'\0')
2000 (void) CopyMagickString(images->magick,blob_info->magick,MagickPathExtent);
2001 magick_info=GetMagickInfo(images->magick,exception);
2002 if (magick_info == (
const MagickInfo *) NULL)
2004 (void) ThrowMagickException(exception,GetMagickModule(),
2005 MissingDelegateError,
"NoDecodeDelegateForThisImageFormat",
"`%s'",
2007 blob_info=DestroyImageInfo(blob_info);
2010 if (GetMagickAdjoin(magick_info) == MagickFalse)
2012 blob_info=DestroyImageInfo(blob_info);
2013 return(ImageToBlob(image_info,images,length,exception));
2015 (void) CopyMagickString(blob_info->magick,images->magick,MagickPathExtent);
2016 if (GetMagickBlobSupport(magick_info) != MagickFalse)
2021 blob_info->length=0;
2022 blob_info->blob=(
void *) AcquireQuantumMemory(MagickMaxBlobExtent,
2023 sizeof(
unsigned char));
2024 if (blob_info->blob == (
void *) NULL)
2025 (
void) ThrowMagickException(exception,GetMagickModule(),
2026 ResourceLimitError,
"MemoryAllocationFailed",
"`%s'",images->filename);
2029 (void) CloseBlob(images);
2030 images->blob->exempt=MagickTrue;
2031 *images->filename=
'\0';
2032 status=WriteImages(blob_info,images,images->filename,exception);
2033 *length=images->blob->length;
2034 blob=DetachBlob(images->blob);
2035 if (blob != (
void *) NULL)
2037 if (status == MagickFalse)
2038 blob=(
unsigned char *) RelinquishMagickMemory(blob);
2040 blob=(
unsigned char *) ResizeQuantumMemory(blob,*length+1,
2041 sizeof(
unsigned char));
2048 filename[MagickPathExtent],
2049 unique[MagickPathExtent];
2057 file=AcquireUniqueFileResource(unique);
2060 ThrowFileException(exception,FileOpenError,
"UnableToWriteBlob",
2061 image_info->filename);
2065 blob_info->file=fdopen(file,
"wb");
2066 if (blob_info->file != (FILE *) NULL)
2068 (void) FormatLocaleString(filename,MagickPathExtent,
"%s:%s",
2069 images->magick,unique);
2070 status=WriteImages(blob_info,images,filename,exception);
2071 (void) CloseBlob(images);
2072 (void) fclose(blob_info->file);
2073 if (status == MagickFalse)
2074 InheritException(exception,&images->exception);
2076 blob=FileToBlob(unique,~0UL,length,exception);
2078 (void) RelinquishUniqueFileResource(unique);
2081 blob_info=DestroyImageInfo(blob_info);
2117 MagickExport MagickBooleanType InjectImageBlob(
const ImageInfo *image_info,
2121 filename[MagickPathExtent];
2150 assert(image_info != (
ImageInfo *) NULL);
2151 assert(image_info->signature == MagickCoreSignature);
2152 assert(image != (
Image *) NULL);
2153 assert(image->signature == MagickCoreSignature);
2154 assert(inject_image != (
Image *) NULL);
2155 assert(inject_image->signature == MagickCoreSignature);
2157 if (IsEventLogging() != MagickFalse)
2158 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2159 unique_file=(FILE *) NULL;
2160 file=AcquireUniqueFileResource(filename);
2162 unique_file=fdopen(file,
"wb");
2163 if ((file == -1) || (unique_file == (FILE *) NULL))
2165 (void) CopyMagickString(image->filename,filename,MagickPathExtent);
2166 ThrowFileException(exception,FileOpenError,
"UnableToCreateTemporaryFile",
2168 return(MagickFalse);
2170 byte_image=CloneImage(inject_image,0,0,MagickFalse,exception);
2171 if (byte_image == (
Image *) NULL)
2173 (void) fclose(unique_file);
2174 (void) RelinquishUniqueFileResource(filename);
2175 return(MagickFalse);
2177 (void) FormatLocaleString(byte_image->filename,MagickPathExtent,
"%s:%s",
2179 DestroyBlob(byte_image);
2180 byte_image->blob=CloneBlobInfo((
BlobInfo *) NULL);
2181 write_info=CloneImageInfo(image_info);
2182 SetImageInfoFile(write_info,unique_file);
2183 status=WriteImage(write_info,byte_image);
2184 write_info=DestroyImageInfo(write_info);
2185 byte_image=DestroyImage(byte_image);
2186 (void) fclose(unique_file);
2187 if (status == MagickFalse)
2189 (void) RelinquishUniqueFileResource(filename);
2190 return(MagickFalse);
2195 file=open_utf8(filename,O_RDONLY | O_BINARY,0);
2198 (void) RelinquishUniqueFileResource(filename);
2199 ThrowFileException(exception,FileOpenError,
"UnableToOpenFile",
2200 image_info->filename);
2201 return(MagickFalse);
2203 quantum=(size_t) MagickMaxBufferExtent;
2204 if ((fstat(file,&file_stats) == 0) && (file_stats.st_size > 0))
2205 quantum=(size_t) MagickMin(file_stats.st_size,MagickMaxBufferExtent);
2206 buffer=(
unsigned char *) AcquireQuantumMemory(quantum,
sizeof(*buffer));
2207 if (buffer == (
unsigned char *) NULL)
2209 (void) RelinquishUniqueFileResource(filename);
2211 ThrowBinaryException(ResourceLimitError,
"MemoryAllocationFailed",
2216 ssize_t count = read(file,buffer,quantum);
2223 status=WriteBlobStream(image,(
size_t) count,buffer) == count ? MagickTrue :
2228 ThrowFileException(exception,FileOpenError,
"UnableToWriteBlob",filename);
2229 (void) RelinquishUniqueFileResource(filename);
2230 buffer=(
unsigned char *) RelinquishMagickMemory(buffer);
2256 MagickExport MagickBooleanType IsBlobExempt(
const Image *image)
2258 assert(image != (
const Image *) NULL);
2259 assert(image->signature == MagickCoreSignature);
2260 if (IsEventLogging() != MagickFalse)
2261 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2262 return(image->blob->exempt);
2287 MagickExport MagickBooleanType IsBlobSeekable(
const Image *image)
2290 *magick_restrict blob_info;
2292 assert(image != (
const Image *) NULL);
2293 assert(image->signature == MagickCoreSignature);
2294 if (IsEventLogging() != MagickFalse)
2295 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2296 blob_info=image->blob;
2297 switch (blob_info->type)
2306 if (blob_info->file_info.file == (FILE *) NULL)
2307 return(MagickFalse);
2308 status=fseek(blob_info->file_info.file,0,SEEK_CUR);
2309 return(status == -1 ? MagickFalse : MagickTrue);
2313 #if defined(MAGICKCORE_ZLIB_DELEGATE)
2317 if (blob_info->file_info.gzfile == (gzFile) NULL)
2318 return(MagickFalse);
2319 offset=gzseek(blob_info->file_info.gzfile,0,SEEK_CUR);
2320 return(offset < 0 ? MagickFalse : MagickTrue);
2325 case UndefinedStream:
2329 case StandardStream:
2334 return(MagickFalse);
2359 MagickExport MagickBooleanType IsBlobTemporary(
const Image *image)
2361 assert(image != (
const Image *) NULL);
2362 assert(image->signature == MagickCoreSignature);
2363 if (IsEventLogging() != MagickFalse)
2364 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
2365 return(image->blob->temporary);
2397 MagickExport
unsigned char *MapBlob(
int file,
const MapMode mode,
2398 const MagickOffsetType offset,
const size_t length)
2400 #if defined(MAGICKCORE_HAVE_MMAP)
2413 #if defined(MAP_ANONYMOUS)
2414 flags|=MAP_ANONYMOUS;
2416 return((
unsigned char *) NULL);
2423 protection=PROT_READ;
2429 protection=PROT_WRITE;
2435 protection=PROT_READ | PROT_WRITE;
2440 #if !defined(MAGICKCORE_HAVE_HUGEPAGES) || !defined(MAP_HUGETLB)
2441 map=(
unsigned char *) mmap((
char *) NULL,length,protection,flags,file,offset);
2443 map=(
unsigned char *) mmap((
char *) NULL,length,protection,flags |
2444 MAP_HUGETLB,file,offset);
2445 if (map == (
unsigned char *) MAP_FAILED)
2446 map=(
unsigned char *) mmap((
char *) NULL,length,protection,flags,file,
2449 if (map == (
unsigned char *) MAP_FAILED)
2450 return((
unsigned char *) NULL);
2457 return((
unsigned char *) NULL);
2486 MagickExport
void MSBOrderLong(
unsigned char *buffer,
const size_t length)
2495 assert(buffer != (
unsigned char *) NULL);
2502 *buffer++=(
unsigned char) c;
2506 *buffer++=(
unsigned char) c;
2536 MagickExport
void MSBOrderShort(
unsigned char *p,
const size_t length)
2544 assert(p != (
unsigned char *) NULL);
2551 *p++=(
unsigned char) c;
2587 static inline MagickBooleanType SetStreamBuffering(
const ImageInfo *image_info,
2599 size=MagickMinBufferExtent;
2600 option=GetImageOption(image_info,
"stream:buffer-size");
2601 if (option != (
const char *) NULL)
2602 size=StringToUnsignedLong(option);
2603 status=setvbuf(image->blob->file_info.file,(
char *) NULL,size == 0 ?
2604 _IONBF : _IOFBF,size);
2605 return(status == 0 ? MagickTrue : MagickFalse);
2608 #if defined(MAGICKCORE_ZLIB_DELEGATE)
2609 static inline gzFile gzopen_utf8(
const char *path,
const char *mode)
2611 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__)
2612 return(gzopen(path,mode));
2620 path_wide=create_wchar_path(path);
2621 if (path_wide == (
wchar_t *) NULL)
2622 return((gzFile) NULL);
2623 file=gzopen_w(path_wide,mode);
2624 path_wide=(
wchar_t *) RelinquishMagickMemory(path_wide);
2630 MagickExport MagickBooleanType OpenBlob(
const ImageInfo *image_info,
2634 *magick_restrict blob_info;
2637 extension[MagickPathExtent],
2638 filename[MagickPathExtent];
2649 assert(image_info != (
ImageInfo *) NULL);
2650 assert(image_info->signature == MagickCoreSignature);
2651 assert(image != (
Image *) NULL);
2652 assert(image->signature == MagickCoreSignature);
2653 if (IsEventLogging() != MagickFalse)
2654 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
2655 image_info->filename);
2656 blob_info=image->blob;
2657 if (image_info->blob != (
void *) NULL)
2659 if (image_info->stream != (StreamHandler) NULL)
2660 blob_info->stream=(StreamHandler) image_info->stream;
2661 AttachBlob(blob_info,image_info->blob,image_info->length);
2664 (void) DetachBlob(blob_info);
2665 blob_info->mode=mode;
2668 default: type=
"r";
break;
2669 case ReadBlobMode: type=
"r";
break;
2670 case ReadBinaryBlobMode: type=
"rb";
break;
2671 case WriteBlobMode: type=
"w";
break;
2672 case WriteBinaryBlobMode: type=
"w+b";
break;
2673 case AppendBlobMode: type=
"a";
break;
2674 case AppendBinaryBlobMode: type=
"a+b";
break;
2677 blob_info->synchronize=image_info->synchronize;
2678 if (image_info->stream != (StreamHandler) NULL)
2680 blob_info->stream=(StreamHandler) image_info->stream;
2683 blob_info->type=FifoStream;
2691 (void) CopyMagickString(filename,image->filename,MagickPathExtent);
2692 rights=ReadPolicyRights;
2694 rights=WritePolicyRights;
2695 if (IsRightsAuthorized(PathPolicyDomain,rights,filename) == MagickFalse)
2698 (void) ThrowMagickException(exception,GetMagickModule(),PolicyError,
2699 "NotAuthorized",
"`%s'",filename);
2700 return(MagickFalse);
2702 if ((LocaleCompare(filename,
"-") == 0) ||
2703 ((*filename ==
'\0') && (image_info->file == (FILE *) NULL)))
2705 blob_info->file_info.file=(*type ==
'r') ? stdin : stdout;
2706 #if defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__OS2__)
2707 if (strchr(type,
'b') != (
char *) NULL)
2708 (void) setmode(fileno(blob_info->file_info.file),_O_BINARY);
2710 blob_info->type=StandardStream;
2711 blob_info->exempt=MagickTrue;
2712 return(SetStreamBuffering(image_info,image));
2714 if ((LocaleNCompare(filename,
"fd:",3) == 0) &&
2715 (IsGeometry(filename+3) != MagickFalse))
2718 fileMode[MagickPathExtent];
2722 blob_info->file_info.file=fdopen(StringToLong(filename+3),fileMode);
2723 if (blob_info->file_info.file == (FILE *) NULL)
2725 ThrowFileException(exception,BlobError,
"UnableToOpenBlob",filename);
2726 return(MagickFalse);
2728 #if defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__OS2__)
2729 if (strchr(type,
'b') != (
char *) NULL)
2730 (void) setmode(fileno(blob_info->file_info.file),_O_BINARY);
2732 blob_info->type=FileStream;
2733 blob_info->exempt=MagickTrue;
2734 return(SetStreamBuffering(image_info,image));
2736 #if defined(MAGICKCORE_HAVE_POPEN) && defined(MAGICKCORE_PIPES_SUPPORT)
2737 if (*filename ==
'|')
2740 fileMode[MagickPathExtent],
2746 #if defined(SIGPIPE)
2748 (void) signal(SIGPIPE,SIG_IGN);
2752 sanitize_command=SanitizeString(filename+1);
2753 blob_info->file_info.file=(FILE *) popen_utf8(sanitize_command,
2755 sanitize_command=DestroyString(sanitize_command);
2756 if (blob_info->file_info.file == (FILE *) NULL)
2758 ThrowFileException(exception,BlobError,
"UnableToOpenBlob",filename);
2759 return(MagickFalse);
2761 blob_info->type=PipeStream;
2762 blob_info->exempt=MagickTrue;
2763 return(SetStreamBuffering(image_info,image));
2766 status=GetPathAttributes(filename,&blob_info->properties);
2767 #if defined(S_ISFIFO)
2768 if ((status != MagickFalse) && S_ISFIFO(blob_info->properties.st_mode))
2770 blob_info->file_info.file=(FILE *) fopen_utf8(filename,type);
2771 if (blob_info->file_info.file == (FILE *) NULL)
2773 ThrowFileException(exception,BlobError,
"UnableToOpenBlob",filename);
2774 return(MagickFalse);
2776 blob_info->type=FileStream;
2777 blob_info->exempt=MagickTrue;
2778 return(SetStreamBuffering(image_info,image));
2781 GetPathComponent(image->filename,ExtensionPath,extension);
2784 (void) CopyMagickString(filename,image->filename,MagickPathExtent);
2785 if ((image_info->adjoin == MagickFalse) ||
2786 (strchr(filename,
'%') != (
char *) NULL))
2791 (void) InterpretImageFilename(image_info,image,image->filename,(
int)
2792 image->scene,filename);
2793 if ((LocaleCompare(filename,image->filename) == 0) &&
2794 ((GetPreviousImageInList(image) != (
Image *) NULL) ||
2795 (GetNextImageInList(image) != (
Image *) NULL)))
2798 path[MagickPathExtent];
2800 GetPathComponent(image->filename,RootPath,path);
2801 if (*extension ==
'\0')
2802 (void) FormatLocaleString(filename,MagickPathExtent,
"%s-%.20g",
2803 path,(
double) image->scene);
2805 (
void) FormatLocaleString(filename,MagickPathExtent,
2806 "%s-%.20g.%s",path,(
double) image->scene,extension);
2808 (void) CopyMagickString(image->filename,filename,MagickPathExtent);
2809 #if defined(macintosh)
2810 SetApplicationType(filename,image_info->magick,
'8BIM');
2814 if (image_info->file != (FILE *) NULL)
2816 blob_info->file_info.file=image_info->file;
2817 blob_info->type=FileStream;
2818 blob_info->exempt=MagickTrue;
2823 blob_info->file_info.file=(FILE *) fopen_utf8(filename,type);
2824 if (blob_info->file_info.file != (FILE *) NULL)
2832 blob_info->type=FileStream;
2833 (void) fstat(fileno(blob_info->file_info.file),
2834 &blob_info->properties);
2835 (void) SetStreamBuffering(image_info,image);
2836 (void) memset(magick,0,
sizeof(magick));
2837 count=fread(magick,1,
sizeof(magick),blob_info->file_info.file);
2838 (void) fseek(blob_info->file_info.file,-((off_t) count),SEEK_CUR);
2839 #if defined(MAGICKCORE_POSIX_SUPPORT)
2840 (void) fflush(blob_info->file_info.file);
2842 (void) LogMagickEvent(BlobEvent,GetMagickModule(),
2843 " read %.20g magic header bytes",(double) count);
2844 #if defined(MAGICKCORE_ZLIB_DELEGATE)
2845 if (((
int) magick[0] == 0x1F) && ((
int) magick[1] == 0x8B) &&
2846 ((
int) magick[2] == 0x08))
2849 gzfile = gzopen_utf8(filename,
"rb");
2851 if (gzfile != (gzFile) NULL)
2853 if (blob_info->file_info.file != (FILE *) NULL)
2854 (void) fclose(blob_info->file_info.file);
2855 blob_info->file_info.file=(FILE *) NULL;
2856 blob_info->file_info.gzfile=gzfile;
2857 blob_info->type=ZipStream;
2861 #if defined(MAGICKCORE_BZLIB_DELEGATE)
2862 if (strncmp((
char *) magick,
"BZh",3) == 0)
2865 *bzfile = BZ2_bzopen(filename,
"r");
2867 if (bzfile != (BZFILE *) NULL)
2869 if (blob_info->file_info.file != (FILE *) NULL)
2870 (void) fclose(blob_info->file_info.file);
2871 blob_info->file_info.file=(FILE *) NULL;
2872 blob_info->file_info.bzfile=bzfile;
2873 blob_info->type=BZipStream;
2877 if (blob_info->type == FileStream)
2888 sans_exception=AcquireExceptionInfo();
2889 magick_info=GetMagickInfo(image_info->magick,sans_exception);
2890 sans_exception=DestroyExceptionInfo(sans_exception);
2891 length=(size_t) blob_info->properties.st_size;
2892 if ((magick_info != (
const MagickInfo *) NULL) &&
2893 (GetMagickBlobSupport(magick_info) != MagickFalse) &&
2894 (length > MagickMaxBufferExtent) &&
2895 (AcquireMagickResource(MapResource,length) != MagickFalse))
2900 blob=MapBlob(fileno(blob_info->file_info.file),ReadMode,0,
2902 if (blob == (
void *) NULL)
2903 RelinquishMagickResource(MapResource,length);
2909 if (image_info->file != (FILE *) NULL)
2910 blob_info->exempt=MagickFalse;
2913 (void) fclose(blob_info->file_info.file);
2914 blob_info->file_info.file=(FILE *) NULL;
2916 AttachBlob(blob_info,blob,length);
2917 blob_info->mapped=MagickTrue;
2924 #if defined(MAGICKCORE_ZLIB_DELEGATE)
2925 if ((LocaleCompare(extension,
"gz") == 0) ||
2926 (LocaleCompare(extension,
"wmz") == 0) ||
2927 (LocaleCompare(extension,
"svgz") == 0))
2929 blob_info->file_info.gzfile=gzopen_utf8(filename,
"wb");
2930 if (blob_info->file_info.gzfile != (gzFile) NULL)
2931 blob_info->type=ZipStream;
2935 #if defined(MAGICKCORE_BZLIB_DELEGATE)
2936 if (LocaleCompare(extension,
"bz2") == 0)
2938 if (mode == WriteBinaryBlobMode)
2940 blob_info->file_info.bzfile=BZ2_bzopen(filename,
"w");
2941 if (blob_info->file_info.bzfile != (BZFILE *) NULL)
2942 blob_info->type=BZipStream;
2947 blob_info->file_info.file=(FILE *) fopen_utf8(filename,type);
2948 if (blob_info->file_info.file != (FILE *) NULL)
2950 blob_info->type=FileStream;
2951 (void) SetStreamBuffering(image_info,image);
2954 blob_info->status=MagickFalse;
2955 blob_info->error_number=0;
2956 if (blob_info->type != UndefinedStream)
2957 blob_info->size=GetBlobSize(image);
2960 ThrowFileException(exception,BlobError,
"UnableToOpenBlob",filename);
2961 return(MagickFalse);
3000 #if defined(__cplusplus) || defined(c_plusplus)
3004 static size_t PingStream(
const Image *magick_unused(image),
3005 const void *magick_unused(pixels),
const size_t columns)
3007 magick_unreferenced(image);
3008 magick_unreferenced(pixels);
3013 #if defined(__cplusplus) || defined(c_plusplus)
3017 MagickExport
Image *PingBlob(
const ImageInfo *image_info,
const void *blob,
3033 assert(image_info != (
ImageInfo *) NULL);
3034 assert(image_info->signature == MagickCoreSignature);
3036 if (IsEventLogging() != MagickFalse)
3037 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",
3038 image_info->filename);
3039 if ((blob == (
const void *) NULL) || (length == 0))
3041 (void) ThrowMagickException(exception,GetMagickModule(),BlobError,
3042 "ZeroLengthBlobNotPermitted",
"`%s'",image_info->filename);
3043 return((
Image *) NULL);
3045 ping_info=CloneImageInfo(image_info);
3046 ping_info->blob=(
void *) blob;
3047 ping_info->length=length;
3048 ping_info->ping=MagickTrue;
3049 if (*ping_info->magick ==
'\0')
3050 (void) SetImageInfo(ping_info,0,exception);
3051 magick_info=GetMagickInfo(ping_info->magick,exception);
3052 if (magick_info == (
const MagickInfo *) NULL)
3054 (void) ThrowMagickException(exception,GetMagickModule(),
3055 MissingDelegateError,
"NoDecodeDelegateForThisImageFormat",
"`%s'",
3057 ping_info=DestroyImageInfo(ping_info);
3058 return((
Image *) NULL);
3060 if (GetMagickBlobSupport(magick_info) != MagickFalse)
3063 filename[MagickPathExtent];
3068 (void) CopyMagickString(filename,ping_info->filename,MagickPathExtent);
3069 (void) FormatLocaleString(ping_info->filename,MagickPathExtent,
"%s:%s",
3070 ping_info->magick,filename);
3071 image=ReadStream(ping_info,&PingStream,exception);
3072 if (image != (
Image *) NULL)
3073 (void) DetachBlob(image->blob);
3074 ping_info=DestroyImageInfo(ping_info);
3080 ping_info->blob=(
void *) NULL;
3081 ping_info->length=0;
3082 *ping_info->filename=
'\0';
3083 status=BlobToFile(ping_info->filename,blob,length,exception);
3084 if (status == MagickFalse)
3086 (void) RelinquishUniqueFileResource(ping_info->filename);
3087 ping_info=DestroyImageInfo(ping_info);
3088 return((
Image *) NULL);
3090 clone_info=CloneImageInfo(ping_info);
3091 (void) FormatLocaleString(clone_info->filename,MagickPathExtent,
"%s:%s",
3092 ping_info->magick,ping_info->filename);
3093 image=ReadStream(clone_info,&PingStream,exception);
3094 if (image != (
Image *) NULL)
3102 for (images=GetFirstImageInList(image); images != (
Image *) NULL; )
3104 (void) CopyMagickString(images->filename,image_info->filename,
3106 (void) CopyMagickString(images->magick_filename,image_info->filename,
3108 (void) CopyMagickString(images->magick,magick_info->name,
3110 images=GetNextImageInList(images);
3113 clone_info=DestroyImageInfo(clone_info);
3114 (void) RelinquishUniqueFileResource(ping_info->filename);
3115 ping_info=DestroyImageInfo(ping_info);
3150 MagickExport ssize_t ReadBlob(
Image *image,
const size_t length,
3151 unsigned char *data)
3154 *magick_restrict blob_info;
3165 assert(image != (
Image *) NULL);
3166 assert(image->signature == MagickCoreSignature);
3167 assert(image->blob != (
BlobInfo *) NULL);
3168 assert(image->blob->type != UndefinedStream);
3171 assert(data != (
void *) NULL);
3172 blob_info=image->blob;
3175 switch (blob_info->type)
3177 case UndefinedStream:
3179 case StandardStream:
3187 count=(ssize_t) fread(q,1,length,blob_info->file_info.file);
3192 c=getc(blob_info->file_info.file);
3195 *q++=(
unsigned char) c;
3201 c=getc(blob_info->file_info.file);
3204 *q++=(
unsigned char) c;
3210 c=getc(blob_info->file_info.file);
3213 *q++=(
unsigned char) c;
3219 c=getc(blob_info->file_info.file);
3222 *q++=(
unsigned char) c;
3229 if ((count != (ssize_t) length) &&
3230 (ferror(blob_info->file_info.file) != 0))
3231 ThrowBlobException(blob_info);
3236 #if defined(MAGICKCORE_ZLIB_DELEGATE)
3247 for (i=0; i < (ssize_t) length; i+=count)
3249 count=(ssize_t) gzread(blob_info->file_info.gzfile,q+i,
3250 (
unsigned int) MagickMin(length-i,MagickMaxBufferExtent));
3263 c=gzgetc(blob_info->file_info.gzfile);
3266 *q++=(
unsigned char) c;
3272 c=gzgetc(blob_info->file_info.gzfile);
3275 *q++=(
unsigned char) c;
3281 c=gzgetc(blob_info->file_info.gzfile);
3284 *q++=(
unsigned char) c;
3290 c=gzgetc(blob_info->file_info.gzfile);
3293 *q++=(
unsigned char) c;
3301 (void) gzerror(blob_info->file_info.gzfile,&status);
3302 if ((count != (ssize_t) length) && (status != Z_OK))
3303 ThrowBlobException(blob_info);
3304 if (blob_info->eof == MagickFalse)
3305 blob_info->eof=gzeof(blob_info->file_info.gzfile) != 0 ? MagickTrue :
3312 #if defined(MAGICKCORE_BZLIB_DELEGATE)
3319 for (i=0; i < (ssize_t) length; i+=count)
3321 count=(ssize_t) BZ2_bzread(blob_info->file_info.bzfile,q+i,
3322 (
unsigned int) MagickMin(length-i,MagickMaxBufferExtent));
3332 (void) BZ2_bzerror(blob_info->file_info.bzfile,&status);
3333 if ((count != (ssize_t) length) && (status != BZ_OK))
3334 ThrowBlobException(blob_info);
3345 if (blob_info->offset >= (MagickOffsetType) blob_info->length)
3347 blob_info->eof=MagickTrue;
3350 p=blob_info->data+blob_info->offset;
3351 count=(ssize_t) MagickMin((MagickOffsetType) length,(MagickOffsetType)
3352 blob_info->length-blob_info->offset);
3353 blob_info->offset+=count;
3354 if (count != (ssize_t) length)
3355 blob_info->eof=MagickTrue;
3356 (
void) memcpy(q,p,(
size_t) count);
3385 MagickExport
int ReadBlobByte(
Image *image)
3388 *magick_restrict blob_info;
3393 assert(image != (
Image *) NULL);
3394 assert(image->signature == MagickCoreSignature);
3395 assert(image->blob != (
BlobInfo *) NULL);
3396 assert(image->blob->type != UndefinedStream);
3397 blob_info=image->blob;
3398 switch (blob_info->type)
3400 case StandardStream:
3404 c=getc(blob_info->file_info.file);
3407 if (ferror(blob_info->file_info.file) != 0)
3408 ThrowBlobException(blob_info);
3415 if (blob_info->offset >= (MagickOffsetType) blob_info->length)
3417 blob_info->eof=MagickTrue;
3420 c=(int) (*((
unsigned char *) blob_info->data+blob_info->offset));
3421 blob_info->offset++;
3432 count=ReadBlob(image,1,buffer);
3465 MagickExport
double ReadBlobDouble(
Image *image)
3476 quantum.double_value=0.0;
3477 quantum.unsigned_value=ReadBlobLongLong(image);
3478 return(quantum.double_value);
3504 MagickExport
float ReadBlobFloat(
Image *image)
3515 quantum.float_value=0.0;
3516 quantum.unsigned_value=ReadBlobLong(image);
3517 return(quantum.float_value);
3543 MagickExport
unsigned int ReadBlobLong(
Image *image)
3557 assert(image != (
Image *) NULL);
3558 assert(image->signature == MagickCoreSignature);
3560 p=(
const unsigned char *) ReadBlobStream(image,4,buffer,&count);
3563 if (image->endian == LSBEndian)
3565 value=(
unsigned int) (*p++);
3566 value|=(
unsigned int) (*p++) << 8;
3567 value|=(
unsigned int) (*p++) << 16;
3568 value|=(
unsigned int) (*p++) << 24;
3571 value=(
unsigned int) (*p++) << 24;
3572 value|=(
unsigned int) (*p++) << 16;
3573 value|=(
unsigned int) (*p++) << 8;
3574 value|=(
unsigned int) (*p++);
3601 MagickExport MagickSizeType ReadBlobLongLong(
Image *image)
3615 assert(image != (
Image *) NULL);
3616 assert(image->signature == MagickCoreSignature);
3618 p=(
const unsigned char *) ReadBlobStream(image,8,buffer,&count);
3620 return(MagickULLConstant(0));
3621 if (image->endian == LSBEndian)
3623 value=(MagickSizeType) (*p++);
3624 value|=(MagickSizeType) (*p++) << 8;
3625 value|=(MagickSizeType) (*p++) << 16;
3626 value|=(MagickSizeType) (*p++) << 24;
3627 value|=(MagickSizeType) (*p++) << 32;
3628 value|=(MagickSizeType) (*p++) << 40;
3629 value|=(MagickSizeType) (*p++) << 48;
3630 value|=(MagickSizeType) (*p++) << 56;
3633 value=(MagickSizeType) (*p++) << 56;
3634 value|=(MagickSizeType) (*p++) << 48;
3635 value|=(MagickSizeType) (*p++) << 40;
3636 value|=(MagickSizeType) (*p++) << 32;
3637 value|=(MagickSizeType) (*p++) << 24;
3638 value|=(MagickSizeType) (*p++) << 16;
3639 value|=(MagickSizeType) (*p++) << 8;
3640 value|=(MagickSizeType) (*p++);
3667 MagickExport
unsigned short ReadBlobShort(
Image *image)
3681 assert(image != (
Image *) NULL);
3682 assert(image->signature == MagickCoreSignature);
3684 p=(
const unsigned char *) ReadBlobStream(image,2,buffer,&count);
3686 return((
unsigned short) 0U);
3687 if (image->endian == LSBEndian)
3689 value=(
unsigned short) (*p++);
3690 value|=(
unsigned short) (*p++) << 8;
3693 value=(
unsigned short) ((
unsigned short) (*p++) << 8);
3694 value|=(
unsigned short) (*p++);
3721 MagickExport
unsigned int ReadBlobLSBLong(
Image *image)
3735 assert(image != (
Image *) NULL);
3736 assert(image->signature == MagickCoreSignature);
3738 p=(
const unsigned char *) ReadBlobStream(image,4,buffer,&count);
3741 value=(
unsigned int) (*p++);
3742 value|=(
unsigned int) (*p++) << 8;
3743 value|=(
unsigned int) (*p++) << 16;
3744 value|=(
unsigned int) (*p++) << 24;
3771 MagickExport
signed int ReadBlobLSBSignedLong(
Image *image)
3782 quantum.unsigned_value=ReadBlobLSBLong(image);
3783 return(quantum.signed_value);
3809 MagickExport
unsigned short ReadBlobLSBShort(
Image *image)
3823 assert(image != (
Image *) NULL);
3824 assert(image->signature == MagickCoreSignature);
3826 p=(
const unsigned char *) ReadBlobStream(image,2,buffer,&count);
3828 return((
unsigned short) 0U);
3829 value=(
unsigned short) (*p++);
3830 value|=(
unsigned short) (*p++) << 8;
3857 MagickExport
signed short ReadBlobLSBSignedShort(
Image *image)
3868 quantum.unsigned_value=ReadBlobLSBShort(image);
3869 return(quantum.signed_value);
3895 MagickExport
unsigned int ReadBlobMSBLong(
Image *image)
3909 assert(image != (
Image *) NULL);
3910 assert(image->signature == MagickCoreSignature);
3912 p=(
const unsigned char *) ReadBlobStream(image,4,buffer,&count);
3915 value=(
unsigned int) (*p++) << 24;
3916 value|=(
unsigned int) (*p++) << 16;
3917 value|=(
unsigned int) (*p++) << 8;
3918 value|=(
unsigned int) (*p++);
3945 MagickExport MagickSizeType ReadBlobMSBLongLong(
Image *image)
3959 assert(image != (
Image *) NULL);
3960 assert(image->signature == MagickCoreSignature);
3962 p=(
const unsigned char *) ReadBlobStream(image,8,buffer,&count);
3964 return(MagickULLConstant(0));
3965 value=(MagickSizeType) (*p++) << 56;
3966 value|=(MagickSizeType) (*p++) << 48;
3967 value|=(MagickSizeType) (*p++) << 40;
3968 value|=(MagickSizeType) (*p++) << 32;
3969 value|=(MagickSizeType) (*p++) << 24;
3970 value|=(MagickSizeType) (*p++) << 16;
3971 value|=(MagickSizeType) (*p++) << 8;
3972 value|=(MagickSizeType) (*p++);
3999 MagickExport
unsigned short ReadBlobMSBShort(
Image *image)
4013 assert(image != (
Image *) NULL);
4014 assert(image->signature == MagickCoreSignature);
4016 p=(
const unsigned char *) ReadBlobStream(image,2,buffer,&count);
4018 return((
unsigned short) 0U);
4019 value=(
unsigned short) ((*p++) << 8);
4020 value|=(
unsigned short) (*p++);
4047 MagickExport
signed int ReadBlobMSBSignedLong(
Image *image)
4058 quantum.unsigned_value=ReadBlobMSBLong(image);
4059 return(quantum.signed_value);
4085 MagickExport
signed short ReadBlobMSBSignedShort(
Image *image)
4096 quantum.unsigned_value=ReadBlobMSBShort(image);
4097 return(quantum.signed_value);
4123 MagickExport
signed int ReadBlobSignedLong(
Image *image)
4134 quantum.unsigned_value=ReadBlobLong(image);
4135 return(quantum.signed_value);
4161 MagickExport
signed short ReadBlobSignedShort(
Image *image)
4172 quantum.unsigned_value=ReadBlobShort(image);
4173 return(quantum.signed_value);
4211 MagickExport magick_hot_spot
const void *ReadBlobStream(
Image *image,
4212 const size_t length,
void *magick_restrict data,ssize_t *count)
4215 *magick_restrict blob_info;
4217 assert(image != (
Image *) NULL);
4218 assert(image->signature == MagickCoreSignature);
4219 assert(image->blob != (
BlobInfo *) NULL);
4220 assert(image->blob->type != UndefinedStream);
4221 assert(count != (ssize_t *) NULL);
4222 blob_info=image->blob;
4223 if (blob_info->type != BlobStream)
4225 assert(data != NULL);
4226 *count=ReadBlob(image,length,(
unsigned char *) data);
4229 if (blob_info->offset >= (MagickOffsetType) blob_info->length)
4232 blob_info->eof=MagickTrue;
4235 data=blob_info->data+blob_info->offset;
4236 *count=(ssize_t) MagickMin((MagickOffsetType) length,(MagickOffsetType)
4237 blob_info->length-blob_info->offset);
4238 blob_info->offset+=(*count);
4239 if (*count != (ssize_t) length)
4240 blob_info->eof=MagickTrue;
4269 MagickExport
char *ReadBlobString(
Image *image,
char *
string)
4272 *magick_restrict blob_info;
4280 assert(image != (
Image *) NULL);
4281 assert(image->signature == MagickCoreSignature);
4282 assert(image->blob != (
BlobInfo *) NULL);
4283 assert(image->blob->type != UndefinedStream);
4284 if (IsEventLogging() != MagickFalse)
4285 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
4287 blob_info=image->blob;
4288 switch (blob_info->type)
4290 case UndefinedStream:
4292 case StandardStream:
4295 char *p = fgets(
string,MagickPathExtent,blob_info->file_info.file);
4296 if (p == (
char *) NULL)
4298 if (ferror(blob_info->file_info.file) != 0)
4299 ThrowBlobException(blob_info);
4300 return((
char *) NULL);
4307 #if defined(MAGICKCORE_ZLIB_DELEGATE)
4308 char *p = gzgets(blob_info->file_info.gzfile,
string,MagickPathExtent);
4309 if (p == (
char *) NULL)
4312 (void) gzerror(blob_info->file_info.gzfile,&status);
4314 ThrowBlobException(blob_info);
4315 return((
char *) NULL);
4325 c=ReadBlobByte(image);
4328 blob_info->eof=MagickTrue;
4334 }
while (i < (MaxTextExtent-2));
4342 if ((
string[i] ==
'\r') || (
string[i] ==
'\n'))
4345 if ((
string[i-1] ==
'\r') || (
string[i-1] ==
'\n'))
4347 if ((*
string ==
'\0') && (blob_info->eof != MagickFalse))
4348 return((
char *) NULL);
4378 assert(blob->signature == MagickCoreSignature);
4379 if (IsEventLogging() != MagickFalse)
4380 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"...");
4381 LockSemaphoreInfo(blob->semaphore);
4382 blob->reference_count++;
4383 UnlockSemaphoreInfo(blob->semaphore);
4420 MagickExport MagickOffsetType SeekBlob(
Image *image,
4421 const MagickOffsetType offset,
const int whence)
4424 *magick_restrict blob_info;
4426 assert(image != (
Image *) NULL);
4427 assert(image->signature == MagickCoreSignature);
4428 assert(image->blob != (
BlobInfo *) NULL);
4429 assert(image->blob->type != UndefinedStream);
4430 if (IsEventLogging() != MagickFalse)
4431 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
4432 blob_info=image->blob;
4433 switch (blob_info->type)
4435 case UndefinedStream:
4437 case StandardStream:
4442 if ((offset < 0) && (whence == SEEK_SET))
4444 if (fseek(blob_info->file_info.file,offset,whence) < 0)
4446 blob_info->offset=TellBlob(image);
4451 #if defined(MAGICKCORE_ZLIB_DELEGATE)
4452 if (gzseek(blob_info->file_info.gzfile,offset,whence) < 0)
4455 blob_info->offset=TellBlob(image);
4471 blob_info->offset=offset;
4476 if (((offset > 0) && (blob_info->offset > (MAGICK_SSIZE_MAX-offset))) ||
4477 ((offset < 0) && (blob_info->offset < (MAGICK_SSIZE_MIN-offset))))
4482 if ((blob_info->offset+offset) < 0)
4484 blob_info->offset+=offset;
4489 if (((MagickOffsetType) blob_info->length+offset) < 0)
4491 blob_info->offset=blob_info->length+offset;
4495 if (blob_info->offset < (MagickOffsetType) ((off_t) blob_info->length))
4497 blob_info->eof=MagickFalse;
4500 if (blob_info->offset >= (MagickOffsetType) ((off_t) blob_info->extent))
4505 return(blob_info->offset);
4533 MagickExport
void SetBlobExempt(
Image *image,
const MagickBooleanType exempt)
4535 assert(image != (
const Image *) NULL);
4536 assert(image->signature == MagickCoreSignature);
4537 if (IsEventLogging() != MagickFalse)
4538 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
4539 image->blob->exempt=exempt;
4568 MagickExport MagickBooleanType SetBlobExtent(
Image *image,
4569 const MagickSizeType extent)
4572 *magick_restrict blob_info;
4574 assert(image != (
Image *) NULL);
4575 assert(image->signature == MagickCoreSignature);
4576 assert(image->blob != (
BlobInfo *) NULL);
4577 assert(image->blob->type != UndefinedStream);
4578 if (IsEventLogging() != MagickFalse)
4579 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
4580 blob_info=image->blob;
4581 switch (blob_info->type)
4583 case UndefinedStream:
4585 case StandardStream:
4586 return(MagickFalse);
4595 if (extent != (MagickSizeType) ((off_t) extent))
4596 return(MagickFalse);
4597 offset=SeekBlob(image,0,SEEK_END);
4599 return(MagickFalse);
4600 if ((MagickSizeType) offset >= extent)
4602 offset=SeekBlob(image,(MagickOffsetType) extent-1,SEEK_SET);
4605 count=(ssize_t) fwrite((
const unsigned char *)
"",1,1,
4606 blob_info->file_info.file);
4607 #if defined(MAGICKCORE_HAVE_POSIX_FALLOCATE)
4608 if (blob_info->synchronize != MagickFalse)
4613 file=fileno(blob_info->file_info.file);
4614 if ((file == -1) || (offset < 0))
4615 return(MagickFalse);
4616 (void) posix_fallocate(file,offset,extent-offset);
4619 offset=SeekBlob(image,offset,SEEK_SET);
4621 return(MagickFalse);
4626 return(MagickFalse);
4628 return(MagickFalse);
4630 return(MagickFalse);
4633 if (extent != (MagickSizeType) ((
size_t) extent))
4634 return(MagickFalse);
4635 if (blob_info->mapped != MagickFalse)
4643 (void) UnmapBlob(blob_info->data,blob_info->length);
4644 RelinquishMagickResource(MapResource,blob_info->length);
4645 if (extent != (MagickSizeType) ((off_t) extent))
4646 return(MagickFalse);
4647 offset=SeekBlob(image,0,SEEK_END);
4649 return(MagickFalse);
4650 if ((MagickSizeType) offset >= extent)
4652 offset=SeekBlob(image,(MagickOffsetType) extent-1,SEEK_SET);
4653 count=(ssize_t) fwrite((
const unsigned char *)
"",1,1,
4654 blob_info->file_info.file);
4655 #if defined(MAGICKCORE_HAVE_POSIX_FALLOCATE)
4656 if (blob_info->synchronize != MagickFalse)
4661 file=fileno(blob_info->file_info.file);
4662 if ((file == -1) || (offset < 0))
4663 return(MagickFalse);
4664 (void) posix_fallocate(file,offset,extent-offset);
4667 offset=SeekBlob(image,offset,SEEK_SET);
4669 return(MagickFalse);
4670 (void) AcquireMagickResource(MapResource,extent);
4671 blob_info->data=(
unsigned char*) MapBlob(fileno(
4672 blob_info->file_info.file),WriteMode,0,(size_t) extent);
4673 blob_info->extent=(size_t) extent;
4674 blob_info->length=(size_t) extent;
4675 (void) SyncBlob(image);
4678 blob_info->extent=(size_t) extent;
4679 blob_info->data=(
unsigned char *) ResizeQuantumMemory(blob_info->data,
4680 blob_info->extent+1,
sizeof(*blob_info->data));
4681 (void) SyncBlob(image);
4682 if (blob_info->data == (
unsigned char *) NULL)
4684 (void) DetachBlob(blob_info);
4685 return(MagickFalse);
4716 static int SyncBlob(
Image *image)
4719 *magick_restrict blob_info;
4724 assert(image != (
Image *) NULL);
4725 assert(image->signature == MagickCoreSignature);
4726 assert(image->blob != (
BlobInfo *) NULL);
4727 assert(image->blob->type != UndefinedStream);
4728 if (IsEventLogging() != MagickFalse)
4729 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
4730 blob_info=image->blob;
4732 switch (blob_info->type)
4734 case UndefinedStream:
4735 case StandardStream:
4740 status=fflush(blob_info->file_info.file);
4745 #if defined(MAGICKCORE_ZLIB_DELEGATE)
4746 status=gzflush(blob_info->file_info.gzfile,Z_SYNC_FLUSH);
4752 #if defined(MAGICKCORE_BZLIB_DELEGATE)
4753 status=BZ2_bzflush(blob_info->file_info.bzfile);
4787 MagickExport MagickOffsetType TellBlob(
const Image *image)
4790 *magick_restrict blob_info;
4795 assert(image != (
Image *) NULL);
4796 assert(image->signature == MagickCoreSignature);
4797 assert(image->blob != (
BlobInfo *) NULL);
4798 assert(image->blob->type != UndefinedStream);
4799 if (IsEventLogging() != MagickFalse)
4800 (void) LogMagickEvent(TraceEvent,GetMagickModule(),
"%s",image->filename);
4801 blob_info=image->blob;
4803 switch (blob_info->type)
4805 case UndefinedStream:
4806 case StandardStream:
4810 offset=ftell(blob_info->file_info.file);
4817 #if defined(MAGICKCORE_ZLIB_DELEGATE)
4818 offset=(MagickOffsetType) gztell(blob_info->file_info.gzfile);
4828 offset=blob_info->offset;
4860 MagickExport MagickBooleanType UnmapBlob(
void *map,
const size_t length)
4862 #if defined(MAGICKCORE_HAVE_MMAP)
4866 status=munmap(map,length);
4867 return(status == -1 ? MagickFalse : MagickTrue);
4871 return(MagickFalse);
4904 MagickExport ssize_t WriteBlob(
Image *image,
const size_t length,
4905 const unsigned char *data)
4908 *magick_restrict blob_info;
4922 assert(image != (
Image *) NULL);
4923 assert(image->signature == MagickCoreSignature);
4924 assert(image->blob != (
BlobInfo *) NULL);
4925 assert(image->blob->type != UndefinedStream);
4928 assert(data != (
const unsigned char *) NULL);
4929 blob_info=image->blob;
4931 p=(
const unsigned char *) data;
4932 q=(
unsigned char *) data;
4933 switch (blob_info->type)
4935 case UndefinedStream:
4937 case StandardStream:
4945 count=(ssize_t) fwrite((
const char *) data,1,length,
4946 blob_info->file_info.file);
4951 c=putc((
int) *p++,blob_info->file_info.file);
4959 c=putc((
int) *p++,blob_info->file_info.file);
4967 c=putc((
int) *p++,blob_info->file_info.file);
4975 c=putc((
int) *p++,blob_info->file_info.file);
4984 if ((count != (ssize_t) length) &&
4985 (ferror(blob_info->file_info.file) != 0))
4986 ThrowBlobException(blob_info);
4991 #if defined(MAGICKCORE_ZLIB_DELEGATE)
5002 for (i=0; i < (ssize_t) length; i+=count)
5004 count=(ssize_t) gzwrite(blob_info->file_info.gzfile,q+i,
5005 (
unsigned int) MagickMin(length-i,MagickMaxBufferExtent));
5018 c=gzputc(blob_info->file_info.gzfile,(
int) *p++);
5026 c=gzputc(blob_info->file_info.gzfile,(
int) *p++);
5034 c=gzputc(blob_info->file_info.gzfile,(
int) *p++);
5042 c=gzputc(blob_info->file_info.gzfile,(
int) *p++);
5052 (void) gzerror(blob_info->file_info.gzfile,&status);
5053 if ((count != (ssize_t) length) && (status != Z_OK))
5054 ThrowBlobException(blob_info);
5060 #if defined(MAGICKCORE_BZLIB_DELEGATE)
5067 for (i=0; i < (ssize_t) length; i+=count)
5069 count=(ssize_t) BZ2_bzwrite(blob_info->file_info.bzfile,q+i,
5070 (
int) MagickMin(length-i,MagickMaxBufferExtent));
5080 (void) BZ2_bzerror(blob_info->file_info.bzfile,&status);
5081 if ((count != (ssize_t) length) && (status != BZ_OK))
5082 ThrowBlobException(blob_info);
5088 count=(ssize_t) blob_info->stream(image,data,length);
5093 if ((blob_info->offset+(MagickOffsetType) length) >=
5094 (MagickOffsetType) blob_info->extent)
5096 if (blob_info->mapped != MagickFalse)
5098 blob_info->extent+=length+blob_info->quantum;
5099 blob_info->quantum<<=1;
5100 blob_info->data=(
unsigned char *) ResizeQuantumMemory(
5101 blob_info->data,blob_info->extent+1,
sizeof(*blob_info->data));
5102 (void) SyncBlob(image);
5103 if (blob_info->data == (
unsigned char *) NULL)
5105 (void) DetachBlob(blob_info);
5109 q=blob_info->data+blob_info->offset;
5110 (void) memcpy(q,p,length);
5111 blob_info->offset+=length;
5112 if (blob_info->offset >= (MagickOffsetType) blob_info->length)
5113 blob_info->length=(
size_t) blob_info->offset;
5114 count=(ssize_t) length;
5117 if (count != (ssize_t) length)
5118 ThrowBlobException(blob_info);
5147 MagickExport ssize_t WriteBlobByte(
Image *image,
const unsigned char value)
5150 *magick_restrict blob_info;
5155 assert(image != (
Image *) NULL);
5156 assert(image->signature == MagickCoreSignature);
5157 assert(image->blob != (
BlobInfo *) NULL);
5158 assert(image->blob->type != UndefinedStream);
5159 blob_info=image->blob;
5161 switch (blob_info->type)
5163 case StandardStream:
5170 c=putc((
int) value,blob_info->file_info.file);
5173 if (ferror(blob_info->file_info.file) != 0)
5174 ThrowBlobException(blob_info);
5182 count=WriteBlobStream(image,1,&value);
5214 MagickExport ssize_t WriteBlobFloat(
Image *image,
const float value)
5225 quantum.unsigned_value=0U;
5226 quantum.float_value=value;
5227 return(WriteBlobLong(image,quantum.unsigned_value));
5255 MagickExport ssize_t WriteBlobLong(
Image *image,
const unsigned int value)
5260 assert(image != (
Image *) NULL);
5261 assert(image->signature == MagickCoreSignature);
5262 if (image->endian == LSBEndian)
5264 buffer[0]=(
unsigned char) value;
5265 buffer[1]=(
unsigned char) (value >> 8);
5266 buffer[2]=(
unsigned char) (value >> 16);
5267 buffer[3]=(
unsigned char) (value >> 24);
5268 return(WriteBlobStream(image,4,buffer));
5270 buffer[0]=(
unsigned char) (value >> 24);
5271 buffer[1]=(
unsigned char) (value >> 16);
5272 buffer[2]=(
unsigned char) (value >> 8);
5273 buffer[3]=(
unsigned char) value;
5274 return(WriteBlobStream(image,4,buffer));
5302 MagickExport ssize_t WriteBlobShort(
Image *image,
const unsigned short value)
5307 assert(image != (
Image *) NULL);
5308 assert(image->signature == MagickCoreSignature);
5309 if (image->endian == LSBEndian)
5311 buffer[0]=(
unsigned char) value;
5312 buffer[1]=(
unsigned char) (value >> 8);
5313 return(WriteBlobStream(image,2,buffer));
5315 buffer[0]=(
unsigned char) (value >> 8);
5316 buffer[1]=(
unsigned char) value;
5317 return(WriteBlobStream(image,2,buffer));
5345 MagickExport ssize_t WriteBlobLSBLong(
Image *image,
const unsigned int value)
5350 assert(image != (
Image *) NULL);
5351 assert(image->signature == MagickCoreSignature);
5352 buffer[0]=(
unsigned char) value;
5353 buffer[1]=(
unsigned char) (value >> 8);
5354 buffer[2]=(
unsigned char) (value >> 16);
5355 buffer[3]=(
unsigned char) (value >> 24);
5356 return(WriteBlobStream(image,4,buffer));
5384 MagickExport ssize_t WriteBlobLSBShort(
Image *image,
const unsigned short value)
5389 assert(image != (
Image *) NULL);
5390 assert(image->signature == MagickCoreSignature);
5391 buffer[0]=(
unsigned char) value;
5392 buffer[1]=(
unsigned char) (value >> 8);
5393 return(WriteBlobStream(image,2,buffer));
5421 MagickExport ssize_t WriteBlobLSBSignedLong(
Image *image,
const signed int value)
5435 assert(image != (
Image *) NULL);
5436 assert(image->signature == MagickCoreSignature);
5437 quantum.signed_value=value;
5438 buffer[0]=(
unsigned char) quantum.unsigned_value;
5439 buffer[1]=(
unsigned char) (quantum.unsigned_value >> 8);
5440 buffer[2]=(
unsigned char) (quantum.unsigned_value >> 16);
5441 buffer[3]=(
unsigned char) (quantum.unsigned_value >> 24);
5442 return(WriteBlobStream(image,4,buffer));
5470 MagickExport ssize_t WriteBlobLSBSignedShort(
Image *image,
5471 const signed short value)
5485 assert(image != (
Image *) NULL);
5486 assert(image->signature == MagickCoreSignature);
5487 quantum.signed_value=value;
5488 buffer[0]=(
unsigned char) quantum.unsigned_value;
5489 buffer[1]=(
unsigned char) (quantum.unsigned_value >> 8);
5490 return(WriteBlobStream(image,2,buffer));
5518 MagickExport ssize_t WriteBlobMSBLong(
Image *image,
const unsigned int value)
5523 assert(image != (
Image *) NULL);
5524 assert(image->signature == MagickCoreSignature);
5525 buffer[0]=(
unsigned char) (value >> 24);
5526 buffer[1]=(
unsigned char) (value >> 16);
5527 buffer[2]=(
unsigned char) (value >> 8);
5528 buffer[3]=(
unsigned char) value;
5529 return(WriteBlobStream(image,4,buffer));
5557 MagickExport ssize_t WriteBlobMSBLongLong(
Image *image,
5558 const MagickSizeType value)
5563 assert(image != (
Image *) NULL);
5564 assert(image->signature == MagickCoreSignature);
5565 buffer[0]=(
unsigned char) (value >> 56);
5566 buffer[1]=(
unsigned char) (value >> 48);
5567 buffer[2]=(
unsigned char) (value >> 40);
5568 buffer[3]=(
unsigned char) (value >> 32);
5569 buffer[4]=(
unsigned char) (value >> 24);
5570 buffer[5]=(
unsigned char) (value >> 16);
5571 buffer[6]=(
unsigned char) (value >> 8);
5572 buffer[7]=(
unsigned char) value;
5573 return(WriteBlobStream(image,8,buffer));
5601 MagickExport ssize_t WriteBlobMSBShort(
Image *image,
const unsigned short value)
5606 assert(image != (
Image *) NULL);
5607 assert(image->signature == MagickCoreSignature);
5608 buffer[0]=(
unsigned char) (value >> 8);
5609 buffer[1]=(
unsigned char) value;
5610 return(WriteBlobStream(image,2,buffer));
5638 MagickExport ssize_t WriteBlobMSBSignedLong(
Image *image,
const signed int value)
5652 assert(image != (
Image *) NULL);
5653 assert(image->signature == MagickCoreSignature);
5654 quantum.signed_value=value;
5655 buffer[0]=(
unsigned char) (quantum.unsigned_value >> 24);
5656 buffer[1]=(
unsigned char) (quantum.unsigned_value >> 16);
5657 buffer[2]=(
unsigned char) (quantum.unsigned_value >> 8);
5658 buffer[3]=(
unsigned char) quantum.unsigned_value;
5659 return(WriteBlobStream(image,4,buffer));
5687 MagickExport ssize_t WriteBlobMSBSignedShort(
Image *image,
5688 const signed short value)
5702 assert(image != (
Image *) NULL);
5703 assert(image->signature == MagickCoreSignature);
5704 quantum.signed_value=value;
5705 buffer[0]=(
unsigned char) (quantum.unsigned_value >> 8);
5706 buffer[1]=(
unsigned char) quantum.unsigned_value;
5707 return(WriteBlobStream(image,2,buffer));
5735 MagickExport ssize_t WriteBlobString(
Image *image,
const char *
string)
5737 assert(image != (
Image *) NULL);
5738 assert(image->signature == MagickCoreSignature);
5739 assert(
string != (
const char *) NULL);
5740 return(WriteBlobStream(image,strlen(
string),(
const unsigned char *)
string));