• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 %                                                                             %
4 %                                                                             %
5 %                                                                             %
6 %                  M   M   OOO   DDDD   U   U  L      EEEEE                   %
7 %                  MM MM  O   O  D   D  U   U  L      E                       %
8 %                  M M M  O   O  D   D  U   U  L      EEE                     %
9 %                  M   M  O   O  D   D  U   U  L      E                       %
10 %                  M   M   OOO   DDDD    UUU   LLLLL  EEEEE                   %
11 %                                                                             %
12 %                                                                             %
13 %                          MagickCore Module Methods                          %
14 %                                                                             %
15 %                              Software Design                                %
16 %                              Bob Friesenhahn                                %
17 %                                March 2000                                   %
18 %                                                                             %
19 %                                                                             %
20 %  Copyright 1999-2019 ImageMagick Studio LLC, a non-profit organization      %
21 %  dedicated to making software imaging solutions freely available.           %
22 %                                                                             %
23 %  You may not use this file except in compliance with the License.  You may  %
24 %  obtain a copy of the License at                                            %
25 %                                                                             %
26 %    https://imagemagick.org/script/license.php                               %
27 %                                                                             %
28 %  Unless required by applicable law or agreed to in writing, software        %
29 %  distributed under the License is distributed on an "AS IS" BASIS,          %
30 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
31 %  See the License for the specific language governing permissions and        %
32 %  limitations under the License.                                             %
33 %                                                                             %
34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
35 %
36 %
37 %
38 */
39 
40 /*
41   Include declarations.
42 */
43 #include "MagickCore/studio.h"
44 #include "MagickCore/blob.h"
45 #include "MagickCore/coder.h"
46 #include "MagickCore/client.h"
47 #include "MagickCore/configure.h"
48 #include "MagickCore/exception.h"
49 #include "MagickCore/exception-private.h"
50 #include "MagickCore/log.h"
51 #include "MagickCore/linked-list.h"
52 #include "MagickCore/magic.h"
53 #include "MagickCore/magick.h"
54 #include "MagickCore/memory_.h"
55 #include "MagickCore/memory-private.h"
56 #include "MagickCore/module.h"
57 #include "MagickCore/module-private.h"
58 #include "MagickCore/nt-base-private.h"
59 #include "MagickCore/policy.h"
60 #include "MagickCore/semaphore.h"
61 #include "MagickCore/splay-tree.h"
62 #include "MagickCore/static.h"
63 #include "MagickCore/string_.h"
64 #include "MagickCore/string-private.h"
65 #include "MagickCore/token.h"
66 #include "MagickCore/utility.h"
67 #include "MagickCore/utility-private.h"
68 #if defined(MAGICKCORE_MODULES_SUPPORT)
69 #if defined(MAGICKCORE_LTDL_DELEGATE)
70 #include "ltdl.h"
71 typedef lt_dlhandle ModuleHandle;
72 #else
73 typedef void *ModuleHandle;
74 #endif
75 
76 /*
77   Define declarations.
78 */
79 #if defined(MAGICKCORE_LTDL_DELEGATE)
80 #  define ModuleGlobExpression "*.la"
81 #else
82 #  if defined(_DEBUG)
83 #    define ModuleGlobExpression "IM_MOD_DB_*.dll"
84 #  else
85 #    define ModuleGlobExpression "IM_MOD_RL_*.dll"
86 #  endif
87 #endif
88 
89 /*
90   Global declarations.
91 */
92 static SemaphoreInfo
93   *module_semaphore = (SemaphoreInfo *) NULL;
94 
95 static SplayTreeInfo
96   *module_list = (SplayTreeInfo *) NULL;
97 
98 /*
99   Forward declarations.
100 */
101 static const ModuleInfo
102   *RegisterModule(const ModuleInfo *,ExceptionInfo *);
103 
104 static MagickBooleanType
105   GetMagickModulePath(const char *,MagickModuleType,char *,ExceptionInfo *),
106   IsModuleTreeInstantiated(),
107   UnregisterModule(const ModuleInfo *,ExceptionInfo *);
108 
109 static void
110   TagToCoderModuleName(const char *,char *),
111   TagToFilterModuleName(const char *,char *),
112   TagToModuleName(const char *,const char *,char *);
113 
114 /*
115 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
116 %                                                                             %
117 %                                                                             %
118 %                                                                             %
119 %   A c q u i r e M o d u l e I n f o                                         %
120 %                                                                             %
121 %                                                                             %
122 %                                                                             %
123 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
124 %
125 %  AcquireModuleInfo() allocates the ModuleInfo structure.
126 %
127 %  The format of the AcquireModuleInfo method is:
128 %
129 %      ModuleInfo *AcquireModuleInfo(const char *path,const char *tag)
130 %
131 %  A description of each parameter follows:
132 %
133 %    o path: the path associated with the tag.
134 %
135 %    o tag: a character string that represents the image format we are
136 %      looking for.
137 %
138 */
AcquireModuleInfo(const char * path,const char * tag)139 MagickExport ModuleInfo *AcquireModuleInfo(const char *path,const char *tag)
140 {
141   ModuleInfo
142     *module_info;
143 
144   module_info=(ModuleInfo *) AcquireCriticalMemory(sizeof(*module_info));
145   (void) memset(module_info,0,sizeof(*module_info));
146   if (path != (const char *) NULL)
147     module_info->path=ConstantString(path);
148   if (tag != (const char *) NULL)
149     module_info->tag=ConstantString(tag);
150   module_info->timestamp=time(0);
151   module_info->signature=MagickCoreSignature;
152   return(module_info);
153 }
154 
155 /*
156 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
157 %                                                                             %
158 %                                                                             %
159 %                                                                             %
160 %   D e s t r o y M o d u l e L i s t                                         %
161 %                                                                             %
162 %                                                                             %
163 %                                                                             %
164 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
165 %
166 %  DestroyModuleList() unregisters any previously loaded modules and exits
167 %  the module loaded environment.
168 %
169 %  The format of the DestroyModuleList module is:
170 %
171 %      void DestroyModuleList(void)
172 %
173 */
DestroyModuleList(void)174 MagickExport void DestroyModuleList(void)
175 {
176   /*
177     Destroy magick modules.
178   */
179   LockSemaphoreInfo(module_semaphore);
180 #if defined(MAGICKCORE_MODULES_SUPPORT)
181   if (module_list != (SplayTreeInfo *) NULL)
182     module_list=DestroySplayTree(module_list);
183 #endif
184   UnlockSemaphoreInfo(module_semaphore);
185 }
186 
187 /*
188 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
189 %                                                                             %
190 %                                                                             %
191 %                                                                             %
192 %   G e t M o d u l e I n f o                                                 %
193 %                                                                             %
194 %                                                                             %
195 %                                                                             %
196 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
197 %
198 %  GetModuleInfo() returns a pointer to a ModuleInfo structure that matches the
199 %  specified tag.  If tag is NULL, the head of the module list is returned. If
200 %  no modules are loaded, or the requested module is not found, NULL is
201 %  returned.
202 %
203 %  The format of the GetModuleInfo module is:
204 %
205 %      ModuleInfo *GetModuleInfo(const char *tag,ExceptionInfo *exception)
206 %
207 %  A description of each parameter follows:
208 %
209 %    o tag: a character string that represents the image format we are
210 %      looking for.
211 %
212 %    o exception: return any errors or warnings in this structure.
213 %
214 */
GetModuleInfo(const char * tag,ExceptionInfo * exception)215 MagickExport ModuleInfo *GetModuleInfo(const char *tag,ExceptionInfo *exception)
216 {
217   ModuleInfo
218     *module_info;
219 
220   if (IsModuleTreeInstantiated() == MagickFalse)
221     return((ModuleInfo *) NULL);
222   LockSemaphoreInfo(module_semaphore);
223   ResetSplayTreeIterator(module_list);
224   if ((tag == (const char *) NULL) || (LocaleCompare(tag,"*") == 0))
225     {
226 #if defined(MAGICKCORE_MODULES_SUPPORT)
227       if (LocaleCompare(tag,"*") == 0)
228         (void) OpenModules(exception);
229 #endif
230       module_info=(ModuleInfo *) GetNextValueInSplayTree(module_list);
231       UnlockSemaphoreInfo(module_semaphore);
232       return(module_info);
233     }
234   module_info=(ModuleInfo *) GetValueFromSplayTree(module_list,tag);
235   UnlockSemaphoreInfo(module_semaphore);
236   return(module_info);
237 }
238 
239 /*
240 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
241 %                                                                             %
242 %                                                                             %
243 %                                                                             %
244 %   G e t M o d u l e I n f o L i s t                                         %
245 %                                                                             %
246 %                                                                             %
247 %                                                                             %
248 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
249 %
250 %  GetModuleInfoList() returns any modules that match the specified pattern.
251 %
252 %  The format of the GetModuleInfoList function is:
253 %
254 %      const ModuleInfo **GetModuleInfoList(const char *pattern,
255 %        size_t *number_modules,ExceptionInfo *exception)
256 %
257 %  A description of each parameter follows:
258 %
259 %    o pattern: Specifies a pointer to a text string containing a pattern.
260 %
261 %    o number_modules:  This integer returns the number of modules in the list.
262 %
263 %    o exception: return any errors or warnings in this structure.
264 %
265 */
266 
267 #if defined(__cplusplus) || defined(c_plusplus)
268 extern "C" {
269 #endif
270 
ModuleInfoCompare(const void * x,const void * y)271 static int ModuleInfoCompare(const void *x,const void *y)
272 {
273   const ModuleInfo
274     **p,
275     **q;
276 
277   p=(const ModuleInfo **) x,
278   q=(const ModuleInfo **) y;
279   if (LocaleCompare((*p)->path,(*q)->path) == 0)
280     return(LocaleCompare((*p)->tag,(*q)->tag));
281   return(LocaleCompare((*p)->path,(*q)->path));
282 }
283 
284 #if defined(__cplusplus) || defined(c_plusplus)
285 }
286 #endif
287 
GetModuleInfoList(const char * pattern,size_t * number_modules,ExceptionInfo * exception)288 MagickExport const ModuleInfo **GetModuleInfoList(const char *pattern,
289   size_t *number_modules,ExceptionInfo *exception)
290 {
291   const ModuleInfo
292     **modules;
293 
294   register const ModuleInfo
295     *p;
296 
297   register ssize_t
298     i;
299 
300   /*
301     Allocate module list.
302   */
303   assert(pattern != (char *) NULL);
304   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",pattern);
305   assert(number_modules != (size_t *) NULL);
306   *number_modules=0;
307   p=GetModuleInfo("*",exception);
308   if (p == (const ModuleInfo *) NULL)
309     return((const ModuleInfo **) NULL);
310   modules=(const ModuleInfo **) AcquireQuantumMemory((size_t)
311     GetNumberOfNodesInSplayTree(module_list)+1UL,sizeof(*modules));
312   if (modules == (const ModuleInfo **) NULL)
313     return((const ModuleInfo **) NULL);
314   /*
315     Generate module list.
316   */
317   LockSemaphoreInfo(module_semaphore);
318   ResetSplayTreeIterator(module_list);
319   p=(const ModuleInfo *) GetNextValueInSplayTree(module_list);
320   for (i=0; p != (const ModuleInfo *) NULL; )
321   {
322     if ((p->stealth == MagickFalse) &&
323         (GlobExpression(p->tag,pattern,MagickFalse) != MagickFalse))
324       modules[i++]=p;
325     p=(const ModuleInfo *) GetNextValueInSplayTree(module_list);
326   }
327   UnlockSemaphoreInfo(module_semaphore);
328   qsort((void *) modules,(size_t) i,sizeof(*modules),ModuleInfoCompare);
329   modules[i]=(ModuleInfo *) NULL;
330   *number_modules=(size_t) i;
331   return(modules);
332 }
333 
334 /*
335 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
336 %                                                                             %
337 %                                                                             %
338 %                                                                             %
339 %   G e t M o d u l e L i s t                                                 %
340 %                                                                             %
341 %                                                                             %
342 %                                                                             %
343 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
344 %
345 %  GetModuleList() returns any image format modules that match the specified
346 %  pattern.
347 %
348 %  The format of the GetModuleList function is:
349 %
350 %      char **GetModuleList(const char *pattern,const MagickModuleType type,
351 %        size_t *number_modules,ExceptionInfo *exception)
352 %
353 %  A description of each parameter follows:
354 %
355 %    o pattern: Specifies a pointer to a text string containing a pattern.
356 %
357 %    o type: choose from MagickImageCoderModule or MagickImageFilterModule.
358 %
359 %    o number_modules:  This integer returns the number of modules in the
360 %      list.
361 %
362 %    o exception: return any errors or warnings in this structure.
363 %
364 */
365 
366 #if defined(__cplusplus) || defined(c_plusplus)
367 extern "C" {
368 #endif
369 
ModuleCompare(const void * x,const void * y)370 static int ModuleCompare(const void *x,const void *y)
371 {
372   register const char
373     **p,
374     **q;
375 
376   p=(const char **) x;
377   q=(const char **) y;
378   return(LocaleCompare(*p,*q));
379 }
380 
381 #if defined(__cplusplus) || defined(c_plusplus)
382 }
383 #endif
384 
GetModuleList(const char * pattern,const MagickModuleType type,size_t * number_modules,ExceptionInfo * exception)385 MagickExport char **GetModuleList(const char *pattern,
386   const MagickModuleType type,size_t *number_modules,ExceptionInfo *exception)
387 {
388 #define MaxModules  511
389 
390   char
391     **modules,
392     filename[MagickPathExtent],
393     module_path[MagickPathExtent],
394     path[MagickPathExtent];
395 
396   DIR
397     *directory;
398 
399   MagickBooleanType
400     status;
401 
402   register ssize_t
403     i;
404 
405   size_t
406     max_entries;
407 
408   struct dirent
409     *buffer,
410     *entry;
411 
412   /*
413     Locate all modules in the image coder or filter path.
414   */
415   switch (type)
416   {
417     case MagickImageCoderModule:
418     default:
419     {
420       TagToCoderModuleName("magick",filename);
421       status=GetMagickModulePath(filename,MagickImageCoderModule,module_path,
422         exception);
423       break;
424     }
425     case MagickImageFilterModule:
426     {
427       TagToFilterModuleName("analyze",filename);
428       status=GetMagickModulePath(filename,MagickImageFilterModule,module_path,
429         exception);
430       break;
431     }
432   }
433   if (status == MagickFalse)
434     return((char **) NULL);
435   GetPathComponent(module_path,HeadPath,path);
436   max_entries=MaxModules;
437   modules=(char **) AcquireQuantumMemory((size_t) max_entries+1UL,
438     sizeof(*modules));
439   if (modules == (char **) NULL)
440     return((char **) NULL);
441   *modules=(char *) NULL;
442   directory=opendir(path);
443   if (directory == (DIR *) NULL)
444     {
445       modules=(char **) RelinquishMagickMemory(modules);
446       return((char **) NULL);
447     }
448   buffer=(struct dirent *) AcquireMagickMemory(sizeof(*buffer)+FILENAME_MAX+1);
449   if (buffer == (struct dirent *) NULL)
450     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
451   i=0;
452   while ((MagickReadDirectory(directory,buffer,&entry) == 0) &&
453          (entry != (struct dirent *) NULL))
454   {
455     status=GlobExpression(entry->d_name,ModuleGlobExpression,MagickFalse);
456     if (status == MagickFalse)
457       continue;
458     if (GlobExpression(entry->d_name,pattern,MagickFalse) == MagickFalse)
459       continue;
460     if (i >= (ssize_t) max_entries)
461       {
462         modules=(char **) NULL;
463         if (~max_entries > max_entries)
464           modules=(char **) ResizeQuantumMemory(modules,(size_t)
465             (max_entries << 1),sizeof(*modules));
466         max_entries<<=1;
467         if (modules == (char **) NULL)
468           break;
469       }
470     /*
471       Add new module name to list.
472     */
473     modules[i]=AcquireString((char *) NULL);
474     GetPathComponent(entry->d_name,BasePath,modules[i]);
475     if (LocaleNCompare("IM_MOD_",modules[i],7) == 0)
476       {
477         (void) CopyMagickString(modules[i],modules[i]+10,MagickPathExtent);
478         modules[i][strlen(modules[i])-1]='\0';
479       }
480     i++;
481   }
482   buffer=(struct dirent *) RelinquishMagickMemory(buffer);
483   (void) closedir(directory);
484   if (modules == (char **) NULL)
485     {
486       (void) ThrowMagickException(exception,GetMagickModule(),ConfigureError,
487         "MemoryAllocationFailed","`%s'",pattern);
488       return((char **) NULL);
489     }
490   qsort((void *) modules,(size_t) i,sizeof(*modules),ModuleCompare);
491   modules[i]=(char *) NULL;
492   *number_modules=(size_t) i;
493   return(modules);
494 }
495 
496 /*
497 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
498 %                                                                             %
499 %                                                                             %
500 %                                                                             %
501 %  G e t M a g i c k M o d u l e P a t h                                      %
502 %                                                                             %
503 %                                                                             %
504 %                                                                             %
505 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
506 %
507 %  GetMagickModulePath() finds a module with the specified module type and
508 %  filename.
509 %
510 %  The format of the GetMagickModulePath module is:
511 %
512 %      MagickBooleanType GetMagickModulePath(const char *filename,
513 %        MagickModuleType module_type,char *path,ExceptionInfo *exception)
514 %
515 %  A description of each parameter follows:
516 %
517 %    o filename: the module file name.
518 %
519 %    o module_type: the module type: MagickImageCoderModule or
520 %      MagickImageFilterModule.
521 %
522 %    o path: the path associated with the filename.
523 %
524 %    o exception: return any errors or warnings in this structure.
525 %
526 */
GetMagickModulePath(const char * filename,MagickModuleType module_type,char * path,ExceptionInfo * exception)527 static MagickBooleanType GetMagickModulePath(const char *filename,
528   MagickModuleType module_type,char *path,ExceptionInfo *exception)
529 {
530   char
531     *module_path;
532 
533   assert(filename != (const char *) NULL);
534   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",filename);
535   assert(path != (char *) NULL);
536   assert(exception != (ExceptionInfo *) NULL);
537   if (strchr(filename,'/') != (char *) NULL)
538     return(MagickFalse);
539   (void) CopyMagickString(path,filename,MagickPathExtent);
540   module_path=(char *) NULL;
541   switch (module_type)
542   {
543     case MagickImageCoderModule:
544     default:
545     {
546       (void) LogMagickEvent(ModuleEvent,GetMagickModule(),
547         "Searching for coder module file \"%s\" ...",filename);
548       module_path=GetEnvironmentValue("MAGICK_CODER_MODULE_PATH");
549 #if defined(MAGICKCORE_CODER_PATH)
550       if (module_path == (char *) NULL)
551         module_path=AcquireString(MAGICKCORE_CODER_PATH);
552 #endif
553       break;
554     }
555     case MagickImageFilterModule:
556     {
557       (void) LogMagickEvent(ModuleEvent,GetMagickModule(),
558         "Searching for filter module file \"%s\" ...",filename);
559       module_path=GetEnvironmentValue("MAGICK_CODER_FILTER_PATH");
560 #if defined(MAGICKCORE_FILTER_PATH)
561       if (module_path == (char *) NULL)
562         module_path=AcquireString(MAGICKCORE_FILTER_PATH);
563 #endif
564       break;
565     }
566   }
567   if (module_path != (char *) NULL)
568     {
569       register char
570         *p,
571         *q;
572 
573       for (p=module_path-1; p != (char *) NULL; )
574       {
575         (void) CopyMagickString(path,p+1,MagickPathExtent);
576         q=strchr(path,DirectoryListSeparator);
577         if (q != (char *) NULL)
578           *q='\0';
579         q=path+strlen(path)-1;
580         if ((q >= path) && (*q != *DirectorySeparator))
581           (void) ConcatenateMagickString(path,DirectorySeparator,
582             MagickPathExtent);
583         (void) ConcatenateMagickString(path,filename,MagickPathExtent);
584 #if defined(MAGICKCORE_HAVE_REALPATH)
585         {
586           char
587             resolved_path[PATH_MAX+1];
588 
589           if (realpath(path,resolved_path) != (char *) NULL)
590             (void) CopyMagickString(path,resolved_path,MagickPathExtent);
591         }
592 #endif
593         if (IsPathAccessible(path) != MagickFalse)
594           {
595             module_path=DestroyString(module_path);
596             return(MagickTrue);
597           }
598         p=strchr(p+1,DirectoryListSeparator);
599       }
600       module_path=DestroyString(module_path);
601     }
602 #if defined(MAGICKCORE_INSTALLED_SUPPORT)
603   else
604 #if defined(MAGICKCORE_CODER_PATH)
605     {
606       const char
607         *directory;
608 
609       /*
610         Search hard coded paths.
611       */
612       switch (module_type)
613       {
614         case MagickImageCoderModule:
615         default:
616         {
617           directory=MAGICKCORE_CODER_PATH;
618           break;
619         }
620         case MagickImageFilterModule:
621         {
622           directory=MAGICKCORE_FILTER_PATH;
623           break;
624         }
625       }
626       (void) FormatLocaleString(path,MagickPathExtent,"%s%s",directory,
627         filename);
628       if (IsPathAccessible(path) == MagickFalse)
629         {
630           ThrowFileException(exception,ConfigureWarning,
631             "UnableToOpenModuleFile",path);
632           return(MagickFalse);
633         }
634       return(MagickTrue);
635     }
636 #else
637 #if defined(MAGICKCORE_WINDOWS_SUPPORT)
638     {
639       const char
640         *registery_key;
641 
642       unsigned char
643         *key_value;
644 
645       /*
646         Locate path via registry key.
647       */
648       switch (module_type)
649       {
650         case MagickImageCoderModule:
651         default:
652         {
653           registery_key="CoderModulesPath";
654           break;
655         }
656         case MagickImageFilterModule:
657         {
658           registery_key="FilterModulesPath";
659           break;
660         }
661       }
662       key_value=NTRegistryKeyLookup(registery_key);
663       if (key_value == (unsigned char *) NULL)
664         {
665           ThrowMagickException(exception,GetMagickModule(),ConfigureError,
666             "RegistryKeyLookupFailed","`%s'",registery_key);
667           return(MagickFalse);
668         }
669       (void) FormatLocaleString(path,MagickPathExtent,"%s%s%s",(char *)
670         key_value,DirectorySeparator,filename);
671       key_value=(unsigned char *) RelinquishMagickMemory(key_value);
672       if (IsPathAccessible(path) == MagickFalse)
673         {
674           ThrowFileException(exception,ConfigureWarning,
675             "UnableToOpenModuleFile",path);
676           return(MagickFalse);
677         }
678       return(MagickTrue);
679     }
680 #endif
681 #endif
682 #if !defined(MAGICKCORE_CODER_PATH) && !defined(MAGICKCORE_WINDOWS_SUPPORT)
683 # error MAGICKCORE_CODER_PATH or MAGICKCORE_WINDOWS_SUPPORT must be defined when MAGICKCORE_INSTALLED_SUPPORT is defined
684 #endif
685 #else
686   {
687     char
688       *home;
689 
690     home=GetEnvironmentValue("MAGICK_HOME");
691     if (home != (char *) NULL)
692       {
693         /*
694           Search MAGICK_HOME.
695         */
696 #if !defined(MAGICKCORE_POSIX_SUPPORT)
697         (void) FormatLocaleString(path,MagickPathExtent,"%s%s%s",home,
698           DirectorySeparator,filename);
699 #else
700         const char
701           *directory;
702 
703         switch (module_type)
704         {
705           case MagickImageCoderModule:
706           default:
707           {
708             directory=MAGICKCORE_CODER_RELATIVE_PATH;
709             break;
710           }
711           case MagickImageFilterModule:
712           {
713             directory=MAGICKCORE_FILTER_RELATIVE_PATH;
714             break;
715           }
716         }
717         (void) FormatLocaleString(path,MagickPathExtent,"%s/lib/%s/%s",home,
718           directory,filename);
719 #endif
720         home=DestroyString(home);
721         if (IsPathAccessible(path) != MagickFalse)
722           return(MagickTrue);
723       }
724   }
725   if (*GetClientPath() != '\0')
726     {
727       /*
728         Search based on executable directory.
729       */
730 #if !defined(MAGICKCORE_POSIX_SUPPORT)
731       (void) FormatLocaleString(path,MagickPathExtent,"%s%s%s",GetClientPath(),
732         DirectorySeparator,filename);
733 #else
734       char
735         prefix[MagickPathExtent];
736 
737       const char
738         *directory;
739 
740       switch (module_type)
741       {
742         case MagickImageCoderModule:
743         default:
744         {
745           directory="coders";
746           break;
747         }
748         case MagickImageFilterModule:
749         {
750           directory="filters";
751           break;
752         }
753       }
754       (void) CopyMagickString(prefix,GetClientPath(),MagickPathExtent);
755       ChopPathComponents(prefix,1);
756       (void) FormatLocaleString(path,MagickPathExtent,"%s/lib/%s/%s/%s",prefix,
757         MAGICKCORE_MODULES_RELATIVE_PATH,directory,filename);
758 #endif
759       if (IsPathAccessible(path) != MagickFalse)
760         return(MagickTrue);
761     }
762 #if defined(MAGICKCORE_WINDOWS_SUPPORT)
763   {
764     /*
765       Search module path.
766     */
767     if ((NTGetModulePath("CORE_RL_MagickCore_.dll",path) != MagickFalse) ||
768         (NTGetModulePath("CORE_DB_MagickCore_.dll",path) != MagickFalse))
769       {
770         (void) ConcatenateMagickString(path,DirectorySeparator,
771           MagickPathExtent);
772         (void) ConcatenateMagickString(path,filename,MagickPathExtent);
773         if (IsPathAccessible(path) != MagickFalse)
774           return(MagickTrue);
775       }
776   }
777 #endif
778   {
779     char
780       *home;
781 
782     home=GetEnvironmentValue("XDG_CONFIG_HOME");
783     if (home == (char *) NULL)
784       home=GetEnvironmentValue("LOCALAPPDATA");
785     if (home == (char *) NULL)
786       home=GetEnvironmentValue("APPDATA");
787     if (home == (char *) NULL)
788       home=GetEnvironmentValue("USERPROFILE");
789     if (home != (char *) NULL)
790       {
791         /*
792           Search $XDG_CONFIG_HOME/ImageMagick.
793         */
794         (void) FormatLocaleString(path,MagickPathExtent,"%s%sImageMagick%s%s",
795           home,DirectorySeparator,DirectorySeparator,filename);
796         home=DestroyString(home);
797         if (IsPathAccessible(path) != MagickFalse)
798           return(MagickTrue);
799       }
800     home=GetEnvironmentValue("HOME");
801     if (home != (char *) NULL)
802       {
803         /*
804           Search $HOME/.config/ImageMagick.
805         */
806         (void) FormatLocaleString(path,MagickPathExtent,
807           "%s%s.config%sImageMagick%s%s",home,DirectorySeparator,
808           DirectorySeparator,DirectorySeparator,filename);
809         home=DestroyString(home);
810         if (IsPathAccessible(path) != MagickFalse)
811           return(MagickTrue);
812       }
813   }
814   /*
815     Search current directory.
816   */
817   if (IsPathAccessible(path) != MagickFalse)
818     return(MagickTrue);
819   if (exception->severity < ConfigureError)
820     ThrowFileException(exception,ConfigureWarning,"UnableToOpenModuleFile",
821       path);
822 #endif
823   return(MagickFalse);
824 }
825 
826 /*
827 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
828 %                                                                             %
829 %                                                                             %
830 %                                                                             %
831 %   I s M o d u l e T r e e I n s t a n t i a t e d                           %
832 %                                                                             %
833 %                                                                             %
834 %                                                                             %
835 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
836 %
837 %  IsModuleTreeInstantiated() determines if the module tree is instantiated.
838 %  If not, it instantiates the tree and returns it.
839 %
840 %  The format of the IsModuleTreeInstantiated() method is:
841 %
842 %      IsModuleTreeInstantiated()
843 %
844 */
845 
DestroyModuleNode(void * module_info)846 static void *DestroyModuleNode(void *module_info)
847 {
848   ExceptionInfo
849     *exception;
850 
851   register ModuleInfo
852     *p;
853 
854   exception=AcquireExceptionInfo();
855   p=(ModuleInfo *) module_info;
856   if (UnregisterModule(p,exception) == MagickFalse)
857     CatchException(exception);
858   if (p->tag != (char *) NULL)
859     p->tag=DestroyString(p->tag);
860   if (p->path != (char *) NULL)
861     p->path=DestroyString(p->path);
862   exception=DestroyExceptionInfo(exception);
863   return(RelinquishMagickMemory(p));
864 }
865 
IsModuleTreeInstantiated()866 static MagickBooleanType IsModuleTreeInstantiated()
867 {
868   if (module_list == (SplayTreeInfo *) NULL)
869     {
870       if (module_semaphore == (SemaphoreInfo *) NULL)
871         ActivateSemaphoreInfo(&module_semaphore);
872       LockSemaphoreInfo(module_semaphore);
873       if (module_list == (SplayTreeInfo *) NULL)
874         {
875           MagickBooleanType
876             status;
877 
878           ModuleInfo
879             *module_info;
880 
881           SplayTreeInfo
882             *splay_tree;
883 
884           splay_tree=NewSplayTree(CompareSplayTreeString,
885             (void *(*)(void *)) NULL,DestroyModuleNode);
886           module_info=AcquireModuleInfo((const char *) NULL,"[boot-strap]");
887           module_info->stealth=MagickTrue;
888           status=AddValueToSplayTree(splay_tree,module_info->tag,module_info);
889           if (status == MagickFalse)
890             ThrowFatalException(ResourceLimitFatalError,
891               "MemoryAllocationFailed");
892           if (lt_dlinit() != 0)
893             ThrowFatalException(ModuleFatalError,
894               "UnableToInitializeModuleLoader");
895           module_list=splay_tree;
896         }
897       UnlockSemaphoreInfo(module_semaphore);
898     }
899   return(module_list != (SplayTreeInfo *) NULL ? MagickTrue : MagickFalse);
900 }
901 
902 /*
903 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
904 %                                                                             %
905 %                                                                             %
906 %                                                                             %
907 %   I n v o k e D y n a m i c I m a g e F i l t e r                           %
908 %                                                                             %
909 %                                                                             %
910 %                                                                             %
911 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
912 %
913 %  InvokeDynamicImageFilter() invokes a dynamic image filter.
914 %
915 %  The format of the InvokeDynamicImageFilter module is:
916 %
917 %      MagickBooleanType InvokeDynamicImageFilter(const char *tag,Image **image,
918 %        const int argc,const char **argv,ExceptionInfo *exception)
919 %
920 %  A description of each parameter follows:
921 %
922 %    o tag: a character string that represents the name of the particular
923 %      module.
924 %
925 %    o image: the image.
926 %
927 %    o argc: a pointer to an integer describing the number of elements in the
928 %      argument vector.
929 %
930 %    o argv: a pointer to a text array containing the command line arguments.
931 %
932 %    o exception: return any errors or warnings in this structure.
933 %
934 */
InvokeDynamicImageFilter(const char * tag,Image ** images,const int argc,const char ** argv,ExceptionInfo * exception)935 MagickExport MagickBooleanType InvokeDynamicImageFilter(const char *tag,
936   Image **images,const int argc,const char **argv,ExceptionInfo *exception)
937 {
938   char
939     name[MagickPathExtent],
940     path[MagickPathExtent];
941 
942   ImageFilterHandler
943     *image_filter;
944 
945   MagickBooleanType
946     status;
947 
948   ModuleHandle
949     handle;
950 
951   PolicyRights
952     rights;
953 
954   /*
955     Find the module.
956   */
957   assert(images != (Image **) NULL);
958   assert((*images)->signature == MagickCoreSignature);
959   if ((*images)->debug != MagickFalse)
960     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",
961       (*images)->filename);
962   rights=ReadPolicyRights;
963   if (IsRightsAuthorized(FilterPolicyDomain,rights,tag) == MagickFalse)
964     {
965       errno=EPERM;
966       (void) ThrowMagickException(exception,GetMagickModule(),PolicyError,
967         "NotAuthorized","`%s'",tag);
968       return(MagickFalse);
969     }
970 #if !defined(MAGICKCORE_BUILD_MODULES)
971   {
972     MagickBooleanType
973       status;
974 
975     status=InvokeStaticImageFilter(tag,images,argc,argv,exception);
976     if (status != MagickFalse)
977       return(status);
978   }
979 #endif
980   TagToFilterModuleName(tag,name);
981   status=GetMagickModulePath(name,MagickImageFilterModule,path,exception);
982   if (status == MagickFalse)
983     {
984       (void) ThrowMagickException(exception,GetMagickModule(),ModuleError,
985         "UnableToLoadModule","'%s': %s",name,path);
986       return(MagickFalse);
987     }
988   /*
989     Open the module.
990   */
991   handle=(ModuleHandle) lt_dlopen(path);
992   if (handle == (ModuleHandle) NULL)
993     {
994       (void) ThrowMagickException(exception,GetMagickModule(),ModuleError,
995         "UnableToLoadModule","'%s': %s",name,lt_dlerror());
996       return(MagickFalse);
997     }
998   /*
999     Locate the module.
1000   */
1001 #if !defined(MAGICKCORE_NAMESPACE_PREFIX)
1002   (void) FormatLocaleString(name,MagickPathExtent,"%sImage",tag);
1003 #else
1004   (void) FormatLocaleString(name,MagickPathExtent,"%s%sImage",
1005     MAGICKCORE_NAMESPACE_PREFIX_TAG,tag);
1006 #endif
1007   /*
1008     Execute the module.
1009   */
1010   ClearMagickException(exception);
1011   image_filter=(ImageFilterHandler *) lt_dlsym(handle,name);
1012   if (image_filter == (ImageFilterHandler *) NULL)
1013     (void) ThrowMagickException(exception,GetMagickModule(),ModuleError,
1014       "UnableToLoadModule","'%s': %s",name,lt_dlerror());
1015   else
1016     {
1017       size_t
1018         signature;
1019 
1020       if ((*images)->debug != MagickFalse)
1021         (void) LogMagickEvent(ModuleEvent,GetMagickModule(),
1022           "Invoking \"%s\" dynamic image filter",tag);
1023       signature=image_filter(images,argc,argv,exception);
1024       if ((*images)->debug != MagickFalse)
1025         (void) LogMagickEvent(ModuleEvent,GetMagickModule(),"\"%s\" completes",
1026           tag);
1027       if (signature != MagickImageFilterSignature)
1028         (void) ThrowMagickException(exception,GetMagickModule(),ModuleError,
1029           "ImageFilterSignatureMismatch","'%s': %8lx != %8lx",tag,
1030           (unsigned long) signature,(unsigned long) MagickImageFilterSignature);
1031     }
1032   /*
1033     Close the module.
1034   */
1035   if (lt_dlclose(handle) != 0)
1036     (void) ThrowMagickException(exception,GetMagickModule(),ModuleWarning,
1037       "UnableToCloseModule","'%s': %s",name,lt_dlerror());
1038   return(exception->severity < ErrorException ? MagickTrue : MagickFalse);
1039 }
1040 
1041 /*
1042 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1043 %                                                                             %
1044 %                                                                             %
1045 %                                                                             %
1046 %  L i s t M o d u l e I n f o                                                %
1047 %                                                                             %
1048 %                                                                             %
1049 %                                                                             %
1050 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1051 %
1052 %  ListModuleInfo() lists the module info to a file.
1053 %
1054 %  The format of the ListModuleInfo module is:
1055 %
1056 %      MagickBooleanType ListModuleInfo(FILE *file,ExceptionInfo *exception)
1057 %
1058 %  A description of each parameter follows.
1059 %
1060 %    o file:  An pointer to a FILE.
1061 %
1062 %    o exception: return any errors or warnings in this structure.
1063 %
1064 */
ListModuleInfo(FILE * file,ExceptionInfo * exception)1065 MagickExport MagickBooleanType ListModuleInfo(FILE *file,
1066   ExceptionInfo *exception)
1067 {
1068   char
1069     filename[MagickPathExtent],
1070     module_path[MagickPathExtent],
1071     **modules,
1072     path[MagickPathExtent];
1073 
1074   register ssize_t
1075     i;
1076 
1077   size_t
1078     number_modules;
1079 
1080   if (file == (const FILE *) NULL)
1081     file=stdout;
1082   /*
1083     List image coders.
1084   */
1085   modules=GetModuleList("*",MagickImageCoderModule,&number_modules,exception);
1086   if (modules == (char **) NULL)
1087     return(MagickFalse);
1088   TagToCoderModuleName("magick",filename);
1089   (void) GetMagickModulePath(filename,MagickImageCoderModule,module_path,
1090     exception);
1091   GetPathComponent(module_path,HeadPath,path);
1092   (void) FormatLocaleFile(file,"\nPath: %s\n\n",path);
1093   (void) FormatLocaleFile(file,"Image Coder\n");
1094   (void) FormatLocaleFile(file,
1095     "-------------------------------------------------"
1096     "------------------------------\n");
1097   for (i=0; i < (ssize_t) number_modules; i++)
1098   {
1099     (void) FormatLocaleFile(file,"%s",modules[i]);
1100     (void) FormatLocaleFile(file,"\n");
1101   }
1102   (void) fflush(file);
1103   /*
1104     Relinquish resources.
1105   */
1106   for (i=0; i < (ssize_t) number_modules; i++)
1107     modules[i]=DestroyString(modules[i]);
1108   modules=(char **) RelinquishMagickMemory(modules);
1109   /*
1110     List image filters.
1111   */
1112   modules=GetModuleList("*",MagickImageFilterModule,&number_modules,exception);
1113   if (modules == (char **) NULL)
1114     return(MagickFalse);
1115   TagToFilterModuleName("analyze",filename);
1116   (void) GetMagickModulePath(filename,MagickImageFilterModule,module_path,
1117     exception);
1118   GetPathComponent(module_path,HeadPath,path);
1119   (void) FormatLocaleFile(file,"\nPath: %s\n\n",path);
1120   (void) FormatLocaleFile(file,"Image Filter\n");
1121   (void) FormatLocaleFile(file,
1122     "-------------------------------------------------"
1123     "------------------------------\n");
1124   for (i=0; i < (ssize_t) number_modules; i++)
1125   {
1126     (void) FormatLocaleFile(file,"%s",modules[i]);
1127     (void) FormatLocaleFile(file,"\n");
1128   }
1129   (void) fflush(file);
1130   /*
1131     Relinquish resources.
1132   */
1133   for (i=0; i < (ssize_t) number_modules; i++)
1134     modules[i]=DestroyString(modules[i]);
1135   modules=(char **) RelinquishMagickMemory(modules);
1136   return(MagickTrue);
1137 }
1138 
1139 /*
1140 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1141 %                                                                             %
1142 %                                                                             %
1143 %                                                                             %
1144 +   M o d u l e C o m p o n e n t G e n e s i s                               %
1145 %                                                                             %
1146 %                                                                             %
1147 %                                                                             %
1148 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1149 %
1150 %  ModuleComponentGenesis() instantiates the module component.
1151 %
1152 %  The format of the ModuleComponentGenesis method is:
1153 %
1154 %      MagickBooleanType ModuleComponentGenesis(void)
1155 %
1156 */
ModuleComponentGenesis(void)1157 MagickPrivate MagickBooleanType ModuleComponentGenesis(void)
1158 {
1159   MagickBooleanType
1160     status;
1161 
1162   if (module_semaphore == (SemaphoreInfo *) NULL)
1163     module_semaphore=AcquireSemaphoreInfo();
1164   status=IsModuleTreeInstantiated();
1165   return(status);
1166 }
1167 
1168 /*
1169 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1170 %                                                                             %
1171 %                                                                             %
1172 %                                                                             %
1173 +   M o d u l e C o m p o n e n t T e r m i n u s                             %
1174 %                                                                             %
1175 %                                                                             %
1176 %                                                                             %
1177 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1178 %
1179 %  ModuleComponentTerminus() destroys the module component.
1180 %
1181 %  The format of the ModuleComponentTerminus method is:
1182 %
1183 %      ModuleComponentTerminus(void)
1184 %
1185 */
ModuleComponentTerminus(void)1186 MagickPrivate void ModuleComponentTerminus(void)
1187 {
1188   if (module_semaphore == (SemaphoreInfo *) NULL)
1189     ActivateSemaphoreInfo(&module_semaphore);
1190   DestroyModuleList();
1191   RelinquishSemaphoreInfo(&module_semaphore);
1192 }
1193 
1194 /*
1195 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1196 %                                                                             %
1197 %                                                                             %
1198 %                                                                             %
1199 %   O p e n M o d u l e                                                       %
1200 %                                                                             %
1201 %                                                                             %
1202 %                                                                             %
1203 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1204 %
1205 %  OpenModule() loads a module, and invokes its registration module.  It
1206 %  returns MagickTrue on success, and MagickFalse if there is an error.
1207 %
1208 %  The format of the OpenModule module is:
1209 %
1210 %      MagickBooleanType OpenModule(const char *module,ExceptionInfo *exception)
1211 %
1212 %  A description of each parameter follows:
1213 %
1214 %    o module: a character string that indicates the module to load.
1215 %
1216 %    o exception: return any errors or warnings in this structure.
1217 %
1218 */
OpenModule(const char * module,ExceptionInfo * exception)1219 MagickPrivate MagickBooleanType OpenModule(const char *module,
1220   ExceptionInfo *exception)
1221 {
1222   char
1223     filename[MagickPathExtent],
1224     module_name[MagickPathExtent],
1225     name[MagickPathExtent],
1226     path[MagickPathExtent];
1227 
1228   MagickBooleanType
1229     status;
1230 
1231   ModuleHandle
1232     handle;
1233 
1234   ModuleInfo
1235     *module_info;
1236 
1237   PolicyRights
1238     rights;
1239 
1240   register const CoderInfo
1241     *p;
1242 
1243   size_t
1244     signature;
1245 
1246   /*
1247     Assign module name from alias.
1248   */
1249   assert(module != (const char *) NULL);
1250   module_info=(ModuleInfo *) GetModuleInfo(module,exception);
1251   if (module_info != (ModuleInfo *) NULL)
1252     return(MagickTrue);
1253   rights=ReadPolicyRights;
1254   if (IsRightsAuthorized(ModulePolicyDomain,rights,module) == MagickFalse)
1255     {
1256       errno=EPERM;
1257       (void) ThrowMagickException(exception,GetMagickModule(),PolicyError,
1258         "NotAuthorized","`%s'",module);
1259       return(MagickFalse);
1260     }
1261   (void) CopyMagickString(module_name,module,MagickPathExtent);
1262   p=GetCoderInfo(module,exception);
1263   if (p != (CoderInfo *) NULL)
1264     (void) CopyMagickString(module_name,p->name,MagickPathExtent);
1265   if (GetValueFromSplayTree(module_list,module_name) != (void *) NULL)
1266     return(MagickTrue);  /* module already opened, return */
1267   /*
1268     Locate module.
1269   */
1270   handle=(ModuleHandle) NULL;
1271   TagToCoderModuleName(module_name,filename);
1272   (void) LogMagickEvent(ModuleEvent,GetMagickModule(),
1273     "Searching for module \"%s\" using filename \"%s\"",module_name,filename);
1274   *path='\0';
1275   status=GetMagickModulePath(filename,MagickImageCoderModule,path,exception);
1276   if (status == MagickFalse)
1277     return(MagickFalse);
1278   /*
1279     Load module
1280   */
1281   (void) LogMagickEvent(ModuleEvent,GetMagickModule(),
1282     "Opening module at path \"%s\"",path);
1283   handle=(ModuleHandle) lt_dlopen(path);
1284   if (handle == (ModuleHandle) NULL)
1285     {
1286       (void) ThrowMagickException(exception,GetMagickModule(),ModuleError,
1287         "UnableToLoadModule","'%s': %s",path,lt_dlerror());
1288       return(MagickFalse);
1289     }
1290   /*
1291     Register module.
1292   */
1293   module_info=AcquireModuleInfo(path,module_name);
1294   module_info->handle=handle;
1295   if (RegisterModule(module_info,exception) == (ModuleInfo *) NULL)
1296     return(MagickFalse);
1297   /*
1298     Define RegisterFORMATImage method.
1299   */
1300   TagToModuleName(module_name,"Register%sImage",name);
1301   module_info->register_module=(size_t (*)(void)) lt_dlsym(handle,name);
1302   if (module_info->register_module == (size_t (*)(void)) NULL)
1303     {
1304       (void) ThrowMagickException(exception,GetMagickModule(),ModuleError,
1305         "UnableToRegisterImageFormat","'%s': %s",module_name,lt_dlerror());
1306       return(MagickFalse);
1307     }
1308   (void) LogMagickEvent(ModuleEvent,GetMagickModule(),
1309     "Method \"%s\" in module \"%s\" at address %p",name,module_name,
1310     (void *) module_info->register_module);
1311   /*
1312     Define UnregisterFORMATImage method.
1313   */
1314   TagToModuleName(module_name,"Unregister%sImage",name);
1315   module_info->unregister_module=(void (*)(void)) lt_dlsym(handle,name);
1316   if (module_info->unregister_module == (void (*)(void)) NULL)
1317     {
1318       (void) ThrowMagickException(exception,GetMagickModule(),ModuleError,
1319         "UnableToRegisterImageFormat","'%s': %s",module_name,lt_dlerror());
1320       return(MagickFalse);
1321     }
1322   (void) LogMagickEvent(ModuleEvent,GetMagickModule(),
1323     "Method \"%s\" in module \"%s\" at address %p",name,module_name,
1324     (void *) module_info->unregister_module);
1325   signature=module_info->register_module();
1326   if (signature != MagickImageCoderSignature)
1327     {
1328       (void) ThrowMagickException(exception,GetMagickModule(),ModuleError,
1329         "ImageCoderSignatureMismatch","'%s': %8lx != %8lx",module_name,
1330         (unsigned long) signature,(unsigned long) MagickImageCoderSignature);
1331       return(MagickFalse);
1332     }
1333   return(MagickTrue);
1334 }
1335 
1336 /*
1337 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1338 %                                                                             %
1339 %                                                                             %
1340 %                                                                             %
1341 %   O p e n M o d u l e s                                                     %
1342 %                                                                             %
1343 %                                                                             %
1344 %                                                                             %
1345 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1346 %
1347 %  OpenModules() loads all available modules.
1348 %
1349 %  The format of the OpenModules module is:
1350 %
1351 %      MagickBooleanType OpenModules(ExceptionInfo *exception)
1352 %
1353 %  A description of each parameter follows:
1354 %
1355 %    o exception: return any errors or warnings in this structure.
1356 %
1357 */
OpenModules(ExceptionInfo * exception)1358 MagickPrivate MagickBooleanType OpenModules(ExceptionInfo *exception)
1359 {
1360   char
1361     **modules;
1362 
1363   register ssize_t
1364     i;
1365 
1366   size_t
1367     number_modules;
1368 
1369   /*
1370     Load all modules.
1371   */
1372   (void) GetMagickInfo((char *) NULL,exception);
1373   number_modules=0;
1374   modules=GetModuleList("*",MagickImageCoderModule,&number_modules,exception);
1375   if ((modules == (char **) NULL) || (*modules == (char *) NULL))
1376     {
1377       if (modules != (char **) NULL)
1378         modules=(char **) RelinquishMagickMemory(modules);
1379       return(MagickFalse);
1380     }
1381   for (i=0; i < (ssize_t) number_modules; i++)
1382     (void) OpenModule(modules[i],exception);
1383   /*
1384     Relinquish resources.
1385   */
1386   for (i=0; i < (ssize_t) number_modules; i++)
1387     modules[i]=DestroyString(modules[i]);
1388   modules=(char **) RelinquishMagickMemory(modules);
1389   return(MagickTrue);
1390 }
1391 
1392 /*
1393 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1394 %                                                                             %
1395 %                                                                             %
1396 %                                                                             %
1397 %   R e g i s t e r M o d u l e                                               %
1398 %                                                                             %
1399 %                                                                             %
1400 %                                                                             %
1401 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1402 %
1403 %  RegisterModule() adds an entry to the module list.  It returns a pointer to
1404 %  the registered entry on success.
1405 %
1406 %  The format of the RegisterModule module is:
1407 %
1408 %      ModuleInfo *RegisterModule(const ModuleInfo *module_info,
1409 %        ExceptionInfo *exception)
1410 %
1411 %  A description of each parameter follows:
1412 %
1413 %    o info: a pointer to the registered entry is returned.
1414 %
1415 %    o module_info: a pointer to the ModuleInfo structure to register.
1416 %
1417 %    o exception: return any errors or warnings in this structure.
1418 %
1419 */
RegisterModule(const ModuleInfo * module_info,ExceptionInfo * exception)1420 static const ModuleInfo *RegisterModule(const ModuleInfo *module_info,
1421   ExceptionInfo *exception)
1422 {
1423   MagickBooleanType
1424     status;
1425 
1426   assert(module_info != (ModuleInfo *) NULL);
1427   assert(module_info->signature == MagickCoreSignature);
1428   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",module_info->tag);
1429   if (module_list == (SplayTreeInfo *) NULL)
1430     return((const ModuleInfo *) NULL);
1431   status=AddValueToSplayTree(module_list,module_info->tag,module_info);
1432   if (status == MagickFalse)
1433     (void) ThrowMagickException(exception,GetMagickModule(),ResourceLimitError,
1434       "MemoryAllocationFailed","`%s'",module_info->tag);
1435   return(module_info);
1436 }
1437 
1438 /*
1439 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1440 %                                                                             %
1441 %                                                                             %
1442 %                                                                             %
1443 %  T a g T o C o d e r M o d u l e N a m e                                    %
1444 %                                                                             %
1445 %                                                                             %
1446 %                                                                             %
1447 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1448 %
1449 %  TagToCoderModuleName() munges a module tag and obtains the filename of the
1450 %  corresponding module.
1451 %
1452 %  The format of the TagToCoderModuleName module is:
1453 %
1454 %      char *TagToCoderModuleName(const char *tag,char *name)
1455 %
1456 %  A description of each parameter follows:
1457 %
1458 %    o tag: a character string representing the module tag.
1459 %
1460 %    o name: return the module name here.
1461 %
1462 */
TagToCoderModuleName(const char * tag,char * name)1463 static void TagToCoderModuleName(const char *tag,char *name)
1464 {
1465   assert(tag != (char *) NULL);
1466   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",tag);
1467   assert(name != (char *) NULL);
1468 #if defined(MAGICKCORE_LTDL_DELEGATE)
1469   (void) FormatLocaleString(name,MagickPathExtent,"%s.la",tag);
1470   (void) LocaleLower(name);
1471 #else
1472 #if defined(MAGICKCORE_WINDOWS_SUPPORT)
1473   if (LocaleNCompare("IM_MOD_",tag,7) == 0)
1474     (void) CopyMagickString(name,tag,MagickPathExtent);
1475   else
1476     {
1477 #if defined(_DEBUG)
1478       (void) FormatLocaleString(name,MagickPathExtent,"IM_MOD_DB_%s_.dll",tag);
1479 #else
1480       (void) FormatLocaleString(name,MagickPathExtent,"IM_MOD_RL_%s_.dll",tag);
1481 #endif
1482     }
1483 #endif
1484 #endif
1485 }
1486 
1487 /*
1488 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1489 %                                                                             %
1490 %                                                                             %
1491 %                                                                             %
1492 %  T a g T o F i l t e r M o d u l e N a m e                                  %
1493 %                                                                             %
1494 %                                                                             %
1495 %                                                                             %
1496 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1497 %
1498 %  TagToFilterModuleName() munges a module tag and returns the filename of the
1499 %  corresponding filter module.
1500 %
1501 %  The format of the TagToFilterModuleName module is:
1502 %
1503 %      void TagToFilterModuleName(const char *tag,char name)
1504 %
1505 %  A description of each parameter follows:
1506 %
1507 %    o tag: a character string representing the module tag.
1508 %
1509 %    o name: return the filter name here.
1510 %
1511 */
TagToFilterModuleName(const char * tag,char * name)1512 static void TagToFilterModuleName(const char *tag,char *name)
1513 {
1514   assert(tag != (char *) NULL);
1515   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",tag);
1516   assert(name != (char *) NULL);
1517 #if defined(MAGICKCORE_WINDOWS_SUPPORT)
1518   (void) FormatLocaleString(name,MagickPathExtent,"FILTER_%s_.dll",tag);
1519 #elif !defined(MAGICKCORE_LTDL_DELEGATE)
1520   (void) FormatLocaleString(name,MagickPathExtent,"%s.dll",tag);
1521 #else
1522   (void) FormatLocaleString(name,MagickPathExtent,"%s.la",tag);
1523 #endif
1524 }
1525 
1526 /*
1527 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1528 %                                                                             %
1529 %                                                                             %
1530 %                                                                             %
1531 %   T a g T o M o d u l e N a m e                                             %
1532 %                                                                             %
1533 %                                                                             %
1534 %                                                                             %
1535 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1536 %
1537 %  TagToModuleName() munges the module tag name and returns an upper-case tag
1538 %  name as the input string, and a user-provided format.
1539 %
1540 %  The format of the TagToModuleName module is:
1541 %
1542 %      TagToModuleName(const char *tag,const char *format,char *module)
1543 %
1544 %  A description of each parameter follows:
1545 %
1546 %    o tag: the module tag.
1547 %
1548 %    o format: a sprintf-compatible format string containing %s where the
1549 %      upper-case tag name is to be inserted.
1550 %
1551 %    o module: pointer to a destination buffer for the formatted result.
1552 %
1553 */
TagToModuleName(const char * tag,const char * format,char * module)1554 static void TagToModuleName(const char *tag,const char *format,char *module)
1555 {
1556   char
1557     name[MagickPathExtent];
1558 
1559   assert(tag != (const char *) NULL);
1560   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",tag);
1561   assert(format != (const char *) NULL);
1562   assert(module != (char *) NULL);
1563   (void) CopyMagickString(name,tag,MagickPathExtent);
1564   LocaleUpper(name);
1565 #if !defined(MAGICKCORE_NAMESPACE_PREFIX)
1566   (void) FormatLocaleString(module,MagickPathExtent,format,name);
1567 #else
1568   {
1569     char
1570       prefix_format[MagickPathExtent];
1571 
1572     (void) FormatLocaleString(prefix_format,MagickPathExtent,"%s%s",
1573       MAGICKCORE_NAMESPACE_PREFIX_TAG,format);
1574     (void) FormatLocaleString(module,MagickPathExtent,prefix_format,name);
1575   }
1576 #endif
1577 }
1578 
1579 /*
1580 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1581 %                                                                             %
1582 %                                                                             %
1583 %                                                                             %
1584 %   U n r e g i s t e r M o d u l e                                           %
1585 %                                                                             %
1586 %                                                                             %
1587 %                                                                             %
1588 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1589 %
1590 %  UnregisterModule() unloads a module, and invokes its de-registration module.
1591 %  Returns MagickTrue on success, and MagickFalse if there is an error.
1592 %
1593 %  The format of the UnregisterModule module is:
1594 %
1595 %      MagickBooleanType UnregisterModule(const ModuleInfo *module_info,
1596 %        ExceptionInfo *exception)
1597 %
1598 %  A description of each parameter follows:
1599 %
1600 %    o module_info: the module info.
1601 %
1602 %    o exception: return any errors or warnings in this structure.
1603 %
1604 */
UnregisterModule(const ModuleInfo * module_info,ExceptionInfo * exception)1605 static MagickBooleanType UnregisterModule(const ModuleInfo *module_info,
1606   ExceptionInfo *exception)
1607 {
1608   /*
1609     Locate and execute UnregisterFORMATImage module.
1610   */
1611   assert(module_info != (const ModuleInfo *) NULL);
1612   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",module_info->tag);
1613   assert(exception != (ExceptionInfo *) NULL);
1614   if (module_info->unregister_module == NULL)
1615     return(MagickTrue);
1616   module_info->unregister_module();
1617   if (lt_dlclose((ModuleHandle) module_info->handle) != 0)
1618     {
1619       (void) ThrowMagickException(exception,GetMagickModule(),ModuleWarning,
1620         "UnableToCloseModule","'%s': %s",module_info->tag,lt_dlerror());
1621       return(MagickFalse);
1622     }
1623   return(MagickTrue);
1624 }
1625 #else
1626 
1627 #if !defined(MAGICKCORE_BUILD_MODULES)
1628 extern size_t
1629   analyzeImage(Image **,const int,const char **,ExceptionInfo *);
1630 #endif
1631 
ListModuleInfo(FILE * magick_unused (file),ExceptionInfo * magick_unused (exception))1632 MagickExport MagickBooleanType ListModuleInfo(FILE *magick_unused(file),
1633   ExceptionInfo *magick_unused(exception))
1634 {
1635   return(MagickTrue);
1636 }
1637 
InvokeDynamicImageFilter(const char * tag,Image ** image,const int argc,const char ** argv,ExceptionInfo * exception)1638 MagickExport MagickBooleanType InvokeDynamicImageFilter(const char *tag,
1639   Image **image,const int argc,const char **argv,ExceptionInfo *exception)
1640 {
1641   PolicyRights
1642     rights;
1643 
1644   assert(image != (Image **) NULL);
1645   assert((*image)->signature == MagickCoreSignature);
1646   if ((*image)->debug != MagickFalse)
1647     (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",(*image)->filename);
1648   rights=ReadPolicyRights;
1649   if (IsRightsAuthorized(FilterPolicyDomain,rights,tag) == MagickFalse)
1650     {
1651       errno=EPERM;
1652       (void) ThrowMagickException(exception,GetMagickModule(),PolicyError,
1653         "NotAuthorized","`%s'",tag);
1654       return(MagickFalse);
1655     }
1656 #if defined(MAGICKCORE_BUILD_MODULES)
1657   (void) tag;
1658   (void) argc;
1659   (void) argv;
1660   (void) exception;
1661 #else
1662   {
1663     ImageFilterHandler
1664       *image_filter;
1665 
1666     image_filter=(ImageFilterHandler *) NULL;
1667     if (LocaleCompare("analyze",tag) == 0)
1668       image_filter=(ImageFilterHandler *) analyzeImage;
1669     if (image_filter == (ImageFilterHandler *) NULL)
1670       (void) ThrowMagickException(exception,GetMagickModule(),ModuleError,
1671         "UnableToLoadModule","`%s'",tag);
1672     else
1673       {
1674         size_t
1675           signature;
1676 
1677         if ((*image)->debug != MagickFalse)
1678           (void) LogMagickEvent(CoderEvent,GetMagickModule(),
1679             "Invoking \"%s\" static image filter",tag);
1680         signature=image_filter(image,argc,argv,exception);
1681         if ((*image)->debug != MagickFalse)
1682           (void) LogMagickEvent(CoderEvent,GetMagickModule(),"\"%s\" completes",
1683             tag);
1684         if (signature != MagickImageFilterSignature)
1685           {
1686             (void) ThrowMagickException(exception,GetMagickModule(),ModuleError,
1687               "ImageFilterSignatureMismatch","'%s': %8lx != %8lx",tag,
1688               (unsigned long) signature,(unsigned long)
1689               MagickImageFilterSignature);
1690             return(MagickFalse);
1691           }
1692       }
1693   }
1694 #endif
1695   return(MagickTrue);
1696 }
1697 #endif
1698