% MagickCore Binary Large OBjectS Methods %
% %
% Software Design %
-% John Cristy %
+% Cristy %
% July 1999 %
% %
% %
-% Copyright 1999-2012 ImageMagick Studio LLC, a non-profit organization %
+% Copyright 1999-2014 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
Include declarations.
*/
#include "MagickCore/studio.h"
-#include "MagickCore/nt-base-private.h"
#include "MagickCore/blob.h"
#include "MagickCore/blob-private.h"
#include "MagickCore/cache.h"
#include "MagickCore/log.h"
#include "MagickCore/magick.h"
#include "MagickCore/memory_.h"
+#include "MagickCore/nt-base-private.h"
#include "MagickCore/policy.h"
#include "MagickCore/resource_.h"
#include "MagickCore/semaphore.h"
#if !defined(MAP_FAILED)
#define MAP_FAILED ((void *) -1)
#endif
-#if !defined(MS_SYNC)
-#define MS_SYNC 0x04
-#endif
#if defined(__OS2__)
#include <io.h>
#define _O_BINARY O_BINARY
}
for (i=0; i < length; i+=count)
{
- count=(ssize_t) write(file,(const char *) blob+i,(size_t) MagickMin(length-
- i,(MagickSizeType) SSIZE_MAX));
+ count=write(file,(const char *) blob+i,(size_t) MagickMin(length-i,
+ (MagickSizeType) SSIZE_MAX));
if (count <= 0)
{
count=0;
if ((blob == (const void *) NULL) || (length == 0))
{
(void) ThrowMagickException(exception,GetMagickModule(),BlobError,
- "ZeroLengthBlobNotPermitted","'%s'",image_info->filename);
+ "ZeroLengthBlobNotPermitted","`%s'",image_info->filename);
return((Image *) NULL);
}
blob_info=CloneImageInfo(image_info);
{
blob_info=DestroyImageInfo(blob_info);
(void) ThrowMagickException(exception,GetMagickModule(),
- MissingDelegateError,"NoDecodeDelegateForThisImageFormat","'%s'",
+ MissingDelegateError,"NoDecodeDelegateForThisImageFormat","`%s'",
image_info->filename);
return((Image *) NULL);
}
assert(image->blob != (BlobInfo *) NULL);
if (image->blob->type == UndefinedStream)
return(MagickTrue);
- if (image->blob->synchronize != MagickFalse)
- SyncBlob(image);
- image->blob->size=GetBlobSize(image);
- image->extent=image->blob->size;
- image->blob->eof=MagickFalse;
- if (image->blob->exempt != MagickFalse)
- {
- image->blob->type=UndefinedStream;
- return(MagickTrue);
- }
- status=0;
+ status=SyncBlob(image);
switch (image->blob->type)
{
case UndefinedStream:
case FileStream:
case PipeStream:
{
+ if (image->blob->synchronize != MagickFalse)
+ status=fsync(fileno(image->blob->file_info.file));
status=ferror(image->blob->file_info.file);
break;
}
break;
}
case FifoStream:
+ break;
case BlobStream:
+ {
+ if ((image->blob->file_info.file != (FILE *) NULL) &&
+ (image->blob->synchronize != MagickFalse))
+ {
+ (void) fsync(fileno(image->blob->file_info.file));
+ status=ferror(image->blob->file_info.file);
+ }
break;
+ }
}
image->blob->status=status < 0 ? MagickTrue : MagickFalse;
+ image->blob->size=GetBlobSize(image);
+ image->extent=image->blob->size;
+ image->blob->eof=MagickFalse;
+ if (image->blob->exempt != MagickFalse)
+ {
+ image->blob->type=UndefinedStream;
+ return(image->blob->status);
+ }
switch (image->blob->type)
{
case UndefinedStream:
break;
case FileStream:
{
- if (image->blob->synchronize != MagickFalse)
- {
- status=fflush(image->blob->file_info.file);
- status=fsync(fileno(image->blob->file_info.file));
- }
status=fclose(image->blob->file_info.file);
break;
}
case BlobStream:
{
if (image->blob->file_info.file != (FILE *) NULL)
- {
- if (image->blob->synchronize != MagickFalse)
- (void) fsync(fileno(image->blob->file_info.file));
- status=fclose(image->blob->file_info.file);
- }
+ status=fclose(image->blob->file_info.file);
break;
}
}
return;
(void) CloseBlob(image);
if (image->blob->mapped != MagickFalse)
- (void) UnmapBlob(image->blob->data,image->blob->length);
+ {
+ (void) UnmapBlob(image->blob->data,image->blob->length);
+ RelinquishMagickResource(MapResource,image->blob->length);
+ }
if (image->blob->semaphore != (SemaphoreInfo *) NULL)
- DestroySemaphoreInfo(&image->blob->semaphore);
+ RelinquishSemaphoreInfo(&image->blob->semaphore);
image->blob->signature=(~MagickSignature);
image->blob=(BlobInfo *) RelinquishMagickMemory(image->blob);
}
if (blob_info->debug != MagickFalse)
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
if (blob_info->mapped != MagickFalse)
- (void) UnmapBlob(blob_info->data,blob_info->length);
+ {
+ (void) UnmapBlob(blob_info->data,blob_info->length);
+ RelinquishMagickResource(MapResource,blob_info->length);
+ }
blob_info->mapped=MagickFalse;
blob_info->length=0;
blob_info->offset=0;
}
offset=(MagickOffsetType) lseek(file,0,SEEK_END);
count=0;
- if ((offset < 0) || (offset != (MagickOffsetType) ((ssize_t) offset)))
+ if ((file == fileno(stdin)) || (offset < 0) ||
+ (offset != (MagickOffsetType) ((ssize_t) offset)))
{
size_t
quantum;
/*
Stream is not seekable.
*/
+ offset=(MagickOffsetType) lseek(file,0,SEEK_SET);
quantum=(size_t) MagickMaxBufferExtent;
if ((fstat(file,&file_stats) == 0) && (file_stats.st_size != 0))
quantum=(size_t) MagickMin((MagickSizeType) file_stats.st_size,
blob=(unsigned char *) AcquireQuantumMemory(quantum,sizeof(*blob));
for (i=0; blob != (unsigned char *) NULL; i+=count)
{
- count=(ssize_t) read(file,blob+i,quantum);
+ count=read(file,blob+i,quantum);
if (count <= 0)
{
count=0;
if (blob == (unsigned char *) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"MemoryAllocationFailed","'%s'",filename);
+ ResourceLimitError,"MemoryAllocationFailed","`%s'",filename);
return((unsigned char *) NULL);
}
if (file == -1)
{
file=close(file);
(void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"MemoryAllocationFailed","'%s'",filename);
+ ResourceLimitError,"MemoryAllocationFailed","`%s'",filename);
return((unsigned char *) NULL);
}
map=MapBlob(file,ReadMode,0,*length);
(void) lseek(file,0,SEEK_SET);
for (i=0; i < *length; i+=count)
{
- count=(ssize_t) read(file,blob+i,(size_t) MagickMin(*length-i,
- (MagickSizeType) SSIZE_MAX));
+ count=read(file,blob+i,(size_t) MagickMin(*length-i,(MagickSizeType)
+ SSIZE_MAX));
if (count <= 0)
{
count=0;
extent=(MagickSizeType) (image->blob->offset+(MagickOffsetType) length);
if (extent >= image->blob->extent)
{
- image->blob->quantum<<=1;
extent=image->blob->extent+image->blob->quantum+length;
+ image->blob->quantum<<=1;
if (SetBlobExtent(image,extent) == MagickFalse)
return(0);
}
assert(image->signature == MagickSignature);
assert(filename != (const char *) NULL);
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",filename);
- file=open_utf8(filename,O_RDONLY | O_BINARY,0);
+ file=fileno(stdin);
+ if (LocaleCompare(filename,"-") != 0)
+ file=open_utf8(filename,O_RDONLY | O_BINARY,0);
if (file == -1)
{
ThrowFileException(exception,BlobError,"UnableToOpenBlob",filename);
}
for ( ; ; )
{
- count=(ssize_t) read(file,blob,quantum);
+ count=read(file,blob,quantum);
if (count <= 0)
{
count=0;
blob_info->properties.st_ctime=time((time_t *) NULL);
blob_info->debug=IsEventLogging();
blob_info->reference_count=1;
- blob_info->semaphore=AllocateSemaphoreInfo();
+ blob_info->semaphore=AcquireSemaphoreInfo();
blob_info->signature=MagickSignature;
}
\f
%
% o image: the image.
%
-% o length: This pointer to a size_t integer sets the initial length of the
-% blob. On return, it reflects the actual length of the blob.
+% o length: return the actual length of the blob.
%
% o exception: return any errors or warnings in this structure.
%
if (magick_info == (const MagickInfo *) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
- MissingDelegateError,"NoDecodeDelegateForThisImageFormat","'%s'",
+ MissingDelegateError,"NoDecodeDelegateForThisImageFormat","`%s'",
image->filename);
return(blob);
}
sizeof(unsigned char));
if (blob_info->blob == (void *) NULL)
(void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"MemoryAllocationFailed","'%s'",image->filename);
+ ResourceLimitError,"MemoryAllocationFailed","`%s'",image->filename);
else
{
(void) CloseBlob(image);
(void) FormatLocaleString(image->filename,MaxTextExtent,"%s:%s",
image->magick,unique);
status=WriteImage(blob_info,image,exception);
+ (void) CloseBlob(image);
(void) fclose(blob_info->file);
if (status != MagickFalse)
- blob=FileToBlob(image->filename,~0UL,length,exception);
+ blob=FileToBlob(unique,~0UL,length,exception);
}
(void) RelinquishUniqueFileResource(unique);
}
{
file=close(file)-1;
(void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"MemoryAllocationError","'%s'",filename);
+ ResourceLimitError,"MemoryAllocationError","`%s'",filename);
return(MagickFalse);
}
length=0;
%
% o images: the image list.
%
-% o length: This pointer to a size_t integer sets the initial length of the
-% blob. On return, it reflects the actual length of the blob.
+% o length: return the actual length of the blob.
%
% o exception: return any errors or warnings in this structure.
%
exception);
if (*blob_info->magick != '\0')
(void) CopyMagickString(images->magick,blob_info->magick,MaxTextExtent);
- if (blob_info->adjoin == MagickFalse)
- {
- blob_info=DestroyImageInfo(blob_info);
- return(ImageToBlob(image_info,images,length,exception));
- }
magick_info=GetMagickInfo(images->magick,exception);
if (magick_info == (const MagickInfo *) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
- MissingDelegateError,"NoDecodeDelegateForThisImageFormat","'%s'",
+ MissingDelegateError,"NoDecodeDelegateForThisImageFormat","`%s'",
images->filename);
return(blob);
}
+ if (GetMagickAdjoin(magick_info) == MagickFalse)
+ {
+ blob_info=DestroyImageInfo(blob_info);
+ return(ImageToBlob(image_info,images,length,exception));
+ }
(void) CopyMagickString(blob_info->magick,images->magick,MaxTextExtent);
if (GetMagickBlobSupport(magick_info) != MagickFalse)
{
sizeof(unsigned char));
if (blob_info->blob == (void *) NULL)
(void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitError,"MemoryAllocationFailed","'%s'",images->filename);
+ ResourceLimitError,"MemoryAllocationFailed","`%s'",images->filename);
else
{
+ (void) CloseBlob(images);
images->blob->exempt=MagickTrue;
*images->filename='\0';
status=WriteImages(blob_info,images,images->filename,exception);
- if ((status != MagickFalse) && (images->blob->length != 0))
- {
- *length=images->blob->length;
- blob=DetachBlob(images->blob);
- blob=(unsigned char *) ResizeQuantumMemory(blob,*length,
- sizeof(*blob));
- }
+ *length=images->blob->length;
+ blob=DetachBlob(images->blob);
+ if (status == MagickFalse)
+ blob=(unsigned char *) RelinquishMagickMemory(blob);
+ else
+ blob=(unsigned char *) ResizeQuantumMemory(blob,*length+1,
+ sizeof(*blob));
}
}
else
(void) FormatLocaleString(filename,MaxTextExtent,"%s:%s",
images->magick,unique);
status=WriteImages(blob_info,images,filename,exception);
+ (void) CloseBlob(images);
(void) fclose(blob_info->file);
if (status != MagickFalse)
- blob=FileToBlob(images->filename,~0UL,length,exception);
+ blob=FileToBlob(unique,~0UL,length,exception);
}
(void) RelinquishUniqueFileResource(unique);
}
}
for (i=0; ; i+=count)
{
- count=(ssize_t) read(file,buffer,quantum);
+ count=read(file,buffer,quantum);
if (count <= 0)
{
count=0;
MagickExport unsigned char *MapBlob(int file,const MapMode mode,
const MagickOffsetType offset,const size_t length)
{
-#if defined(MAGICKCORE_HAVE_MMAP_FILEIO)
+#if defined(MAGICKCORE_HAVE_MMAP)
int
flags,
protection;
{
protection=PROT_READ;
flags|=MAP_PRIVATE;
- map=(unsigned char *) mmap((char *) NULL,length,protection,flags,file,
- (off_t) offset);
break;
}
case WriteMode:
{
protection=PROT_WRITE;
flags|=MAP_SHARED;
- map=(unsigned char *) mmap((char *) NULL,length,protection,flags,file,
- (off_t) offset);
-#if defined(MAGICKCORE_HAVE_POSIX_MADVISE)
- (void) posix_madvise(map,length,POSIX_MADV_SEQUENTIAL |
- POSIX_MADV_WILLNEED);
-#endif
break;
}
case IOMode:
{
protection=PROT_READ | PROT_WRITE;
flags|=MAP_SHARED;
- map=(unsigned char *) mmap((char *) NULL,length,protection,flags,file,
- (off_t) offset);
break;
}
}
+#if !defined(MAGICKCORE_HAVE_HUGEPAGES) || !defined(MAP_HUGETLB)
+ map=(unsigned char *) mmap((char *) NULL,length,protection,flags,file,
+ (off_t) offset);
+#else
+ map=(unsigned char *) mmap((char *) NULL,length,protection,flags |
+ MAP_HUGETLB,file,(off_t) offset);
+ if (map == (unsigned char *) MAP_FAILED)
+ map=(unsigned char *) mmap((char *) NULL,length,protection,flags,file,
+ (off_t) offset);
+#endif
if (map == (unsigned char *) MAP_FAILED)
return((unsigned char *) NULL);
return(map);
{
errno=EPERM;
(void) ThrowMagickException(exception,GetMagickModule(),PolicyError,
- "NotAuthorized","'%s'",filename);
+ "NotAuthorized","`%s'",filename);
return(MagickFalse);
}
if ((LocaleCompare(filename,"-") == 0) ||
#endif
status=GetPathAttributes(filename,&image->blob->properties);
#if defined(S_ISFIFO)
- if ((status == MagickTrue) && S_ISFIFO(image->blob->properties.st_mode))
+ if ((status != MagickFalse) && S_ISFIFO(image->blob->properties.st_mode))
{
image->blob->file_info.file=(FILE *) fopen_utf8(filename,type);
if (image->blob->file_info.file == (FILE *) NULL)
image->blob->type=FileStream;
#if defined(MAGICKCORE_HAVE_SETVBUF)
- (void) setvbuf(image->blob->file_info.file,(char *) NULL,
- (int) _IOFBF,16384);
+ (void) setvbuf(image->blob->file_info.file,(char *) NULL,(int)
+ _IOFBF,16384);
#endif
(void) ResetMagickMemory(magick,0,sizeof(magick));
count=fread(magick,1,sizeof(magick),image->blob->file_info.file);
- (void) rewind(image->blob->file_info.file);
+ (void) fseek(image->blob->file_info.file,-((off_t) count),SEEK_CUR);
+ (void) fflush(image->blob->file_info.file);
(void) LogMagickEvent(BlobEvent,GetMagickModule(),
" read %.20g magic header bytes",(double) count);
#if defined(MAGICKCORE_ZLIB_DELEGATE)
ExceptionInfo
*sans_exception;
- struct stat
- *properties;
+ size_t
+ length;
sans_exception=AcquireExceptionInfo();
magick_info=GetMagickInfo(image_info->magick,sans_exception);
sans_exception=DestroyExceptionInfo(sans_exception);
- properties=(&image->blob->properties);
+ length=(size_t) image->blob->properties.st_size;
if ((magick_info != (const MagickInfo *) NULL) &&
(GetMagickBlobSupport(magick_info) != MagickFalse) &&
- (properties->st_size <= MagickMaxBufferExtent))
+ (length <= MagickMaxBufferExtent) &&
+ (AcquireMagickResource(MapResource,length) != MagickFalse))
{
- size_t
- length;
-
void
*blob;
- length=(size_t) properties->st_size;
- blob=MapBlob(fileno(image->blob->file_info.file),ReadMode,
- 0,length);
- if (blob != (void *) NULL)
+ blob=MapBlob(fileno(image->blob->file_info.file),ReadMode,0,
+ length);
+ if (blob == (void *) NULL)
+ RelinquishMagickResource(MapResource,length);
+ else
{
/*
Format supports blobs-- use memory-mapped I/O.
{
image->blob->type=FileStream;
#if defined(MAGICKCORE_HAVE_SETVBUF)
- (void) setvbuf(image->blob->file_info.file,(char *) NULL,(int) _IOFBF,
- 16384);
+ (void) setvbuf(image->blob->file_info.file,(char *) NULL,(int)
+ _IOFBF,16384);
#endif
}
}
if ((blob == (const void *) NULL) || (length == 0))
{
(void) ThrowMagickException(exception,GetMagickModule(),BlobError,
- "UnrecognizedImageFormat","'%s'",image_info->magick);
+ "UnrecognizedImageFormat","`%s'",image_info->magick);
return((Image *) NULL);
}
ping_info=CloneImageInfo(image_info);
if (ping_info->blob == (const void *) NULL)
{
(void) ThrowMagickException(exception,GetMagickModule(),
- ResourceLimitFatalError,"MemoryAllocationFailed","'%s'","");
+ ResourceLimitFatalError,"MemoryAllocationFailed","`%s'","");
return((Image *) NULL);
}
(void) memcpy(ping_info->blob,blob,length);
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ReadBlob() reads data from the blob or image file and returns it. It
-% returns the number of bytes read.
+% returns the number of bytes read. If length is zero, ReadBlob() returns
+% zero and has no other results. If length is greater than SSIZE_MAX, the
+% result is unspecified.
%
% The format of the ReadBlob method is:
%
register ssize_t
i;
- count=0;
for (i=0; i < (ssize_t) length; i+=count)
{
- count=read(fileno(image->blob->file_info.file),q+i,(size_t) MagickMin(
- length-i,SSIZE_MAX));
- if (count > 0)
- continue;
- count=0;
- if (errno != EINTR)
+ count=read(fileno(image->blob->file_info.file),q+i,(size_t)
+ MagickMin(length-i,(MagickSizeType) SSIZE_MAX));
+ if (count <= 0)
{
- i=(-1);
- break;
+ count=0;
+ if (errno != EINTR)
+ break;
}
}
count=i;
case BZipStream:
{
#if defined(MAGICKCORE_BZLIB_DELEGATE)
- count=(ssize_t) BZ2_bzread(image->blob->file_info.bzfile,q,
- (int) length);
+ count=(ssize_t) BZ2_bzread(image->blob->file_info.bzfile,q,(int) length);
#endif
break;
}
{
image->blob->extent=(size_t) (image->blob->offset+
image->blob->quantum);
+ image->blob->quantum<<=1;
image->blob->data=(unsigned char *) ResizeQuantumMemory(
image->blob->data,image->blob->extent+1,
sizeof(*image->blob->data));
return(MagickFalse);
case FileStream:
{
+ MagickOffsetType
+ offset;
+
+ ssize_t
+ count;
+
if (extent != (MagickSizeType) ((off_t) extent))
return(MagickFalse);
-#if !defined(MAGICKCORE_HAVE_POSIX_FALLOCATE)
+ offset=SeekBlob(image,0,SEEK_END);
+ if (offset < 0)
return(MagickFalse);
-#else
- {
- int
- status;
-
- MagickOffsetType
- offset;
+ if ((MagickSizeType) offset >= extent)
+ break;
+ offset=SeekBlob(image,(MagickOffsetType) extent-1,SEEK_SET);
+ count=(ssize_t) fwrite((const unsigned char *) "",1,1,
+ image->blob->file_info.file);
+#if defined(MAGICKCORE_HAVE_POSIX_FALLOCATE)
+ if (image->blob->synchronize != MagickFalse)
+ {
+ int
+ status;
- offset=TellBlob(image);
- status=posix_fallocate(fileno(image->blob->file_info.file),offset,
- extent-offset);
- if (status != 0)
- return(MagickFalse);
- }
+ status=posix_fallocate(fileno(image->blob->file_info.file),offset,
+ extent-offset);
+ if (status != 0)
+ return(MagickFalse);
+ }
#endif
+ offset=SeekBlob(image,offset,SEEK_SET);
+ if (count != 1)
+ return(MagickFalse);
break;
}
case PipeStream:
return(MagickFalse);
case BlobStream:
{
+ if (extent != (MagickSizeType) ((size_t) extent))
+ return(MagickFalse);
if (image->blob->mapped != MagickFalse)
{
- if (image->blob->file_info.file == (FILE *) NULL)
- return(MagickFalse);
- (void) UnmapBlob(image->blob->data,image->blob->length);
-#if !defined(MAGICKCORE_HAVE_POSIX_FALLOCATE)
- return(MagickFalse);
-#else
- {
- int
- status;
+ MagickOffsetType
+ offset;
- MagickOffsetType
- offset;
+ ssize_t
+ count;
- offset=TellBlob(image);
- status=posix_fallocate(fileno(image->blob->file_info.file),offset,
- extent-offset);
- if (status != 0)
- return(MagickFalse);
- }
+ (void) UnmapBlob(image->blob->data,image->blob->length);
+ RelinquishMagickResource(MapResource,image->blob->length);
+ if (extent != (MagickSizeType) ((off_t) extent))
+ return(MagickFalse);
+ offset=SeekBlob(image,0,SEEK_END);
+ if (offset < 0)
+ return(MagickFalse);
+ if ((MagickSizeType) offset >= extent)
+ break;
+ offset=SeekBlob(image,(MagickOffsetType) extent-1,SEEK_SET);
+ count=(ssize_t) fwrite((const unsigned char *) "",1,1,
+ image->blob->file_info.file);
+#if defined(MAGICKCORE_HAVE_POSIX_FALLOCATE)
+ if (image->blob->synchronize != MagickFalse)
+ {
+ int
+ status;
+
+ status=posix_fallocate(fileno(image->blob->file_info.file),offset,
+ extent-offset);
+ if (status != 0)
+ return(MagickFalse);
+ }
+#endif
+ offset=SeekBlob(image,offset,SEEK_SET);
+ if (count != 1)
+ return(MagickFalse);
+ (void) AcquireMagickResource(MapResource,extent);
image->blob->data=(unsigned char*) MapBlob(fileno(
image->blob->file_info.file),WriteMode,0,(size_t) extent);
image->blob->extent=(size_t) extent;
image->blob->length=(size_t) extent;
(void) SyncBlob(image);
break;
-#endif
}
- if (extent != (MagickSizeType) ((size_t) extent))
- return(MagickFalse);
image->blob->extent=(size_t) extent;
image->blob->data=(unsigned char *) ResizeQuantumMemory(image->blob->data,
image->blob->extent+1,sizeof(*image->blob->data));
case FifoStream:
break;
case BlobStream:
- {
-#if defined(MAGICKCORE_HAVE_MMAP_FILEIO)
- if (image->blob->mapped != MagickFalse)
- status=msync(image->blob->data,image->blob->length,MS_SYNC);
-#endif
break;
- }
}
return(status);
}
*/
MagickExport MagickBooleanType UnmapBlob(void *map,const size_t length)
{
-#if defined(MAGICKCORE_HAVE_MMAP_FILEIO)
+#if defined(MAGICKCORE_HAVE_MMAP)
int
status;
break;
case StandardStream:
{
- register ssize_t
- i;
-
- count=0;
- for (i=0; i < (MagickOffsetType) length; i+=count)
- {
- count=write(fileno(image->blob->file_info.file),data+i,(size_t)
- MagickMin(length-i,SSIZE_MAX));
- if (count > 0)
- continue;
- count=0;
- if (errno != EINTR)
- {
- i=(-1);
- break;
- }
- }
- count=i;
+ count=write(fileno(image->blob->file_info.file),data,length);
break;
}
case FileStream:
{
if (image->blob->mapped != MagickFalse)
return(0);
- image->blob->quantum<<=1;
image->blob->extent+=length+image->blob->quantum;
+ image->blob->quantum<<=1;
image->blob->data=(unsigned char *) ResizeQuantumMemory(
image->blob->data,image->blob->extent+1,sizeof(*image->blob->data));
(void) SyncBlob(image);