/*

% Copyright (C) 2003-2026 GraphicsMagick Group

% Copyright (C) 2002 ImageMagick Studio

% Copyright 1991-1999 E. I. du Pont de Nemours and Company

%

% This program is covered by multiple licenses, which are described in

% Copyright.txt. You should have received a copy of Copyright.txt with this

% package; otherwise see http://www.graphicsmagick.org/www/Copyright.html.

%

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%                  M   M   AAA    GGGG  IIIII   CCCC  K   K                   %

%                  MM MM  A   A  G        I    C      K  K                    %

%                  M M M  AAAAA  G GGG    I    C      KKK                     %

%                  M   M  A   A  G   G    I    C      K  K                    %

%                  M   M  A   A   GGGG  IIIII   CCCC  K   K                   %

%                                                                             %

%                                                                             %

%            Methods to Read or List GraphicsMagick Image formats             %

%                                                                             %

%                                                                             %

%                            Software Design                                  %

%                            Bob Friesenhahn                                  %

%                              John Cristy                                    %

%                             November 1998                                   %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%

*/

/*

  Include declarations.

*/

#include "magick/studio.h"

#if defined(USE_GLIBC_MTRACE) && USE_GLIBC_MTRACE

#  include <mcheck.h>

#endif /* if defined(USE_GLIBC_MTRACE) && USE_GLIBC_MTRACE */

#if defined(MSWINDOWS) || defined(__CYGWIN__)

# include "magick/nt_feature.h"

#endif

#include "magick/blob.h"

#include "magick/color_lookup.h"

#include "magick/command.h"

#include "magick/constitute.h"

#include "magick/delegate.h"

#include "magick/log.h"

#include "magick/magic.h"

#include "magick/magick.h"

#include "magick/module.h"

#include "magick/monitor.h"

#include "magick/pixel_cache.h"

#include "magick/random.h"

#include "magick/registry.h"

#include "magick/resource.h"

#include "magick/render.h"

#include "magick/semaphore.h"

#include "magick/tempfile.h"

#include "magick/utility.h"

#include "magick/version.h"

#if defined(HasX11)

#include "magick/xwindow.h"

#endif

/* watch out here - this include code for simple spinlock semaphore */

#include "magick/spinlock.h"

/*

  Global declarations.

*/

typedef enum  {

  InitDefault,

  InitUninitialized,

  InitInitialized

} MagickInitializationState;

static void

  DestroyMagickInfoList(void);

static SemaphoreInfo

  *magick_semaphore = (SemaphoreInfo *) NULL;

static SemaphoreInfo

  *module_semaphore = (SemaphoreInfo *) NULL;

static MagickInfo

  *magick_list = (MagickInfo *) NULL;

static unsigned int initialize_magick_options = 0;

static unsigned int panic_signal_handler_call_count = 0;

static unsigned int quit_signal_handler_call_count = 0;

static MagickInitializationState MagickInitialized = InitDefault;

static CoderClass MinimumCoderClass = UnstableCoderClass;

static void DestroyMagickInfo(MagickInfo** magick_info);

static void DestroyMagickInfoList(void);

static MagickPassFail InitializeMagickInfoList(void);

/*

  Block size to use when accessing filesystem.

  Adjust via MAGICK_IOBUF_SIZE environment variable.

*/

static size_t filesystem_blocksize=16384;

/*

  Get blocksize to use when accessing the filesystem.

*/

size_t

MagickGetFileSystemBlockSize(void)

{

  return filesystem_blocksize;

}

/*

  Set blocksize to use when accessing the filesystem.

*/

void

MagickSetFileSystemBlockSize(const size_t block_size)

