This source file includes following definitions.
- AcquireMagickResource
- AsynchronousResourceComponentTerminus
- DestroyTemporaryResources
- GetPathTemplate
- AcquireUniqueFileResource
- GetMagickResource
- GetMagickResourceLimit
- FormatPixelSize
- ListMagickResourceInfo
- RelinquishMagickResource
- RelinquishUniqueFileResource
- StringToSizeType
- ResourceComponentGenesis
- ResourceComponentTerminus
- SetMagickResourceLimit
#include "magick/studio.h"
#include "magick/cache.h"
#include "magick/configure.h"
#include "magick/exception.h"
#include "magick/exception-private.h"
#include "magick/hashmap.h"
#include "magick/log.h"
#include "magick/image.h"
#include "magick/image-private.h"
#include "magick/memory_.h"
#include "magick/nt-base-private.h"
#include "magick/option.h"
#include "magick/policy.h"
#include "magick/random_.h"
#include "magick/registry.h"
#include "magick/resource_.h"
#include "magick/semaphore.h"
#include "magick/signature-private.h"
#include "magick/string_.h"
#include "magick/string-private.h"
#include "magick/splay-tree.h"
#include "magick/thread-private.h"
#include "magick/token.h"
#include "magick/utility.h"
#include "magick/utility-private.h"
typedef struct _ResourceInfo
{
MagickOffsetType
width,
height,
area,
memory,
map,
disk,
file,
thread,
throttle,
time;
MagickSizeType
width_limit,
height_limit,
area_limit,
memory_limit,
map_limit,
disk_limit,
file_limit,
thread_limit,
throttle_limit,
time_limit;
} ResourceInfo;
static RandomInfo
*random_info = (RandomInfo *) NULL;
static ResourceInfo
resource_info =
{
MagickULLConstant(0),
MagickULLConstant(0),
MagickULLConstant(0),
MagickULLConstant(0),
MagickULLConstant(0),
MagickULLConstant(0),
MagickULLConstant(0),
MagickULLConstant(0),
MagickULLConstant(0),
MagickULLConstant(0),
(INT_MAX/(5*sizeof(Quantum))),
(INT_MAX/(5*sizeof(Quantum))),
MagickULLConstant(3072)*1024*1024,
MagickULLConstant(1536)*1024*1024,
MagickULLConstant(3072)*1024*1024,
MagickResourceInfinity,
MagickULLConstant(768),
MagickULLConstant(1),
MagickULLConstant(0),
MagickResourceInfinity
};
static SemaphoreInfo
*resource_semaphore = (SemaphoreInfo *) NULL;
static SplayTreeInfo
*temporary_resources = (SplayTreeInfo *) NULL;
MagickExport MagickBooleanType AcquireMagickResource(const ResourceType type,
const MagickSizeType size)
{
char
resource_current[MaxTextExtent],
resource_limit[MaxTextExtent],
resource_request[MaxTextExtent];
MagickBooleanType
status;
MagickSizeType
limit;
status=MagickFalse;
(void) FormatMagickSize(size,MagickFalse,resource_request);
if (resource_semaphore == (SemaphoreInfo *) NULL)
ActivateSemaphoreInfo(&resource_semaphore);
LockSemaphoreInfo(resource_semaphore);
switch (type)
{
case WidthResource:
{
resource_info.width=(MagickOffsetType) size;
limit=resource_info.width_limit;
status=(resource_info.width_limit == MagickResourceInfinity) ||
(size < limit) ? MagickTrue : MagickFalse;
(void) FormatMagickSize((MagickSizeType) resource_info.width,MagickFalse,
resource_current);
(void) FormatMagickSize(resource_info.width_limit,MagickFalse,
resource_limit);
break;
}
case HeightResource:
{
resource_info.height=(MagickOffsetType) size;
limit=resource_info.height_limit;
status=(resource_info.height_limit == MagickResourceInfinity) ||
(size < limit) ? MagickTrue : MagickFalse;
(void) FormatMagickSize((MagickSizeType) resource_info.height,MagickFalse,
resource_current);
(void) FormatMagickSize(resource_info.height_limit,MagickFalse,
resource_limit);
break;
}
case AreaResource:
{
resource_info.area=(MagickOffsetType) size;
limit=resource_info.area_limit;
status=(resource_info.area_limit == MagickResourceInfinity) ||
(size < limit) ? MagickTrue : MagickFalse;
(void) FormatMagickSize((MagickSizeType) resource_info.area,MagickFalse,
resource_current);
(void) FormatMagickSize(resource_info.area_limit,MagickFalse,
resource_limit);
break;
}
case MemoryResource:
{
resource_info.memory+=size;
limit=resource_info.memory_limit;
status=(resource_info.memory_limit == MagickResourceInfinity) ||
((MagickSizeType) resource_info.memory < limit) ?
MagickTrue : MagickFalse;
(void) FormatMagickSize((MagickSizeType) resource_info.memory,MagickTrue,
resource_current);
(void) FormatMagickSize(resource_info.memory_limit,MagickTrue,
resource_limit);
break;
}
case MapResource:
{
resource_info.map+=size;
limit=resource_info.map_limit;
status=(resource_info.map_limit == MagickResourceInfinity) ||
((MagickSizeType) resource_info.map < limit) ?
MagickTrue : MagickFalse;
(void) FormatMagickSize((MagickSizeType) resource_info.map,MagickTrue,
resource_current);
(void) FormatMagickSize(resource_info.map_limit,MagickTrue,
resource_limit);
break;
}
case DiskResource:
{
resource_info.disk+=size;
limit=resource_info.disk_limit;
status=(resource_info.disk_limit == MagickResourceInfinity) ||
((MagickSizeType) resource_info.disk < limit) ?
MagickTrue : MagickFalse;
(void) FormatMagickSize((MagickSizeType) resource_info.disk,MagickTrue,
resource_current);
(void) FormatMagickSize(resource_info.disk_limit,MagickTrue,
resource_limit);
break;
}
case FileResource:
{
resource_info.file+=size;
limit=resource_info.file_limit;
status=(resource_info.file_limit == MagickResourceInfinity) ||
((MagickSizeType) resource_info.file < limit) ?
MagickTrue : MagickFalse;
(void) FormatMagickSize((MagickSizeType) resource_info.file,MagickFalse,
resource_current);
(void) FormatMagickSize((MagickSizeType) resource_info.file_limit,
MagickFalse,resource_limit);
break;
}
case ThreadResource:
{
limit=resource_info.thread_limit;
status=(resource_info.thread_limit == MagickResourceInfinity) ||
((MagickSizeType) resource_info.thread < limit) ? MagickTrue :
MagickFalse;
(void) FormatMagickSize((MagickSizeType) resource_info.thread,MagickFalse,
resource_current);
(void) FormatMagickSize((MagickSizeType) resource_info.thread_limit,
MagickFalse,resource_limit);
break;
}
case ThrottleResource:
{
limit=resource_info.throttle_limit;
status=(resource_info.throttle_limit == MagickResourceInfinity) ||
((MagickSizeType) resource_info.throttle < limit) ? MagickTrue :
MagickFalse;
(void) FormatMagickSize((MagickSizeType) resource_info.throttle,
MagickFalse,resource_current);
(void) FormatMagickSize((MagickSizeType) resource_info.throttle_limit,
MagickFalse,resource_limit);
break;
}
case TimeResource:
{
resource_info.time+=size;
limit=resource_info.time_limit;
status=(resource_info.time_limit == MagickResourceInfinity) ||
((MagickSizeType) resource_info.time < limit) ?
MagickTrue : MagickFalse;
(void) FormatMagickSize((MagickSizeType) resource_info.time,MagickFalse,
resource_current);
(void) FormatMagickSize((MagickSizeType) resource_info.time_limit,
MagickFalse,resource_limit);
break;
}
default:
break;
}
UnlockSemaphoreInfo(resource_semaphore);
(void) LogMagickEvent(ResourceEvent,GetMagickModule(),"%s: %s/%s/%s",
CommandOptionToMnemonic(MagickResourceOptions,(ssize_t) type),
resource_request,resource_current,resource_limit);
return(status);
}
MagickExport void AsynchronousResourceComponentTerminus(void)
{
const char
*path;
if (temporary_resources == (SplayTreeInfo *) NULL)
return;
ResetSplayTreeIterator(temporary_resources);
path=(const char *) GetNextKeyInSplayTree(temporary_resources);
while (path != (const char *) NULL)
{
(void) ShredFile(path);
path=(const char *) GetNextKeyInSplayTree(temporary_resources);
}
}
static void *DestroyTemporaryResources(void *temporary_resource)
{
(void) ShredFile((char *) temporary_resource);
temporary_resource=DestroyString((char *) temporary_resource);
return((void *) NULL);
}
MagickExport MagickBooleanType GetPathTemplate(char *path)
{
char
*directory,
*value;
ExceptionInfo
*exception;
MagickBooleanType
status;
struct stat
attributes;
(void) FormatLocaleString(path,MaxTextExtent,"magick-%.20gXXXXXXXXXXXX",
(double) getpid());
exception=AcquireExceptionInfo();
directory=(char *) GetImageRegistry(StringRegistryType,"temporary-path",
exception);
exception=DestroyExceptionInfo(exception);
if (directory == (char *) NULL)
directory=GetEnvironmentValue("MAGICK_TEMPORARY_PATH");
if (directory == (char *) NULL)
directory=GetEnvironmentValue("MAGICK_TMPDIR");
#if defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__OS2__) || defined(__CYGWIN__)
if (directory == (char *) NULL)
directory=GetEnvironmentValue("TMP");
if (directory == (char *) NULL)
directory=GetEnvironmentValue("TEMP");
#endif
#if defined(__VMS)
if (directory == (char *) NULL)
directory=GetEnvironmentValue("MTMPDIR");
#endif
#if defined(P_tmpdir)
if (directory == (char *) NULL)
directory=ConstantString(P_tmpdir);
#endif
if (directory == (char *) NULL)
directory=GetEnvironmentValue("TMPDIR");
if (directory == (char *) NULL)
return(MagickTrue);
value=GetPolicyValue("temporary-path");
if (value != (char *) NULL)
(void) CloneString(&directory,value);
if (strlen(directory) > (MaxTextExtent-25))
{
directory=DestroyString(directory);
return(MagickFalse);
}
status=GetPathAttributes(directory,&attributes);
if ((status == MagickFalse) || !S_ISDIR(attributes.st_mode))
{
directory=DestroyString(directory);
return(MagickFalse);
}
if (directory[strlen(directory)-1] == *DirectorySeparator)
(void) FormatLocaleString(path,MaxTextExtent,"%smagick-%.20gXXXXXXXXXXXX",
directory,(double) getpid());
else
(void) FormatLocaleString(path,MaxTextExtent,
"%s%smagick-%.20gXXXXXXXXXXXX",directory,DirectorySeparator,
(double) getpid());
directory=DestroyString(directory);
#if defined(MAGICKCORE_WINDOWS_SUPPORT)
{
register char
*p;
for (p=(path[1] == *DirectorySeparator ? path+2 : path); *p != '\0'; p++)
if (*p == *DirectorySeparator)
*p='/';
}
#endif
return(MagickTrue);
}
MagickExport int AcquireUniqueFileResource(char *path)
{
#if !defined(O_NOFOLLOW)
#define O_NOFOLLOW 0
#endif
#if !defined(TMP_MAX)
# define TMP_MAX 238328
#endif
int
c,
file;
register char
*p;
register ssize_t
i;
static const char
portable_filename[65] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-";
StringInfo
*key;
unsigned char
*datum;
assert(path != (char *) NULL);
(void) LogMagickEvent(ResourceEvent,GetMagickModule(),"...");
if (random_info == (RandomInfo *) NULL)
{
LockSemaphoreInfo(resource_semaphore);
if (random_info == (RandomInfo *) NULL)
random_info=AcquireRandomInfo();
UnlockSemaphoreInfo(resource_semaphore);
}
file=(-1);
for (i=0; i < (ssize_t) TMP_MAX; i++)
{
(void) GetPathTemplate(path);
key=GetRandomKey(random_info,6);
p=path+strlen(path)-12;
datum=GetStringInfoDatum(key);
for (i=0; i < (ssize_t) GetStringInfoLength(key); i++)
{
c=(int) (datum[i] & 0x3f);
*p++=portable_filename[c];
}
key=DestroyStringInfo(key);
#if defined(MAGICKCORE_HAVE_MKSTEMP)
file=mkstemp(path);
if (file != -1)
{
#if defined(MAGICKCORE_HAVE_FCHMOD)
(void) fchmod(file,0600);
#endif
#if defined(__OS2__)
setmode(file,O_BINARY);
#endif
break;
}
#endif
key=GetRandomKey(random_info,12);
p=path+strlen(path)-12;
datum=GetStringInfoDatum(key);
for (i=0; i < (ssize_t) GetStringInfoLength(key); i++)
{
c=(int) (datum[i] & 0x3f);
*p++=portable_filename[c];
}
key=DestroyStringInfo(key);
file=open_utf8(path,O_RDWR | O_CREAT | O_EXCL | O_BINARY | O_NOFOLLOW,
S_MODE);
if ((file >= 0) || (errno != EEXIST))
break;
}
(void) LogMagickEvent(ResourceEvent,GetMagickModule(),"Acquire %s",path);
if (file == -1)
return(file);
if (resource_semaphore == (SemaphoreInfo *) NULL)
ActivateSemaphoreInfo(&resource_semaphore);
LockSemaphoreInfo(resource_semaphore);
if (temporary_resources == (SplayTreeInfo *) NULL)
temporary_resources=NewSplayTree(CompareSplayTreeString,
DestroyTemporaryResources,(void *(*)(void *)) NULL);
UnlockSemaphoreInfo(resource_semaphore);
(void) AddValueToSplayTree(temporary_resources,ConstantString(path),
(const void *) NULL);
return(file);
}
MagickExport MagickSizeType GetMagickResource(const ResourceType type)
{
MagickSizeType
resource;
resource=0;
LockSemaphoreInfo(resource_semaphore);
switch (type)
{
case WidthResource:
{
resource=(MagickSizeType) resource_info.width;
break;
}
case HeightResource:
{
resource=(MagickSizeType) resource_info.height;
break;
}
case AreaResource:
{
resource=(MagickSizeType) resource_info.area;
break;
}
case MemoryResource:
{
resource=(MagickSizeType) resource_info.memory;
break;
}
case MapResource:
{
resource=(MagickSizeType) resource_info.map;
break;
}
case DiskResource:
{
resource=(MagickSizeType) resource_info.disk;
break;
}
case FileResource:
{
resource=(MagickSizeType) resource_info.file;
break;
}
case ThreadResource:
{
resource=(MagickSizeType) resource_info.thread;
break;
}
case ThrottleResource:
{
resource=(MagickSizeType) resource_info.throttle;
break;
}
case TimeResource:
{
resource=(MagickSizeType) resource_info.time;
break;
}
default:
break;
}
UnlockSemaphoreInfo(resource_semaphore);
return(resource);
}
MagickExport MagickSizeType GetMagickResourceLimit(const ResourceType type)
{
MagickSizeType
resource;
resource=0;
if (resource_semaphore == (SemaphoreInfo *) NULL)
ActivateSemaphoreInfo(&resource_semaphore);
LockSemaphoreInfo(resource_semaphore);
switch (type)
{
case WidthResource:
{
resource=resource_info.width_limit;
break;
}
case HeightResource:
{
resource=resource_info.height_limit;
break;
}
case AreaResource:
{
resource=resource_info.area_limit;
break;
}
case MemoryResource:
{
resource=resource_info.memory_limit;
break;
}
case MapResource:
{
resource=resource_info.map_limit;
break;
}
case DiskResource:
{
resource=resource_info.disk_limit;
break;
}
case FileResource:
{
resource=resource_info.file_limit;
break;
}
case ThreadResource:
{
resource=resource_info.thread_limit;
break;
}
case ThrottleResource:
{
resource=resource_info.throttle_limit;
break;
}
case TimeResource:
{
resource=resource_info.time_limit;
break;
}
default:
break;
}
UnlockSemaphoreInfo(resource_semaphore);
return(resource);
}
static ssize_t FormatPixelSize(const MagickSizeType size,
const MagickBooleanType bi,char *format)
{
const char
**units;
double
bytes,
length;
register ssize_t
i,
j;
ssize_t
count;
static const char
*bi_units[] =
{
"", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi", "Yi", (char *) NULL
},
*traditional_units[] =
{
"", "K", "M", "G", "T", "P", "E", "Z", "Y", (char *) NULL
};
bytes=1000.0;
units=traditional_units;
if (bi != MagickFalse)
{
bytes=1024.0;
units=bi_units;
}
#if defined(_MSC_VER) && (_MSC_VER == 1200)
length=(double) ((MagickOffsetType) size);
#else
length=(double) size;
#endif
for (i=0; (length >= bytes) && (units[i+1] != (const char *) NULL); i++)
length/=bytes;
count=0;
for (j=2; j < 12; j++)
{
count=FormatLocaleString(format,MaxTextExtent,"%.*g%sP",(int) (i+j),length,
units[i]);
if (strchr(format,'+') == (char *) NULL)
break;
}
return(count);
}
MagickExport MagickBooleanType ListMagickResourceInfo(FILE *file,
ExceptionInfo *magick_unused(exception))
{
char
area_limit[MaxTextExtent],
disk_limit[MaxTextExtent],
height_limit[MaxTextExtent],
map_limit[MaxTextExtent],
memory_limit[MaxTextExtent],
time_limit[MaxTextExtent],
width_limit[MaxTextExtent];
magick_unreferenced(exception);
if (file == (const FILE *) NULL)
file=stdout;
if (resource_semaphore == (SemaphoreInfo *) NULL)
ActivateSemaphoreInfo(&resource_semaphore);
LockSemaphoreInfo(resource_semaphore);
(void) FormatPixelSize(resource_info.width_limit,MagickFalse,width_limit);
(void) FormatPixelSize(resource_info.height_limit,MagickFalse,height_limit);
(void) FormatPixelSize(resource_info.area_limit,MagickFalse,area_limit);
(void) FormatMagickSize(resource_info.memory_limit,MagickTrue,memory_limit);
(void) FormatMagickSize(resource_info.map_limit,MagickTrue,map_limit);
(void) CopyMagickString(disk_limit,"unlimited",MaxTextExtent);
if (resource_info.disk_limit != MagickResourceInfinity)
(void) FormatMagickSize(resource_info.disk_limit,MagickTrue,disk_limit);
(void) CopyMagickString(time_limit,"unlimited",MaxTextExtent);
if (resource_info.time_limit != MagickResourceInfinity)
(void) FormatLocaleString(time_limit,MaxTextExtent,"%.20g",(double)
((MagickOffsetType) resource_info.time_limit));
(void) FormatLocaleFile(file,"Resource limits:\n");
(void) FormatLocaleFile(file," Width: %s\n",width_limit);
(void) FormatLocaleFile(file," Height: %s\n",height_limit);
(void) FormatLocaleFile(file," Area: %s\n",area_limit);
(void) FormatLocaleFile(file," Memory: %s\n",memory_limit);
(void) FormatLocaleFile(file," Map: %s\n",map_limit);
(void) FormatLocaleFile(file," Disk: %s\n",disk_limit);
(void) FormatLocaleFile(file," File: %.20g\n",(double) ((MagickOffsetType)
resource_info.file_limit));
(void) FormatLocaleFile(file," Thread: %.20g\n",(double) ((MagickOffsetType)
resource_info.thread_limit));
(void) FormatLocaleFile(file," Throttle: %.20g\n",(double)
((MagickOffsetType) resource_info.throttle_limit));
(void) FormatLocaleFile(file," Time: %s\n",time_limit);
(void) fflush(file);
UnlockSemaphoreInfo(resource_semaphore);
return(MagickTrue);
}
MagickExport void RelinquishMagickResource(const ResourceType type,
const MagickSizeType size)
{
char
resource_current[MaxTextExtent],
resource_limit[MaxTextExtent],
resource_request[MaxTextExtent];
(void) FormatMagickSize(size,MagickFalse,resource_request);
if (resource_semaphore == (SemaphoreInfo *) NULL)
ActivateSemaphoreInfo(&resource_semaphore);
LockSemaphoreInfo(resource_semaphore);
switch (type)
{
case WidthResource:
{
resource_info.width=(MagickOffsetType) size;
(void) FormatMagickSize((MagickSizeType) resource_info.width,MagickFalse,
resource_current);
(void) FormatMagickSize(resource_info.width_limit,MagickFalse,
resource_limit);
break;
}
case HeightResource:
{
resource_info.height=(MagickOffsetType) size;
(void) FormatMagickSize((MagickSizeType) resource_info.height,MagickFalse,
resource_current);
(void) FormatMagickSize(resource_info.height_limit,MagickFalse,
resource_limit);
break;
}
case AreaResource:
{
resource_info.area=(MagickOffsetType) size;
(void) FormatMagickSize((MagickSizeType) resource_info.area,MagickFalse,
resource_current);
(void) FormatMagickSize(resource_info.area_limit,MagickFalse,
resource_limit);
break;
}
case MemoryResource:
{
resource_info.memory-=size;
(void) FormatMagickSize((MagickSizeType) resource_info.memory,
MagickTrue,resource_current);
(void) FormatMagickSize(resource_info.memory_limit,MagickTrue,
resource_limit);
break;
}
case MapResource:
{
resource_info.map-=size;
(void) FormatMagickSize((MagickSizeType) resource_info.map,MagickTrue,
resource_current);
(void) FormatMagickSize(resource_info.map_limit,MagickTrue,
resource_limit);
break;
}
case DiskResource:
{
resource_info.disk-=size;
(void) FormatMagickSize((MagickSizeType) resource_info.disk,MagickTrue,
resource_current);
(void) FormatMagickSize(resource_info.disk_limit,MagickTrue,
resource_limit);
break;
}
case FileResource:
{
resource_info.file-=size;
(void) FormatMagickSize((MagickSizeType) resource_info.file,MagickFalse,
resource_current);
(void) FormatMagickSize((MagickSizeType) resource_info.file_limit,
MagickFalse,resource_limit);
break;
}
case ThreadResource:
{
(void) FormatMagickSize((MagickSizeType) resource_info.thread,MagickFalse,
resource_current);
(void) FormatMagickSize((MagickSizeType) resource_info.thread_limit,
MagickFalse,resource_limit);
break;
}
case ThrottleResource:
{
(void) FormatMagickSize((MagickSizeType) resource_info.throttle,
MagickFalse,resource_current);
(void) FormatMagickSize((MagickSizeType) resource_info.throttle_limit,
MagickFalse,resource_limit);
break;
}
case TimeResource:
{
resource_info.time-=size;
(void) FormatMagickSize((MagickSizeType) resource_info.time,MagickFalse,
resource_current);
(void) FormatMagickSize((MagickSizeType) resource_info.time_limit,
MagickFalse,resource_limit);
break;
}
default:
break;
}
UnlockSemaphoreInfo(resource_semaphore);
(void) LogMagickEvent(ResourceEvent,GetMagickModule(),"%s: %s/%s/%s",
CommandOptionToMnemonic(MagickResourceOptions,(ssize_t) type),
resource_request,resource_current,resource_limit);
}
MagickExport MagickBooleanType RelinquishUniqueFileResource(const char *path)
{
char
cache_path[MaxTextExtent];
MagickBooleanType
status;
assert(path != (const char *) NULL);
status=MagickFalse;
(void) LogMagickEvent(ResourceEvent,GetMagickModule(),"Relinquish %s",path);
if (resource_semaphore == (SemaphoreInfo *) NULL)
ActivateSemaphoreInfo(&resource_semaphore);
LockSemaphoreInfo(resource_semaphore);
if (temporary_resources != (SplayTreeInfo *) NULL)
status=DeleteNodeFromSplayTree(temporary_resources, (const void *) path);
UnlockSemaphoreInfo(resource_semaphore);
(void) CopyMagickString(cache_path,path,MaxTextExtent);
AppendImageFormat("cache",cache_path);
(void) ShredFile(cache_path);
if (status == MagickFalse)
status=ShredFile(path);
return(status);
}
static inline MagickSizeType StringToSizeType(const char *string,
const double interval)
{
double
value;
value=SiPrefixToDoubleInterval(string,interval);
if (value >= (double) MagickULLConstant(~0))
return(MagickULLConstant(~0));
return((MagickSizeType) value);
}
MagickExport MagickBooleanType ResourceComponentGenesis(void)
{
char
*limit;
MagickSizeType
memory;
ssize_t
files,
pages,
pagesize;
if (resource_semaphore == (SemaphoreInfo *) NULL)
resource_semaphore=AllocateSemaphoreInfo();
(void) SetMagickResourceLimit(WidthResource,resource_info.width_limit);
limit=GetEnvironmentValue("MAGICK_WIDTH_LIMIT");
if (limit != (char *) NULL)
{
(void) SetMagickResourceLimit(WidthResource,StringToSizeType(limit,
100.0));
limit=DestroyString(limit);
}
(void) SetMagickResourceLimit(HeightResource,resource_info.width_limit);
limit=GetEnvironmentValue("MAGICK_HEIGHT_LIMIT");
if (limit != (char *) NULL)
{
(void) SetMagickResourceLimit(HeightResource,StringToSizeType(limit,
100.0));
limit=DestroyString(limit);
}
pagesize=GetMagickPageSize();
pages=(-1);
#if defined(MAGICKCORE_HAVE_SYSCONF) && defined(_SC_PHYS_PAGES)
pages=(ssize_t) sysconf(_SC_PHYS_PAGES);
#endif
memory=(MagickSizeType) pages*pagesize;
if ((pagesize <= 0) || (pages <= 0))
memory=2048UL*1024UL*1024UL;
#if defined(PixelCacheThreshold)
memory=PixelCacheThreshold;
#endif
(void) SetMagickResourceLimit(AreaResource,2*memory);
limit=GetEnvironmentValue("MAGICK_AREA_LIMIT");
if (limit != (char *) NULL)
{
(void) SetMagickResourceLimit(AreaResource,StringToSizeType(limit,100.0));
limit=DestroyString(limit);
}
(void) SetMagickResourceLimit(MemoryResource,memory);
limit=GetEnvironmentValue("MAGICK_MEMORY_LIMIT");
if (limit != (char *) NULL)
{
(void) SetMagickResourceLimit(MemoryResource,
StringToSizeType(limit,100.0));
limit=DestroyString(limit);
}
(void) SetMagickResourceLimit(MapResource,2*memory);
limit=GetEnvironmentValue("MAGICK_MAP_LIMIT");
if (limit != (char *) NULL)
{
(void) SetMagickResourceLimit(MapResource,StringToSizeType(limit,100.0));
limit=DestroyString(limit);
}
(void) SetMagickResourceLimit(DiskResource,MagickResourceInfinity);
limit=GetEnvironmentValue("MAGICK_DISK_LIMIT");
if (limit != (char *) NULL)
{
(void) SetMagickResourceLimit(DiskResource,StringToSizeType(limit,100.0));
limit=DestroyString(limit);
}
files=(-1);
#if defined(MAGICKCORE_HAVE_SYSCONF) && defined(_SC_OPEN_MAX)
files=(ssize_t) sysconf(_SC_OPEN_MAX);
#endif
#if defined(MAGICKCORE_HAVE_GETRLIMIT) && defined(RLIMIT_NOFILE)
if (files < 0)
{
struct rlimit
resources;
if (getrlimit(RLIMIT_NOFILE,&resources) != -1)
files=(ssize_t) resources.rlim_cur;
}
#endif
#if defined(MAGICKCORE_HAVE_GETDTABLESIZE) && defined(MAGICKCORE_POSIX_SUPPORT)
if (files < 0)
files=(ssize_t) getdtablesize();
#endif
if (files < 0)
files=64;
(void) SetMagickResourceLimit(FileResource,MagickMax((size_t)
(3*files/4),64));
limit=GetEnvironmentValue("MAGICK_FILE_LIMIT");
if (limit != (char *) NULL)
{
(void) SetMagickResourceLimit(FileResource,StringToSizeType(limit,100.0));
limit=DestroyString(limit);
}
(void) SetMagickResourceLimit(ThreadResource,GetOpenMPMaximumThreads());
limit=GetEnvironmentValue("MAGICK_THREAD_LIMIT");
if (limit != (char *) NULL)
{
(void) SetMagickResourceLimit(ThreadResource,StringToSizeType(limit,
100.0));
limit=DestroyString(limit);
}
(void) SetMagickResourceLimit(ThrottleResource,0);
limit=GetEnvironmentValue("MAGICK_THROTTLE_LIMIT");
if (limit != (char *) NULL)
{
(void) SetMagickResourceLimit(ThrottleResource,StringToSizeType(limit,
100.0));
limit=DestroyString(limit);
}
(void) SetMagickResourceLimit(TimeResource,MagickResourceInfinity);
limit=GetEnvironmentValue("MAGICK_TIME_LIMIT");
if (limit != (char *) NULL)
{
(void) SetMagickResourceLimit(TimeResource,StringToSizeType(limit,100.0));
limit=DestroyString(limit);
}
return(MagickTrue);
}
MagickExport void ResourceComponentTerminus(void)
{
if (resource_semaphore == (SemaphoreInfo *) NULL)
ActivateSemaphoreInfo(&resource_semaphore);
LockSemaphoreInfo(resource_semaphore);
if (temporary_resources != (SplayTreeInfo *) NULL)
temporary_resources=DestroySplayTree(temporary_resources);
if (random_info != (RandomInfo *) NULL)
random_info=DestroyRandomInfo(random_info);
UnlockSemaphoreInfo(resource_semaphore);
DestroySemaphoreInfo(&resource_semaphore);
}
MagickExport MagickBooleanType SetMagickResourceLimit(const ResourceType type,
const MagickSizeType limit)
{
char
*value;
if (resource_semaphore == (SemaphoreInfo *) NULL)
ActivateSemaphoreInfo(&resource_semaphore);
LockSemaphoreInfo(resource_semaphore);
value=(char *) NULL;
switch (type)
{
case WidthResource:
{
resource_info.width_limit=limit;
value=GetPolicyValue("width");
if (value != (char *) NULL)
resource_info.width_limit=MagickMin(limit,StringToSizeType(value,
100.0));
break;
}
case HeightResource:
{
resource_info.height_limit=limit;
value=GetPolicyValue("height");
if (value != (char *) NULL)
resource_info.height_limit=MagickMin(limit,StringToSizeType(value,
100.0));
break;
}
case AreaResource:
{
resource_info.area_limit=limit;
value=GetPolicyValue("area");
if (value != (char *) NULL)
resource_info.area_limit=MagickMin(limit,StringToSizeType(value,100.0));
break;
}
case MemoryResource:
{
resource_info.memory_limit=limit;
value=GetPolicyValue("memory");
if (value != (char *) NULL)
resource_info.memory_limit=MagickMin(limit,StringToSizeType(value,
100.0));
break;
}
case MapResource:
{
resource_info.map_limit=limit;
value=GetPolicyValue("map");
if (value != (char *) NULL)
resource_info.map_limit=MagickMin(limit,StringToSizeType(value,100.0));
break;
}
case DiskResource:
{
resource_info.disk_limit=limit;
value=GetPolicyValue("disk");
if (value != (char *) NULL)
resource_info.disk_limit=MagickMin(limit,StringToSizeType(value,100.0));
break;
}
case FileResource:
{
resource_info.file_limit=limit;
value=GetPolicyValue("file");
if (value != (char *) NULL)
resource_info.file_limit=MagickMin(limit,StringToSizeType(value,100.0));
break;
}
case ThreadResource:
{
resource_info.thread_limit=limit;
value=GetPolicyValue("thread");
if (value != (char *) NULL)
resource_info.thread_limit=MagickMin(limit,StringToSizeType(value,
100.0));
if (resource_info.thread_limit > GetOpenMPMaximumThreads())
resource_info.thread_limit=GetOpenMPMaximumThreads();
break;
}
case ThrottleResource:
{
resource_info.throttle_limit=limit;
value=GetPolicyValue("throttle");
if (value != (char *) NULL)
resource_info.throttle_limit=MagickMin(limit,StringToSizeType(value,
100.0));
if (resource_info.throttle_limit > GetOpenMPMaximumThreads())
resource_info.throttle_limit=GetOpenMPMaximumThreads();
else if (resource_info.thread_limit == 0)
resource_info.thread_limit=1;
break;
}
case TimeResource:
{
resource_info.time_limit=limit;
value=GetPolicyValue("time");
if (value != (char *) NULL)
resource_info.time_limit=MagickMin(limit,StringToSizeType(value,100.0));
break;
}
default:
break;
}
if (value != (char *) NULL)
value=DestroyString(value);
UnlockSemaphoreInfo(resource_semaphore);
return(MagickTrue);
}