{

  assert(block_size > 0);

  filesystem_blocksize=block_size;

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   D e s t r o y M a g i c k                                                 %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  DestroyMagick() destroys the GraphicsMagick environment, releasing all

%  allocated semaphores, memory, and temporary files.  This function

%  should be invoked in the primary (original) thread of the application's

%  process while shutting down, and only after any threads which might be

%  using GraphicsMagick functions have terminated.  Since GraphicsMagick

%  may use threads internally via OpenMP, it is also necessary for any

%  function calls into GraphicsMagick to have already returned so that

%  OpenMP worker threads are quiesced and won't be accessing any semaphores

%  or data structures which are destroyed by this function.

%

%  The OpenMP implementation (if present) starts/stops any OpenMP worker

%  threads and allocates/frees OpenMP resources using its own algorithms.

%  This means that OpenMP worker threads and OpenMP resources are likely

%  to remain allocated after DestroyMagick() returns.  Since OpenMP 5.0,

%  invoking omp_pause_resource_all(omp_pause_hard) will assure that any

%  resources allocated by OpenMP (threads, thread-specific memory, etc.)

%  are freed, and this may be called after DestroyMagick() has returned.

%

%  The format of the DestroyMagick function is:

%

%      DestroyMagick(void)

%

%

*/

MagickExport void

DestroyMagick(void)

{

  /* Acquire destruction lock */

  SPINLOCK_WAIT;

  if (MagickInitialized == InitUninitialized)

    {

      /* Release destruction lock */

      SPINLOCK_RELEASE;

      return;

    }

  (void) LogMagickEvent(ConfigureEvent,GetMagickModule(),

                        "Destroy Magick");

  MagickDestroyCommandInfo();   /* Command parser */

  DestroyMagickMonitor();       /* Progress monitor */

#if defined(HasX11)

  MagickXDestroyX11Resources();

#endif

  DestroyColorInfo();           /* Color database */

  DestroyDelegateInfo();        /* External delegate information */

  DestroyTypeInfo();            /* Font information */

  /*DestroyMagicInfo();*/       /* File format detection */

  DestroyMagickInfoList();      /* Coder registrations + modules */

  DestroyConstitute();          /* Constitute semaphore */

  DestroyMagickRegistry();      /* Registered images */

  DestroyMagickResources();     /* Resource semaphore */

  DestroyMagickRandomGenerator(); /* Random number generator */

  DestroyTemporaryFiles();      /* Temporary files */

#if defined(MSWINDOWS)

#if defined(HasGS)

  NTGhostscriptUnLoadDLL();     /* Ghostscript DLL */

#endif /* if defined(HasGS) */

#endif /* defined(MSWINDOWS) */

  /*

    Destroy logging last since some components log their destruction.

  */

  DestroyLogInfo();             /* Logging configuration */

  DestroyMagickExceptionHandling(); /* Exception handling */

  DestroySemaphore();           /* Semaphores framework */

  /* Now uninitialized */

  MagickInitialized=InitUninitialized;

  /* Release destruction lock */

  SPINLOCK_RELEASE;

}

/*

  Destroy MagickInfo structure.

*/

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   D e s t r o y M a g i c k I n f o                                         %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  DestroyMagickInfo() destroys a MagickInfo structure.

%

%  The format of the DestroyMagickInfoList method is:

%

%      void DestroyMagickInfo(MagickInfo** magick_info)

%

*/

static void

DestroyMagickInfo(MagickInfo** magick_info)

{

  MagickInfo

    *p;

  p=*magick_info;

  if (p)

    {

      p->name=0;

      p->description=0;

      p->version=0;

      p->note=0;

      p->module=0;

      MagickFreeMemory(p);

      *magick_info=p;

    }

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   D e s t r o y M a g i c k I n f o L i s t                                 %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  DestroyMagickInfo() deallocates memory associated with the MagickInfo list.

%

%  The format of the DestroyMagickInfoList method is:

%

%      void DestroyMagickInfoList(void)

%

*/

static void

DestroyMagickInfoList(void)

{

  MagickInfo

    *magick_info;

  register MagickInfo

    *p;

  DestroyMagickModules();

  /*

    At this point, the list should be empty, but check for remaining

    entries anyway.

  */

  if (magick_list != (MagickInfo *) NULL)

    (void) printf("Warning: module registrations are still present!\n");

  for (p=magick_list; p != (MagickInfo *) NULL; )

  {

    magick_info=p;

    p=p->next;

#if !defined(BuildMagickModules)

    (void) printf("Warning: module registration for \"%s\" from module \"%s\" still present!\n",

                  magick_info->name, magick_info->module);

#endif /* !defined(BuildMagickModules) */

    DestroyMagickInfo(&magick_info);

  }

  magick_list=(MagickInfo *) NULL;

  DestroySemaphoreInfo(&magick_semaphore);

  DestroySemaphoreInfo(&module_semaphore);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   G e t I m a g e M a g i c k                                               %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  GetImageMagick() searches for an image format that matches the specified

%  magick string.  If one is found the name is returned otherwise NULL.

%

%  The format of the GetImageMagick method is:

%

%      const char *GetImageMagick(const unsigned char *magick,

%        const size_t length)

%

%  A description of each parameter follows:

%

%    o magick: The image format we are searching for.

%

%    o length: The length of the binary string.

%

%

*/

MagickExport const char *

GetImageMagick(const unsigned char *magick,const size_t length)

{

  register MagickInfo

    *p;

  assert(magick != (const unsigned char *) NULL);

  LockSemaphoreInfo(magick_semaphore);

  for (p=magick_list; p != (MagickInfo *) NULL; p=p->next)

    if (p->magick && p->magick(magick,length))

      break;

  UnlockSemaphoreInfo(magick_semaphore);

  if (p != (MagickInfo *) NULL)

    return(p->name);

  return((char *) NULL);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   G e t M a g i c k I n f o                                                 %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  GetMagickInfo() returns a pointer MagickInfo structure that matches

%  the specified name.  If name is NULL, the head of the image format list

%  is returned. It is not safe to traverse the list by using the previous and

%  next pointers in the MagickInfo structure since the list contents or order

%  may be altered while the list is being traversed. If the list must be

%  traversed, access it via the GetMagickInfoArray function instead.

%

%  If GraphicsMagick has not been initialized via InitializeMagick()

%  then this function will not work.

%

%  The format of the GetMagickInfo method is:

%

%     const MagickInfo *GetMagickInfo(const char *name,ExceptionInfo *exception)

%

%  A description of each parameter follows:

%

%    o name: The image format we are looking for.

%

%    o exception: Return any errors or warnings in this structure.

%

%

*/

static MagickInfo *

GetMagickInfoEntryLocked(const char *name)

{

  register MagickInfo

    *p;

  LockSemaphoreInfo(magick_semaphore);

  p=magick_list;

  if ((name != (const char *) NULL) && (name[0] != '*'))

    {

      for (p=magick_list; p != (MagickInfo *) NULL; p=p->next)

        if (LocaleCompare(p->name,name) == 0)

          break;

      if (p != (MagickInfo *) NULL)

        if (p != magick_list)

          {

            /*

              Self-adjusting list.

            */

            if (p->previous != (MagickInfo *) NULL)

              p->previous->next=p->next;

            if (p->next != (MagickInfo *) NULL)

              p->next->previous=p->previous;

            p->previous=(MagickInfo *) NULL;

            p->next=magick_list;

            magick_list->previous=p;

            magick_list=p;

          }

    }

  UnlockSemaphoreInfo(magick_semaphore);

  return p;

}

MagickExport const MagickInfo *

GetMagickInfo(const char *name,ExceptionInfo *exception)

{

  const MagickInfo

    *magick_info=(const MagickInfo *) NULL;

  if ((name != (const char *) NULL) &&

      (name[0] != '\0'))

    {

      LockSemaphoreInfo(module_semaphore);

      if (name[0] == '*')

        {

          /*

            If all modules are requested, then use OpenModules to load all

            modules.

          */

          (void) OpenModules(exception);

        }

      else

        {

          magick_info=GetMagickInfoEntryLocked(name);

          if (magick_info == (const MagickInfo *) NULL)

            {

              /*

                Try to load a supporting module.

              */

              (void) OpenModule(name,exception);

            }

        }

      UnlockSemaphoreInfo(module_semaphore);

    }

  /*

    Return whatever we've got

  */

  if (magick_info == (const MagickInfo *) NULL)

    magick_info=GetMagickInfoEntryLocked(name);

  return magick_info;

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   G e t M a g i c k I n f o A r r a y                                       %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  GetMagickInfoArray() returns a sorted null-terminated array of MagickInfo

%  pointers corresponding to the available format registrations. If necessarly

%  all modules are loaded in order to return a complete list. This function

%  should be used to access the entire list rather than GetMagickInfo since

%  the list returned by GetMagickInfo may be re-ordered every time it is

%  invoked. Once the returned array is no longer needed, the allocated array

%  should be deallocated. Do not attempt to deallocate the MagickInfo

%  structures based on pointers in the array!

%

%  The format of the GetMagickList method is:

%

%      MagickInfo **GetMagickInfoArray(ExceptionInfo *exception)

%

%  A description of each parameter follows:

%

%    o exception: Return any errors or warnings in this structure.

%

%

*/

/*

  Compare two MagickInfo structures based on their name

*/

static int

MagickInfoCompare(const void *x, const void *y)

{

  const MagickInfo

    *xx=*((const MagickInfo **) x),

    *yy=*((const MagickInfo **) y);

  return (strcmp(xx->name, yy->name));

}

MagickExport MagickInfo **

GetMagickInfoArray(ExceptionInfo *exception)

{

  MagickInfo

    **array;

  MagickInfo

    *p;

  MagickInfo

    *list;

  size_t

    entries=0;

  int

    i;

  /*

    Load all modules and obtain pointer to head of list

  */

  (void) GetMagickInfo("*",exception);

  LockSemaphoreInfo(magick_semaphore);

  if (!magick_list)

    {

      UnlockSemaphoreInfo(magick_semaphore);

      return ((MagickInfo **) NULL);

    }

  list=magick_list;

  /*

    Count number of list entries

  */

  for (p=list; p != 0; p=p->next)

    entries++;

  /*

    Allocate array memory

  */

  array=MagickAllocateArray(MagickInfo **,(entries+1),sizeof(MagickInfo *));

  if (!array)

    {

      UnlockSemaphoreInfo(magick_semaphore);

      ThrowException(exception,ResourceLimitError,MemoryAllocationFailed,0);

      return ((MagickInfo **) NULL);

    }

  /*

    Add entries to array

  */

  i=0;

  for (p=list; p != 0; p=p->next)

    array[i++]=p;

  array[i]=(MagickInfo *) NULL;

  UnlockSemaphoreInfo(magick_semaphore);

  /*

    Sort array entries

  */

  qsort((void *) array, entries, sizeof(MagickInfo *), MagickInfoCompare);

  return (array);

}

/*

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%                                                                             %

%                                                                             %

%                                                                             %

%   I n i t i a l i z e M a g i c k                                           %

%                                                                             %

%                                                                             %

%                                                                             %

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

%

%  InitializeMagick() initializes the GraphicsMagick environment.

%

%  InitializeMagick() or InitializeMagickEx() MUST be invoked by the using

%  program before making use of GraphicsMagick functions or else the library

%  will be unusable and any usage is likely to cause a crash.

%

%  This function should be invoked in the primary (original) thread of the

%  application's process, and before starting any OpenMP threads, as part

%  of program initialization.

%

%  If alternate memory allocations are provided via MagickAllocFunctions()

%  then that function should be invoked before InitializeMagickEx() since

%  the memory allocation functions need to be consistent.

%

%  The format of the InitializeMagick function is:

%

%      InitializeMagick(const char *path)

%

%  A description of each parameter follows:

%

%    o path: The execution path of the current GraphicsMagick client (or NULL)

%

%

*/

/*

  Due to legacy compilers, POSIX.1 actually allows the signal function

  to return 'int' or 'void'. The compiler is not so lenient so we must

  ensure that the return type matches the prototype in the headers.

*/

#if !defined(RETSIGTYPE)

# define RETSIGTYPE void

#endif

typedef RETSIGTYPE Sigfunc(int);

#if !defined(SIG_ERR)

# define SIG_ERR (Sigfunc *)-1

#endif

#if !defined(SIG_DFL)

# define SIG_DFL (Sigfunc *)0

#endif

static RETSIGTYPE MagickPanicSignalHandler(int signo);

static RETSIGTYPE MagickSignalHandler(int signo);

/*

  Signal function which only sets the signal handler if it its handling

  is still set to SIG_DFL. This ensures that signal handlers are not

  registered for signals which are being ignored, or that the API

  user has already registered before invoking InitializeMagick.

  Due to a weakness in the POSIX APIs, the only way to see the handler

  which was registered before is by registering a new handler.

  If an API user registers its own signal handler, then it is responsible

  for invoking DestroyMagick when a signal is received.

*/

static void

MagickCondSignal(int signo, Sigfunc *func)

{

#if defined(HAVE_SIGACTION) && defined(HAVE_SIGEMPTYSET)

  struct sigaction

    act,

    oact;

  /*

    Signal set-up code which prevents interrupted system calls from

    automatically being restarted. From W. Richard Stevens "Advanced

    Programming in the UNIX Environment", Chapter 10.14.

  */

  act.sa_handler=func;

  (void) sigemptyset(&act.sa_mask);

  act.sa_flags=0;

#  if defined(SA_INTERRUPT)  /* SunOS */

  act.sa_flags |= SA_INTERRUPT;

#  endif /* if defined(SA_INTERRUPT) */

#  if defined(SA_ONSTACK)  /* Use alternate signal stack if available */

  act.sa_flags |= SA_ONSTACK;

#  endif /* if defined(SA_ONSTACK) */

  (void) memset(&oact, 0, sizeof(oact));

  if (sigaction(signo, &act, &oact) == 0)

    {

      if ((oact.sa_flags & SA_SIGINFO) ||

          (oact.sa_handler != SIG_DFL))

        {

          /* Restore prior handler! */

          if (sigaction(signo, &oact, &act) != 0)

            (void) LogMagickEvent(ConfigureEvent,GetMagickModule(),

                                  "Failed to restore prior signal handler for signal ID %d!",signo);

          else

            (void) LogMagickEvent(ConfigureEvent,GetMagickModule(),

                                  "Restored prior signal handler for signal ID %d!",signo);

        }

      else

        {

          (void) LogMagickEvent(ConfigureEvent,GetMagickModule(),

                                "Registered signal handler for signal ID %d",signo);

        }

    }

  else

    {

      (void) LogMagickEvent(ConfigureEvent,GetMagickModule(),

                            "Failed to register signal handler for signal ID %d!",signo);

    }

#else

  Sigfunc *

    o_handler;

  if ((o_handler=signal(signo, func)) != SIG_ERR)

    {

      if (o_handler != SIG_DFL)

        {

          /* Restore prior handler! */

          if (signal(signo, o_handler) ==  SIG_ERR)

            (void) LogMagickEvent(ConfigureEvent,GetMagickModule(),

                                  "Failed to restore prior signal handler for signal ID %d!",signo);

          else

            (void) LogMagickEvent(ConfigureEvent,GetMagickModule(),

                                  "Restored prior signal handler for signal ID %d!",signo);

        }

      else

        {

          (void) LogMagickEvent(ConfigureEvent,GetMagickModule(),

                                "Registered signal handler for signal ID %d",signo);

        }

    }

  else

    {

      (void) LogMagickEvent(ConfigureEvent,GetMagickModule(),

                            "Failed to register signal handler for signal ID %d!",signo);

    }

#endif

}

/*

  Signal handler which does nothing.

*/

#if 0

static RETSIGTYPE

MagickIgnoreSignalHandler(int signo)

{

  fprintf(stderr,"Caught ignored signal %d\n", signo);

}

#endif

/*

  Write a message about the signal to stderr.

*/

static void

MagickSignalHandlerMessage(const int signo, const char *subtext)

{

  /*

    Signals we might handle, to map to their common description.

    May use strsignal() on POSIX.1-2008-compliant systems, but it is

    not documented to be async-safe.

  */

  static const struct {

    const int signo;

    const char name[8];

    const char *descr;

  } signal_descr[] = {

#if defined(SIGHUP)

    { SIGHUP, "SIGHUP","Hangup" },

#endif

#if defined(SIGINT)

    { SIGINT, "SIGINT", "Interrupt" },

#endif

#if defined(SIGQUIT)

    { SIGQUIT, "SIGQUIT", "Quit" },

#endif

#if defined(SIGILL)

    { SIGILL, "SIGILL", "Illegal Instruction" },

#endif

#if defined(SIGABRT)

    { SIGABRT, "SIGABRT", "Abort" },

#endif

#if defined(SIGFPE)

    { SIGFPE, "SIGFPE", "Arithmetic Exception" },

#endif

#if defined(SIGBUS)

    { SIGBUS, "SIGBUS", "Bus Error" },

#endif

#if defined(SIGSEGV)

    { SIGSEGV, "SIGSEGV", "Segmentation Fault" },

#endif

#if defined(SIGPIPE)

    { SIGPIPE, "SIGPIPE", "Broken Pipe" },

#endif

#if defined(SIGALRM)

    { SIGALRM, "SIGALRM", "Alarm Clock" },

#endif

#if defined(SIGTERM)

    { SIGTERM, "SIGTERM", "Terminated" },

#endif

#if defined(SIGCHLD)

    { SIGCHLD, "SIGCHLD", "Child Status Changed" },

#endif

#if defined(SIGXCPU)

    { SIGXCPU, "SIGXCPU", "CPU time limit exceeded" },

#endif

#if defined(SIGXFSZ)

    { SIGXFSZ, "SIGXFSZ", "File size limit exceeded" }

#endif

  };

  static char

    message[128];

  size_t

    i;

  int

    num=signo;

  /*

    Output messages like:

    gm convert: quitting due to signal 2 (SIGINT) "Interrupt"...

    gm convert: abort due to signal 11 (SIGSEGV) "Segmentation Fault"...

  */

  (void) strlcpy(message, GetClientName(), sizeof(message));

  (void) strlcat(message,": ", sizeof(message));

  (void) strlcat(message,subtext,sizeof(message));

  (void) strlcat(message," due to signal ",sizeof(message));

  i=strlen(message);

  for ( ; (num != 0) && (i < sizeof(message)-1) ; i++)

    {

      int rem = num % 10;

      message[i] = rem + '0';

      num = num/10;

    }

  message[i] = '\0';

  for ( i=0; i < (sizeof(signal_descr)/sizeof(signal_descr[0])); i++)

    {

      if (signo == signal_descr[i].signo)

        {

          (void) strlcat(message," (",sizeof(message));

          (void) strlcat(message,signal_descr[i].name,sizeof(message));

          (void) strlcat(message,") \"",sizeof(message));

          (void) strlcat(message,signal_descr[i].descr,sizeof(message));

          (void) strlcat(message,"\"",sizeof(message));

        }

    }

  (void) strlcat(message,"...\n",sizeof(message));

  if (write(STDERR_FILENO,message,

            (MAGICK_POSIX_IO_SIZE_T) strlen(message)) == -1)

    {

      /* Exists to quench warning */

    }

}

/*

  Signal handler to ensure that DestroyMagick is invoked in case the

  user aborts the program.

  The WIN32 documentation says that SIGINT is not supported under any

  version of Windows. It also says that a new thread is created to

  handle the interrupt caused by CNTRL+C. The Windows signal

  documentation also says that it is unsafe to do anything useful from

  within a signal handler.  This means that malloc/free and any system

  call should not be executed. Theoretically DestroyMagick() should

  not be executed since its purpose is to invoke unsafe functions.

  SIGILL, SIGSEGV, and SIGTERM are documented to never be generated by

  Windows NT.

  While support for signal is definitely broken under Windows, the good

  news is that it seems to be unlikely to generate a signal we care about.

*/

static RETSIGTYPE

MagickPanicSignalHandler(int signo)

{

  ARG_NOT_USED(signo);

  panic_signal_handler_call_count++;

  /*

    Only handle signal one time.

  */

  if (1 == panic_signal_handler_call_count)

    {

      /*

        Release persistent resources

      */

      PanicDestroyMagick();

      /*

        Produce a useful message for the user

      */

      MagickSignalHandlerMessage(signo,"abort");

      /*

        Call abort so that we quit with core dump.

      */

      abort();

    }

}

static MagickBool QuitProgressMonitor(const char *task,

                                      const magick_int64_t quantum,

                                      const magick_uint64_t span,

                                      ExceptionInfo *exception)

{

  ARG_NOT_USED(task);

  ARG_NOT_USED(quantum);

  ARG_NOT_USED(span);

  /* Report an error message */

  if (exception->severity < FatalErrorException)

    ThrowException(exception,MonitorFatalError,UserRequestedTerminationBySignal,0);

  return MagickFail;

}

static RETSIGTYPE

MagickSignalHandler(int signo)

{

  /* fprintf(stderr,"Caught signal %d\n", signo); */

  quit_signal_handler_call_count++;

  /*

    Only handle signal one time.

  */

  if (1 == quit_signal_handler_call_count)

    {

      if (MagickInitialized == InitInitialized)

        {

          /*

            Set progress monitor handler to one which always returns

            MagickFail.

          */

          (void) SetMonitorHandler(QuitProgressMonitor);

          /*

            Release persistent resources

          */

          PanicDestroyMagick();

          /*

            Produce a useful message for the user

          */

          if (signo != SIGINT)

            MagickSignalHandlerMessage(signo,"quitting");

        }

      /*

        Invoke _exit(signo) (or equivalent) which avoids invoking

        registered atexit() functions.

      */

      SignalHandlerExit(signo);

    }

}

/*

   The goal of this routine is to determine whether the passed

   string is a valid and complete path to a file within the

   filesystem

 */

#if !defined(UseInstalledMagick)

static unsigned int

IsValidFilesystemPath(const char *path)

{

  if ((path != (const char *) NULL) && (*path != '\0'))

    {

#if defined(POSIX)

      /* For POSIX we check the first character to see of it is a file

          system path separator. If not then we ignore the passed data

      */

      if ((*path == *DirectorySeparator))

        return IsAccessibleNoLogging(path);

#elif defined(MSWINDOWS)

      /* For Windows we check to see if the path passed seems to be a

         pathof any kind (contains delimiters) or seem to be either UNC

         path or one with a drive letter spec in it: \\Server\share, C:\

      */

      if (((*path == *DirectorySeparator) && (*(path+1) == *DirectorySeparator)) ||

            (*(path+1) == ':') ||

              (strchr(path,*DirectorySeparator) != (char *) NULL))

        return IsAccessibleNoLogging(path);

#else

      /* In any other case, we just look to see if it has path delimiters */

      if ((strchr(path,*DirectorySeparator) != (char *) NULL))

        return IsAccessibleNoLogging(path);

#endif

    }

  return False;

}

#endif /* !defined(UseInstalledMagick) */

/*

  Try and figure out the path and name of the client

 */

static void

InitializeMagickClientPathAndName(const char *path)

{

#if !defined(UseInstalledMagick)

  const char

    *spath;

  char

    execution_path[MaxTextExtent];

  /* the following is to make the logging more readable later on */

  spath = path;

  if (spath == (char *) NULL)

    spath = "NULL";

  if (*spath == '\0')

    spath = "EMPTY";

  *execution_path='\0';

  if (!IsValidFilesystemPath(path))

    {

      /*

        If the path passed is NULL or invalid then we try to ask the

        OS what the name of the executable is. Callers will often pass

        NULL in order to invoke this functionality.

      */

      if (GetExecutionPath(execution_path))

        {

          /*

            The call to the OS worked so we can do all the settings

          */

          (void) DefineClientPathAndName(execution_path);

          (void) LogMagickEvent(ConfigureEvent,GetMagickModule(),

            "Invalid path \"%s\" passed - asking OS worked: \"%s\"",spath,

              execution_path);

        }

      else

        {