1 /*
2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3 % %
4 % %
5 % %
6 % N N TTTTT %
7 % NN N T %
8 % N N N T %
9 % N NN T %
10 % N N T %
11 % %
12 % %
13 % Windows NT Utility Methods for MagickCore %
14 % %
15 % Software Design %
16 % Cristy %
17 % December 1996 %
18 % %
19 % %
20 % Copyright 1999-2020 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 Include declarations.
40 */
41 #include "MagickCore/studio.h"
42 #if defined(MAGICKCORE_WINDOWS_SUPPORT)
43 #include "MagickCore/client.h"
44 #include "MagickCore/exception-private.h"
45 #include "MagickCore/locale_.h"
46 #include "MagickCore/log.h"
47 #include "MagickCore/magick.h"
48 #include "MagickCore/memory_.h"
49 #include "MagickCore/memory-private.h"
50 #include "MagickCore/nt-base.h"
51 #include "MagickCore/nt-base-private.h"
52 #include "MagickCore/resource_.h"
53 #include "MagickCore/resource-private.h"
54 #include "MagickCore/timer.h"
55 #include "MagickCore/string_.h"
56 #include "MagickCore/string-private.h"
57 #include "MagickCore/utility.h"
58 #include "MagickCore/utility-private.h"
59 #include "MagickCore/version.h"
60 #if defined(MAGICKCORE_LTDL_DELEGATE)
61 # include "ltdl.h"
62 #endif
63 #if defined(MAGICKCORE_CIPHER_SUPPORT)
64 #include <ntsecapi.h>
65 #include <wincrypt.h>
66 #endif
67
68 /*
69 Define declarations.
70 */
71 #if !defined(MAP_FAILED)
72 #define MAP_FAILED ((void *)(LONG_PTR)-1)
73 #endif
74
75 /*
76 Typdef declarations.
77 */
78
79 /*
80 We need to make sure only one instance is created for each process and that
81 is why we wrap the new/delete instance methods.
82
83 From: http://www.ghostscript.com/doc/current/API.htm
84 "The Win32 DLL gsdll32.dll can be used by multiple programs simultaneously,
85 but only once within each process"
86 */
87 typedef struct _NTGhostInfo
88 {
89 void
90 (MagickDLLCall *delete_instance)(gs_main_instance *);
91
92 int
93 (MagickDLLCall *new_instance)(gs_main_instance **,void *);
94
95 MagickBooleanType
96 has_instance;
97 } NTGhostInfo;
98
99 /*
100 Static declarations.
101 */
102 #if !defined(MAGICKCORE_LTDL_DELEGATE)
103 static char
104 *lt_slsearchpath = (char *) NULL;
105 #endif
106
107 static NTGhostInfo
108 nt_ghost_info;
109
110 static GhostInfo
111 ghost_info;
112
113 static void
114 *ghost_handle = (void *) NULL;
115
116 static SemaphoreInfo
117 *ghost_semaphore = (SemaphoreInfo *) NULL,
118 *winsock_semaphore = (SemaphoreInfo *) NULL;
119
120 static WSADATA
121 *wsaData = (WSADATA*) NULL;
122
123 static size_t
124 long_paths_enabled = 2;
125
126 struct
127 {
128 const HKEY
129 hkey;
130
131 const char
132 *name;
133 }
134 const registry_roots[2] =
135 {
136 { HKEY_CURRENT_USER, "HKEY_CURRENT_USER" },
137 { HKEY_LOCAL_MACHINE, "HKEY_LOCAL_MACHINE" }
138 };
139
140 /*
141 External declarations.
142 */
143 #if !defined(MAGICKCORE_WINDOWS_SUPPORT)
144 extern "C" BOOL WINAPI
145 DllMain(HINSTANCE handle,DWORD reason,LPVOID lpvReserved);
146 #endif
147
NTGhostscriptDeleteInstance(gs_main_instance * instance)148 static void MagickDLLCall NTGhostscriptDeleteInstance(
149 gs_main_instance *instance)
150 {
151 LockSemaphoreInfo(ghost_semaphore);
152 nt_ghost_info.delete_instance(instance);
153 nt_ghost_info.has_instance=MagickFalse;
154 UnlockSemaphoreInfo(ghost_semaphore);
155 }
156
NTGhostscriptNewInstance(gs_main_instance ** pinstance,void * caller_handle)157 static int MagickDLLCall NTGhostscriptNewInstance(gs_main_instance **pinstance,
158 void *caller_handle)
159 {
160 int
161 status;
162
163 LockSemaphoreInfo(ghost_semaphore);
164 status=-1;
165 if (nt_ghost_info.has_instance == MagickFalse)
166 {
167 status=nt_ghost_info.new_instance(pinstance,caller_handle);
168 if (status >= 0)
169 nt_ghost_info.has_instance=MagickTrue;
170 }
171 UnlockSemaphoreInfo(ghost_semaphore);
172 return(status);
173 }
174
create_utf8_string(const wchar_t * wideChar)175 static inline char *create_utf8_string(const wchar_t *wideChar)
176 {
177 char
178 *utf8;
179
180 int
181 count;
182
183 count=WideCharToMultiByte(CP_UTF8,0,wideChar,-1,NULL,0,NULL,NULL);
184 if (count < 0)
185 return((char *) NULL);
186 utf8=(char *) AcquireQuantumMemory(count+1,sizeof(*utf8));
187 if (utf8 == (char *) NULL)
188 return((char *) NULL);
189 count=WideCharToMultiByte(CP_UTF8,0,wideChar,-1,utf8,count,NULL,NULL);
190 if (count == 0)
191 {
192 utf8=DestroyString(utf8);
193 return((char *) NULL);
194 }
195 utf8[count]=0;
196 return(utf8);
197 }
198
199 /*
200 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
201 % %
202 % %
203 % %
204 % D l l M a i n %
205 % %
206 % %
207 % %
208 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
209 %
210 % DllMain() is an entry point to the DLL which is called when processes and
211 % threads are initialized and terminated, or upon calls to the Windows
212 % LoadLibrary and FreeLibrary functions.
213 %
214 % The function returns TRUE of it succeeds, or FALSE if initialization fails.
215 %
216 % The format of the DllMain method is:
217 %
218 % BOOL WINAPI DllMain(HINSTANCE handle,DWORD reason,LPVOID lpvReserved)
219 %
220 % A description of each parameter follows:
221 %
222 % o handle: handle to the DLL module
223 %
224 % o reason: reason for calling function:
225 %
226 % DLL_PROCESS_ATTACH - DLL is being loaded into virtual address
227 % space of current process.
228 % DLL_THREAD_ATTACH - Indicates that the current process is
229 % creating a new thread. Called under the
230 % context of the new thread.
231 % DLL_THREAD_DETACH - Indicates that the thread is exiting.
232 % Called under the context of the exiting
233 % thread.
234 % DLL_PROCESS_DETACH - Indicates that the DLL is being unloaded
235 % from the virtual address space of the
236 % current process.
237 %
238 % o lpvReserved: Used for passing additional info during DLL_PROCESS_ATTACH
239 % and DLL_PROCESS_DETACH.
240 %
241 */
242 #if defined(_DLL) && defined(ProvideDllMain)
DllMain(HINSTANCE handle,DWORD reason,LPVOID lpvReserved)243 BOOL WINAPI DllMain(HINSTANCE handle,DWORD reason,LPVOID lpvReserved)
244 {
245 switch (reason)
246 {
247 case DLL_PROCESS_ATTACH:
248 {
249 char
250 *module_path;
251
252 ssize_t
253 count;
254
255 wchar_t
256 *wide_path;
257
258 MagickCoreGenesis((const char *) NULL,MagickFalse);
259 wide_path=(wchar_t *) AcquireQuantumMemory(MagickPathExtent,
260 sizeof(*wide_path));
261 if (wide_path == (wchar_t *) NULL)
262 return(FALSE);
263 count=(ssize_t) GetModuleFileNameW(handle,wide_path,MagickPathExtent);
264 if (count != 0)
265 {
266 char
267 *path;
268
269 module_path=create_utf8_string(wide_path);
270 for ( ; count > 0; count--)
271 if (module_path[count] == '\\')
272 {
273 module_path[count+1]='\0';
274 break;
275 }
276 path=(char *) AcquireQuantumMemory(16UL*MagickPathExtent,sizeof(*path));
277 if (path == (char *) NULL)
278 {
279 module_path=DestroyString(module_path);
280 wide_path=(wchar_t *) RelinquishMagickMemory(wide_path);
281 return(FALSE);
282 }
283 count=(ssize_t) GetEnvironmentVariable("PATH",path,16*MagickPathExtent);
284 if ((count != 0) && (strstr(path,module_path) == (char *) NULL))
285 {
286 if ((strlen(module_path)+count+1) < (16*MagickPathExtent-1))
287 {
288 char
289 *variable;
290
291 variable=(char *) AcquireQuantumMemory(16UL*MagickPathExtent,
292 sizeof(*variable));
293 if (variable == (char *) NULL)
294 {
295 path=DestroyString(path);
296 module_path=DestroyString(module_path);
297 wide_path=(wchar_t *) RelinquishMagickMemory(wide_path);
298 return(FALSE);
299 }
300 (void) FormatLocaleString(variable,16*MagickPathExtent,
301 "%s;%s",module_path,path);
302 SetEnvironmentVariable("PATH",variable);
303 variable=DestroyString(variable);
304 }
305 }
306 path=DestroyString(path);
307 module_path=DestroyString(module_path);
308 }
309 wide_path=(wchar_t *) RelinquishMagickMemory(wide_path);
310 break;
311 }
312 case DLL_PROCESS_DETACH:
313 {
314 MagickCoreTerminus();
315 break;
316 }
317 default:
318 break;
319 }
320 return(TRUE);
321 }
322 #endif
323
324 /*
325 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
326 % %
327 % %
328 % %
329 % E x i t %
330 % %
331 % %
332 % %
333 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
334 %
335 % Exit() calls TerminateProcess for Win95.
336 %
337 % The format of the exit method is:
338 %
339 % int Exit(int status)
340 %
341 % A description of each parameter follows:
342 %
343 % o status: an integer value representing the status of the terminating
344 % process.
345 %
346 */
Exit(int status)347 MagickPrivate int Exit(int status)
348 {
349 if (IsWindows95())
350 {
351 TerminateProcess(GetCurrentProcess(),(unsigned int) status);
352 return(0);
353 }
354 exit(status);
355 }
356
357 #if !defined(__MINGW32__)
358 /*
359 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
360 % %
361 % %
362 % %
363 % g e t t i m e o f d a y %
364 % %
365 % %
366 % %
367 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
368 %
369 % The gettimeofday() method get the time of day.
370 %
371 % The format of the gettimeofday method is:
372 %
373 % int gettimeofday(struct timeval *time_value,struct timezone *time_zone)
374 %
375 % A description of each parameter follows:
376 %
377 % o time_value: the time value.
378 %
379 % o time_zone: the time zone.
380 %
381 */
gettimeofday(struct timeval * time_value,struct timezone * time_zone)382 MagickPrivate int gettimeofday (struct timeval *time_value,
383 struct timezone *time_zone)
384 {
385 #define EpochFiletime MagickLLConstant(116444736000000000)
386
387 static int
388 is_tz_set;
389
390 if (time_value != (struct timeval *) NULL)
391 {
392 FILETIME
393 file_time;
394
395 __int64
396 time;
397
398 LARGE_INTEGER
399 date_time;
400
401 GetSystemTimeAsFileTime(&file_time);
402 date_time.LowPart=file_time.dwLowDateTime;
403 date_time.HighPart=file_time.dwHighDateTime;
404 time=date_time.QuadPart;
405 time-=EpochFiletime;
406 time/=10;
407 time_value->tv_sec=(ssize_t) (time / 1000000);
408 time_value->tv_usec=(ssize_t) (time % 1000000);
409 }
410 if (time_zone != (struct timezone *) NULL)
411 {
412 if (is_tz_set == 0)
413 {
414 _tzset();
415 is_tz_set++;
416 }
417 time_zone->tz_minuteswest=_timezone/60;
418 time_zone->tz_dsttime=_daylight;
419 }
420 return(0);
421 }
422 #endif
423
424 /*
425 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
426 % %
427 % %
428 % %
429 % I s W i n d o w s 9 5 %
430 % %
431 % %
432 % %
433 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
434 %
435 % IsWindows95() returns true if the system is Windows 95.
436 %
437 % The format of the IsWindows95 method is:
438 %
439 % int IsWindows95()
440 %
441 */
IsWindows95()442 MagickPrivate int IsWindows95()
443 {
444 OSVERSIONINFO
445 version_info;
446
447 version_info.dwOSVersionInfoSize=sizeof(version_info);
448 if (GetVersionEx(&version_info) &&
449 (version_info.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS))
450 return(1);
451 return(0);
452 }
453
454 /*
455 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
456 % %
457 % %
458 % %
459 % N T A r g v T o U T F 8 %
460 % %
461 % %
462 % %
463 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
464 %
465 % NTArgvToUTF8() converts the wide command line arguments to UTF-8 to ensure
466 % compatibility with Linux.
467 %
468 % The format of the NTArgvToUTF8 method is:
469 %
470 % char **NTArgvToUTF8(const int argc,wchar_t **argv)
471 %
472 % A description of each parameter follows:
473 %
474 % o argc: the number of command line arguments.
475 %
476 % o argv: the wide-character command line arguments.
477 %
478 */
NTArgvToUTF8(const int argc,wchar_t ** argv)479 MagickPrivate char **NTArgvToUTF8(const int argc,wchar_t **argv)
480 {
481 char
482 **utf8;
483
484 ssize_t
485 i;
486
487 utf8=(char **) AcquireQuantumMemory(argc,sizeof(*utf8));
488 if (utf8 == (char **) NULL)
489 ThrowFatalException(ResourceLimitFatalError,"UnableToConvertStringToARGV");
490 for (i=0; i < (ssize_t) argc; i++)
491 {
492 utf8[i]=create_utf8_string(argv[i]);
493 if (utf8[i] == (char *) NULL)
494 {
495 for (i--; i >= 0; i--)
496 utf8[i]=DestroyString(utf8[i]);
497 ThrowFatalException(ResourceLimitFatalError,
498 "UnableToConvertStringToARGV");
499 }
500 }
501 return(utf8);
502 }
503
504 /*
505 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
506 % %
507 % %
508 % %
509 % N T C l o s e D i r e c t o r y %
510 % %
511 % %
512 % %
513 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
514 %
515 % NTCloseDirectory() closes the named directory stream and frees the DIR
516 % structure.
517 %
518 % The format of the NTCloseDirectory method is:
519 %
520 % int NTCloseDirectory(DIR *entry)
521 %
522 % A description of each parameter follows:
523 %
524 % o entry: Specifies a pointer to a DIR structure.
525 %
526 */
NTCloseDirectory(DIR * entry)527 MagickPrivate int NTCloseDirectory(DIR *entry)
528 {
529 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
530 assert(entry != (DIR *) NULL);
531 FindClose(entry->hSearch);
532 entry=(DIR *) RelinquishMagickMemory(entry);
533 return(0);
534 }
535 /*
536 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
537 % %
538 % %
539 % %
540 % N T C l o s e L i b r a r y %
541 % %
542 % %
543 % %
544 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
545 %
546 % NTCloseLibrary() unloads the module associated with the passed handle.
547 %
548 % The format of the NTCloseLibrary method is:
549 %
550 % void NTCloseLibrary(void *handle)
551 %
552 % A description of each parameter follows:
553 %
554 % o handle: Specifies a handle to a previously loaded dynamic module.
555 %
556 */
NTCloseLibrary(void * handle)557 MagickPrivate int NTCloseLibrary(void *handle)
558 {
559 if (IsWindows95())
560 return(FreeLibrary((HINSTANCE) handle));
561 return(!(FreeLibrary((HINSTANCE) handle)));
562 }
563
564 /*
565 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
566 % %
567 % %
568 % %
569 % N T C o n t r o l H a n d l e r %
570 % %
571 % %
572 % %
573 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
574 %
575 % NTControlHandler() registers a control handler that is activated when, for
576 % example, a ctrl-c is received.
577 %
578 % The format of the NTControlHandler method is:
579 %
580 % int NTControlHandler(void)
581 %
582 */
583
ControlHandler(DWORD type)584 static BOOL ControlHandler(DWORD type)
585 {
586 (void) type;
587 AsynchronousResourceComponentTerminus();
588 return(FALSE);
589 }
590
NTControlHandler(void)591 MagickPrivate int NTControlHandler(void)
592 {
593 return(SetConsoleCtrlHandler((PHANDLER_ROUTINE) ControlHandler,TRUE));
594 }
595
596 /*
597 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
598 % %
599 % %
600 % %
601 % N T E l a p s e d T i m e %
602 % %
603 % %
604 % %
605 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
606 %
607 % NTElapsedTime() returns the elapsed time (in seconds) since the last call to
608 % StartTimer().
609 %
610 % The format of the ElapsedTime method is:
611 %
612 % double NTElapsedTime(void)
613 %
614 */
NTElapsedTime(void)615 MagickPrivate double NTElapsedTime(void)
616 {
617 union
618 {
619 FILETIME
620 filetime;
621
622 __int64
623 filetime64;
624 } elapsed_time;
625
626 LARGE_INTEGER
627 performance_count;
628
629 static LARGE_INTEGER
630 frequency = { 0 };
631
632 SYSTEMTIME
633 system_time;
634
635 if (frequency.QuadPart == 0)
636 {
637 if (QueryPerformanceFrequency(&frequency) == 0)
638 frequency.QuadPart=1;
639 }
640 if (frequency.QuadPart > 1)
641 {
642 QueryPerformanceCounter(&performance_count);
643 return((double) performance_count.QuadPart/frequency.QuadPart);
644 }
645 GetSystemTime(&system_time);
646 SystemTimeToFileTime(&system_time,&elapsed_time.filetime);
647 return((double) 1.0e-7*elapsed_time.filetime64);
648 }
649
650 /*
651 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
652 % %
653 % %
654 % %
655 % N T E r f %
656 % %
657 % %
658 % %
659 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
660 %
661 % NTErf() computes the error function of x.
662 %
663 % The format of the NTErf method is:
664 %
665 % double NTCloseDirectory(DIR *entry)
666 %
667 % A description of each parameter follows:
668 %
669 % o x: Specifies a pointer to a DIR structure.
670 %
671 */
NTErf(double x)672 MagickPrivate double NTErf(double x)
673 {
674 double
675 a1,
676 a2,
677 a3,
678 a4,
679 a5,
680 p,
681 t,
682 y;
683
684 int
685 sign;
686
687 a1=0.254829592;
688 a2=-0.284496736;
689 a3=1.421413741;
690 a4=-1.453152027;
691 a5=1.061405429;
692 p=0.3275911;
693 sign=1;
694 if (x < 0)
695 sign=-1;
696 x=abs(x);
697 t=1.0/(1.0+p*x);
698 y=1.0-(((((a5*t+a4)*t)+a3)*t+a2)*t+a1)*t*exp(-x*x);
699 return(sign*y);
700 }
701
702
703 /*
704 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
705 % %
706 % %
707 % %
708 + N T E r r o r H a n d l e r %
709 % %
710 % %
711 % %
712 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
713 %
714 % NTErrorHandler() displays an error reason and then terminates the program.
715 %
716 % The format of the NTErrorHandler method is:
717 %
718 % void NTErrorHandler(const ExceptionType severity,const char *reason,
719 % const char *description)
720 %
721 % A description of each parameter follows:
722 %
723 % o severity: Specifies the numeric error category.
724 %
725 % o reason: Specifies the reason to display before terminating the
726 % program.
727 %
728 % o description: Specifies any description to the reason.
729 %
730 */
NTErrorHandler(const ExceptionType severity,const char * reason,const char * description)731 MagickPrivate void NTErrorHandler(const ExceptionType severity,
732 const char *reason,const char *description)
733 {
734 char
735 buffer[3*MagickPathExtent],
736 *message;
737
738 (void) severity;
739 if (reason == (char *) NULL)
740 {
741 MagickCoreTerminus();
742 exit(0);
743 }
744 message=GetExceptionMessage(errno);
745 if ((description != (char *) NULL) && errno)
746 (void) FormatLocaleString(buffer,MagickPathExtent,"%s: %s (%s) [%s].\n",
747 GetClientName(),reason,description,message);
748 else
749 if (description != (char *) NULL)
750 (void) FormatLocaleString(buffer,MagickPathExtent,"%s: %s (%s).\n",
751 GetClientName(),reason,description);
752 else
753 if (errno != 0)
754 (void) FormatLocaleString(buffer,MagickPathExtent,"%s: %s [%s].\n",
755 GetClientName(),reason,message);
756 else
757 (void) FormatLocaleString(buffer,MagickPathExtent,"%s: %s.\n",
758 GetClientName(),reason);
759 message=DestroyString(message);
760 (void) MessageBox(NULL,buffer,"ImageMagick Exception",MB_OK | MB_TASKMODAL |
761 MB_SETFOREGROUND | MB_ICONEXCLAMATION);
762 MagickCoreTerminus();
763 exit(0);
764 }
765
766 /*
767 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
768 % %
769 % %
770 % %
771 % N T E x i t L i b r a r y %
772 % %
773 % %
774 % %
775 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
776 %
777 % NTExitLibrary() exits the dynamic module loading subsystem.
778 %
779 % The format of the NTExitLibrary method is:
780 %
781 % int NTExitLibrary(void)
782 %
783 */
NTExitLibrary(void)784 MagickPrivate int NTExitLibrary(void)
785 {
786 return(0);
787 }
788
789 /*
790 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
791 % %
792 % %
793 % %
794 % N T G a t h e r R a n d o m D a t a %
795 % %
796 % %
797 % %
798 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
799 %
800 % NTGatherRandomData() gathers random data and returns it.
801 %
802 % The format of the GatherRandomData method is:
803 %
804 % MagickBooleanType NTGatherRandomData(const size_t length,
805 % unsigned char *random)
806 %
807 % A description of each parameter follows:
808 %
809 % length: the length of random data buffer
810 %
811 % random: the random data is returned here.
812 %
813 */
NTGatherRandomData(const size_t length,unsigned char * random)814 MagickPrivate MagickBooleanType NTGatherRandomData(const size_t length,
815 unsigned char *random)
816 {
817 #if defined(MAGICKCORE_CIPHER_SUPPORT) && defined(_MSC_VER) && (_MSC_VER > 1200)
818 HCRYPTPROV
819 handle;
820
821 int
822 status;
823
824 handle=(HCRYPTPROV) NULL;
825 status=CryptAcquireContext(&handle,NULL,MS_DEF_PROV,PROV_RSA_FULL,
826 (CRYPT_VERIFYCONTEXT | CRYPT_MACHINE_KEYSET));
827 if (status == 0)
828 status=CryptAcquireContext(&handle,NULL,MS_DEF_PROV,PROV_RSA_FULL,
829 (CRYPT_VERIFYCONTEXT | CRYPT_MACHINE_KEYSET | CRYPT_NEWKEYSET));
830 if (status == 0)
831 return(MagickFalse);
832 status=CryptGenRandom(handle,(DWORD) length,random);
833 if (status == 0)
834 {
835 status=CryptReleaseContext(handle,0);
836 return(MagickFalse);
837 }
838 status=CryptReleaseContext(handle,0);
839 if (status == 0)
840 return(MagickFalse);
841 #else
842 (void) random;
843 (void) length;
844 #endif
845 return(MagickTrue);
846 }
847
848 /*
849 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
850 % %
851 % %
852 % %
853 % N T G e t E x e c u t i o n P a t h %
854 % %
855 % %
856 % %
857 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
858 %
859 % NTGetExecutionPath() returns the execution path of a program.
860 %
861 % The format of the GetExecutionPath method is:
862 %
863 % MagickBooleanType NTGetExecutionPath(char *path,const size_t extent)
864 %
865 % A description of each parameter follows:
866 %
867 % o path: the pathname of the executable that started the process.
868 %
869 % o extent: the maximum extent of the path.
870 %
871 */
NTGetExecutionPath(char * path,const size_t extent)872 MagickPrivate MagickBooleanType NTGetExecutionPath(char *path,
873 const size_t extent)
874 {
875 wchar_t
876 wide_path[MagickPathExtent];
877
878 (void) GetModuleFileNameW((HMODULE) NULL,wide_path,(DWORD) extent);
879 (void) WideCharToMultiByte(CP_UTF8,0,wide_path,-1,path,(int) extent,NULL,
880 NULL);
881 return(MagickTrue);
882 }
883
884 /*
885 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
886 % %
887 % %
888 % %
889 % N T G e t L a s t E r r o r %
890 % %
891 % %
892 % %
893 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
894 %
895 % NTGetLastError() returns the last error that occurred.
896 %
897 % The format of the NTGetLastError method is:
898 %
899 % char *NTGetLastError(void)
900 %
901 */
NTGetLastError(void)902 char *NTGetLastError(void)
903 {
904 char
905 *reason;
906
907 int
908 status;
909
910 LPVOID
911 buffer;
912
913 status=FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER |
914 FORMAT_MESSAGE_FROM_SYSTEM,NULL,GetLastError(),
915 MAKELANGID(LANG_NEUTRAL,SUBLANG_DEFAULT),(LPTSTR) &buffer,0,NULL);
916 if (!status)
917 reason=AcquireString("An unknown error occurred");
918 else
919 {
920 reason=AcquireString((const char *) buffer);
921 LocalFree(buffer);
922 }
923 return(reason);
924 }
925
926 /*
927 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
928 % %
929 % %
930 % %
931 % N T G e t L i b r a r y E r r o r %
932 % %
933 % %
934 % %
935 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
936 %
937 % Lt_dlerror() returns a pointer to a string describing the last error
938 % associated with a lt_dl method. Note that this function is not thread
939 % safe so it should only be used under the protection of a lock.
940 %
941 % The format of the NTGetLibraryError method is:
942 %
943 % const char *NTGetLibraryError(void)
944 %
945 */
NTGetLibraryError(void)946 MagickPrivate const char *NTGetLibraryError(void)
947 {
948 static char
949 last_error[MagickPathExtent];
950
951 char
952 *error;
953
954 *last_error='\0';
955 error=NTGetLastError();
956 if (error)
957 (void) CopyMagickString(last_error,error,MagickPathExtent);
958 error=DestroyString(error);
959 return(last_error);
960 }
961
962 /*
963 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
964 % %
965 % %
966 % %
967 % N T G e t L i b r a r y S y m b o l %
968 % %
969 % %
970 % %
971 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
972 %
973 % NTGetLibrarySymbol() retrieve the procedure address of the method
974 % specified by the passed character string.
975 %
976 % The format of the NTGetLibrarySymbol method is:
977 %
978 % void *NTGetLibrarySymbol(void *handle,const char *name)
979 %
980 % A description of each parameter follows:
981 %
982 % o handle: Specifies a handle to the previously loaded dynamic module.
983 %
984 % o name: Specifies the procedure entry point to be returned.
985 %
986 */
NTGetLibrarySymbol(void * handle,const char * name)987 void *NTGetLibrarySymbol(void *handle,const char *name)
988 {
989 LPFNDLLFUNC1
990 lpfnDllFunc1;
991
992 lpfnDllFunc1=(LPFNDLLFUNC1) GetProcAddress((HINSTANCE) handle,name);
993 if (!lpfnDllFunc1)
994 return((void *) NULL);
995 return((void *) lpfnDllFunc1);
996 }
997
998 /*
999 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1000 % %
1001 % %
1002 % %
1003 % N T G e t M o d u l e P a t h %
1004 % %
1005 % %
1006 % %
1007 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1008 %
1009 % NTGetModulePath() returns the path of the specified module.
1010 %
1011 % The format of the GetModulePath method is:
1012 %
1013 % MagickBooleanType NTGetModulePath(const char *module,char *path)
1014 %
1015 % A description of each parameter follows:
1016 %
1017 % modith: the module name.
1018 %
1019 % path: the module path is returned here.
1020 %
1021 */
NTGetModulePath(const char * module,char * path)1022 MagickPrivate MagickBooleanType NTGetModulePath(const char *module,char *path)
1023 {
1024 char
1025 module_path[MagickPathExtent];
1026
1027 HMODULE
1028 handle;
1029
1030 ssize_t
1031 length;
1032
1033 *path='\0';
1034 handle=GetModuleHandle(module);
1035 if (handle == (HMODULE) NULL)
1036 return(MagickFalse);
1037 length=GetModuleFileName(handle,module_path,MagickPathExtent);
1038 if (length != 0)
1039 GetPathComponent(module_path,HeadPath,path);
1040 return(MagickTrue);
1041 }
1042
1043 /*
1044 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1045 % %
1046 % %
1047 % %
1048 + N T G e t P a g e S i z e %
1049 % %
1050 % %
1051 % %
1052 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1053 %
1054 % NTGetPageSize() returns the memory page size under Windows.
1055 %
1056 % The format of the NTPageSize
1057 %
1058 % NTPageSize()
1059 %
1060 */
NTGetPageSize(void)1061 MagickPrivate ssize_t NTGetPageSize(void)
1062 {
1063 SYSTEM_INFO
1064 system_info;
1065
1066 GetSystemInfo(&system_info);
1067 return((ssize_t) system_info.dwPageSize);
1068 }
1069
1070 /*
1071 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1072 % %
1073 % %
1074 % %
1075 % N T G h o s t s c r i p t D L L %
1076 % %
1077 % %
1078 % %
1079 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1080 %
1081 % NTGhostscriptDLL() returns the path to the most recent Ghostscript version
1082 % DLL. The method returns TRUE on success otherwise FALSE.
1083 %
1084 % The format of the NTGhostscriptDLL method is:
1085 %
1086 % int NTGhostscriptDLL(char *path,int length)
1087 %
1088 % A description of each parameter follows:
1089 %
1090 % o path: return the Ghostscript DLL path here.
1091 %
1092 % o length: the buffer length.
1093 %
1094 */
1095
NTGetRegistryValue(HKEY root,const char * key,DWORD flags,const char * name,char * value,int * length)1096 static int NTGetRegistryValue(HKEY root,const char *key,DWORD flags,
1097 const char *name,char *value,int *length)
1098 {
1099 BYTE
1100 byte,
1101 *p;
1102
1103 DWORD
1104 extent,
1105 type;
1106
1107 HKEY
1108 hkey;
1109
1110 LONG
1111 status;
1112
1113 /*
1114 Get a registry value: key = root\\key, named value = name.
1115 */
1116 if (RegOpenKeyExA(root,key,0,KEY_READ | flags,&hkey) != ERROR_SUCCESS)
1117 return(1); /* no match */
1118 p=(BYTE *) value;
1119 type=REG_SZ;
1120 extent=(*length);
1121 if (p == (BYTE *) NULL)
1122 p=(&byte); /* ERROR_MORE_DATA only if value is NULL */
1123 status=RegQueryValueExA(hkey,(char *) name,0,&type,p,&extent);
1124 RegCloseKey(hkey);
1125 if (status == ERROR_SUCCESS)
1126 {
1127 *length=extent;
1128 return(0); /* return the match */
1129 }
1130 if (status == ERROR_MORE_DATA)
1131 {
1132 *length=extent;
1133 return(-1); /* buffer not large enough */
1134 }
1135 return(1); /* not found */
1136 }
1137
NTLocateGhostscript(DWORD flags,int * root_index,const char ** product_family,int * major_version,int * minor_version)1138 static int NTLocateGhostscript(DWORD flags,int *root_index,
1139 const char **product_family,int *major_version,int *minor_version)
1140 {
1141 int
1142 i;
1143
1144 MagickBooleanType
1145 status;
1146
1147 static const char
1148 *products[4] =
1149 {
1150 "GPL Ghostscript",
1151 "GNU Ghostscript",
1152 "AFPL Ghostscript",
1153 "Aladdin Ghostscript"
1154 };
1155
1156 /*
1157 Find the most recent version of Ghostscript.
1158 */
1159 status=MagickFalse;
1160 *root_index=0;
1161 *product_family=NULL;
1162 *major_version=5;
1163 *minor_version=49; /* min version of Ghostscript is 5.50 */
1164 for (i=0; i < (ssize_t) (sizeof(products)/sizeof(products[0])); i++)
1165 {
1166 char
1167 key[MagickPathExtent];
1168
1169 HKEY
1170 hkey;
1171
1172 int
1173 j;
1174
1175 REGSAM
1176 mode;
1177
1178 (void) FormatLocaleString(key,MagickPathExtent,"SOFTWARE\\%s",products[i]);
1179 for (j=0; j < (ssize_t) (sizeof(registry_roots)/sizeof(registry_roots[0]));
1180 j++)
1181 {
1182 mode=KEY_READ | flags;
1183 if (RegOpenKeyExA(registry_roots[j].hkey,key,0,mode,&hkey) ==
1184 ERROR_SUCCESS)
1185 {
1186 DWORD
1187 extent;
1188
1189 int
1190 k;
1191
1192 /*
1193 Now enumerate the keys.
1194 */
1195 extent=sizeof(key)/sizeof(char);
1196 for (k=0; RegEnumKeyA(hkey,k,key,extent) == ERROR_SUCCESS; k++)
1197 {
1198 int
1199 major,
1200 minor;
1201
1202 major=0;
1203 minor=0;
1204 if (sscanf(key,"%d.%d",&major,&minor) != 2)
1205 continue;
1206 if ((major > *major_version) || ((major == *major_version) &&
1207 (minor > *minor_version)))
1208 {
1209 *root_index=j;
1210 *product_family=products[i];
1211 *major_version=major;
1212 *minor_version=minor;
1213 status=MagickTrue;
1214 }
1215 }
1216 (void) RegCloseKey(hkey);
1217 }
1218 }
1219 }
1220 if (status == MagickFalse)
1221 {
1222 *major_version=0;
1223 *minor_version=0;
1224 }
1225 (void) LogMagickEvent(ConfigureEvent,GetMagickModule(),"Ghostscript (%s) "
1226 "version %d.%02d",*product_family,*major_version,*minor_version);
1227 return(status);
1228 }
1229
NTGhostscriptGetString(const char * name,BOOL * is_64_bit,char * value,const size_t length)1230 static int NTGhostscriptGetString(const char *name,BOOL *is_64_bit,char *value,
1231 const size_t length)
1232 {
1233 char
1234 buffer[MagickPathExtent],
1235 *directory;
1236
1237 int
1238 extent;
1239
1240 static const char
1241 *product_family = (const char *) NULL;
1242
1243 static BOOL
1244 is_64_bit_version = FALSE;
1245
1246 static int
1247 flags = 0,
1248 major_version = 0,
1249 minor_version = 0,
1250 root_index = 0;
1251
1252 /*
1253 Get a string from the installed Ghostscript.
1254 */
1255 *value='\0';
1256 directory=(char *) NULL;
1257 if (LocaleCompare(name,"GS_DLL") == 0)
1258 {
1259 directory=GetEnvironmentValue("MAGICK_GHOSTSCRIPT_PATH");
1260 if (directory != (char *) NULL)
1261 {
1262 (void) FormatLocaleString(buffer,MagickPathExtent,"%s%sgsdll32.dll",
1263 directory,DirectorySeparator);
1264 if (IsPathAccessible(buffer) != MagickFalse)
1265 {
1266 directory=DestroyString(directory);
1267 (void) CopyMagickString(value,buffer,length);
1268 if (is_64_bit != NULL)
1269 *is_64_bit=FALSE;
1270 return(TRUE);
1271 }
1272 (void) FormatLocaleString(buffer,MagickPathExtent,"%s%sgsdll64.dll",
1273 directory,DirectorySeparator);
1274 if (IsPathAccessible(buffer) != MagickFalse)
1275 {
1276 directory=DestroyString(directory);
1277 (void) CopyMagickString(value,buffer,length);
1278 if (is_64_bit != NULL)
1279 *is_64_bit=TRUE;
1280 return(TRUE);
1281 }
1282 return(FALSE);
1283 }
1284 }
1285 if (product_family == NULL)
1286 {
1287 flags=0;
1288 #if defined(KEY_WOW64_32KEY)
1289 #if defined(_WIN64)
1290 flags=KEY_WOW64_64KEY;
1291 #else
1292 flags=KEY_WOW64_32KEY;
1293 #endif
1294 (void) NTLocateGhostscript(flags,&root_index,&product_family,
1295 &major_version,&minor_version);
1296 if (product_family == NULL)
1297 #if defined(_WIN64)
1298 flags=KEY_WOW64_32KEY;
1299 else
1300 is_64_bit_version=TRUE;
1301 #else
1302 flags=KEY_WOW64_64KEY;
1303 #endif
1304 #endif
1305 }
1306 if (product_family == NULL)
1307 {
1308 (void) NTLocateGhostscript(flags,&root_index,&product_family,
1309 &major_version,&minor_version);
1310 #if !defined(_WIN64)
1311 is_64_bit_version=TRUE;
1312 #endif
1313 }
1314 if (product_family == NULL)
1315 return(FALSE);
1316 if (is_64_bit != NULL)
1317 *is_64_bit=is_64_bit_version;
1318 (void) FormatLocaleString(buffer,MagickPathExtent,"SOFTWARE\\%s\\%d.%02d",
1319 product_family,major_version,minor_version);
1320 extent=(int) length;
1321 if (NTGetRegistryValue(registry_roots[root_index].hkey,buffer,flags,name,value,&extent) == 0)
1322 {
1323 (void) LogMagickEvent(ConfigureEvent,GetMagickModule(),
1324 "registry: \"%s\\%s\\%s\"=\"%s\"",registry_roots[root_index].name,
1325 buffer,name,value);
1326 return(TRUE);
1327 }
1328 return(FALSE);
1329 }
1330
NTGhostscriptDLL(char * path,int length)1331 MagickPrivate int NTGhostscriptDLL(char *path,int length)
1332 {
1333 static char
1334 dll[MagickPathExtent] = { "" };
1335
1336 static BOOL
1337 is_64_bit_version;
1338
1339 *path='\0';
1340 if ((*dll == '\0') &&
1341 (NTGhostscriptGetString("GS_DLL",&is_64_bit_version,dll,sizeof(dll)) == FALSE))
1342 return(FALSE);
1343 #if defined(_WIN64)
1344 if (!is_64_bit_version)
1345 return(FALSE);
1346 #else
1347 if (is_64_bit_version)
1348 return(FALSE);
1349 #endif
1350 (void) CopyMagickString(path,dll,length);
1351 return(TRUE);
1352 }
1353
1354 /*
1355 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1356 % %
1357 % %
1358 % %
1359 % N T G h o s t s c r i p t D L L V e c t o r s %
1360 % %
1361 % %
1362 % %
1363 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1364 %
1365 % NTGhostscriptDLLVectors() returns a GhostInfo structure that includes
1366 % function vectors to invoke Ghostscript DLL functions. A null pointer is
1367 % returned if there is an error when loading the DLL or retrieving the
1368 % function vectors.
1369 %
1370 % The format of the NTGhostscriptDLLVectors method is:
1371 %
1372 % const GhostInfo *NTGhostscriptDLLVectors(void)
1373 %
1374 */
NTGhostscriptDLLVectors(void)1375 MagickPrivate const GhostInfo *NTGhostscriptDLLVectors(void)
1376 {
1377 if (NTGhostscriptLoadDLL() == FALSE)
1378 return((GhostInfo *) NULL);
1379 return(&ghost_info);
1380 }
1381
1382 /*
1383 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1384 % %
1385 % %
1386 % %
1387 % N T G h o s t s c r i p t E X E %
1388 % %
1389 % %
1390 % %
1391 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1392 %
1393 % NTGhostscriptEXE() obtains the path to the latest Ghostscript executable.
1394 % The method returns FALSE if a full path value is not obtained and returns
1395 % a default path of gswin32c.exe.
1396 %
1397 % The format of the NTGhostscriptEXE method is:
1398 %
1399 % int NTGhostscriptEXE(char *path,int length)
1400 %
1401 % A description of each parameter follows:
1402 %
1403 % o path: return the Ghostscript executable path here.
1404 %
1405 % o length: length of buffer.
1406 %
1407 */
NTGhostscriptEXE(char * path,int length)1408 MagickPrivate int NTGhostscriptEXE(char *path,int length)
1409 {
1410 register char
1411 *p;
1412
1413 static char
1414 program[MagickPathExtent] = { "" };
1415
1416 static BOOL
1417 is_64_bit_version = FALSE;
1418
1419 (void) CopyMagickString(path,"gswin32c.exe",length);
1420 if (*program == '\0')
1421 {
1422 if (ghost_semaphore == (SemaphoreInfo *) NULL)
1423 ActivateSemaphoreInfo(&ghost_semaphore);
1424 LockSemaphoreInfo(ghost_semaphore);
1425 if (*program == '\0')
1426 {
1427 if (NTGhostscriptGetString("GS_DLL",&is_64_bit_version,program,
1428 sizeof(program)) == FALSE)
1429 {
1430 UnlockSemaphoreInfo(ghost_semaphore);
1431 return(FALSE);
1432 }
1433 p=strrchr(program,'\\');
1434 if (p != (char *) NULL)
1435 {
1436 p++;
1437 *p='\0';
1438 (void) ConcatenateMagickString(program,is_64_bit_version ?
1439 "gswin64c.exe" : "gswin32c.exe",sizeof(program));
1440 }
1441 }
1442 UnlockSemaphoreInfo(ghost_semaphore);
1443 }
1444 (void) CopyMagickString(path,program,length);
1445 return(TRUE);
1446 }
1447
1448 /*
1449 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1450 % %
1451 % %
1452 % %
1453 % N T G h o s t s c r i p t F o n t s %
1454 % %
1455 % %
1456 % %
1457 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1458 %
1459 % NTGhostscriptFonts() obtains the path to the Ghostscript fonts. The method
1460 % returns FALSE if it cannot determine the font path.
1461 %
1462 % The format of the NTGhostscriptFonts method is:
1463 %
1464 % int NTGhostscriptFonts(char *path,int length)
1465 %
1466 % A description of each parameter follows:
1467 %
1468 % o path: return the font path here.
1469 %
1470 % o length: length of the path buffer.
1471 %
1472 */
NTGhostscriptFonts(char * path,int length)1473 MagickPrivate int NTGhostscriptFonts(char *path,int length)
1474 {
1475 char
1476 buffer[MagickPathExtent],
1477 *directory,
1478 filename[MagickPathExtent];
1479
1480 register char
1481 *p,
1482 *q;
1483
1484 *path='\0';
1485 directory=GetEnvironmentValue("MAGICK_GHOSTSCRIPT_FONT_PATH");
1486 if (directory != (char *) NULL)
1487 {
1488 (void) CopyMagickString(buffer,directory,MagickPathExtent);
1489 directory=DestroyString(directory);
1490 }
1491 else
1492 {
1493 if (NTGhostscriptGetString("GS_LIB",NULL,buffer,MagickPathExtent) == FALSE)
1494 return(FALSE);
1495 }
1496 for (p=buffer-1; p != (char *) NULL; p=strchr(p+1,DirectoryListSeparator))
1497 {
1498 (void) CopyMagickString(path,p+1,length+1);
1499 q=strchr(path,DirectoryListSeparator);
1500 if (q != (char *) NULL)
1501 *q='\0';
1502 (void) FormatLocaleString(filename,MagickPathExtent,"%s%sfonts.dir",path,
1503 DirectorySeparator);
1504 if (IsPathAccessible(filename) != MagickFalse)
1505 return(TRUE);
1506 (void) FormatLocaleString(filename,MagickPathExtent,"%s%sn019003l.pfb",path,
1507 DirectorySeparator);
1508 if (IsPathAccessible(filename) != MagickFalse)
1509 return(TRUE);
1510 }
1511 *path='\0';
1512 return(FALSE);
1513 }
1514
1515 /*
1516 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1517 % %
1518 % %
1519 % %
1520 % N T G h o s t s c r i p t L o a d D L L %
1521 % %
1522 % %
1523 % %
1524 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1525 %
1526 % NTGhostscriptLoadDLL() attempts to load the Ghostscript DLL and returns
1527 % TRUE if it succeeds.
1528 %
1529 % The format of the NTGhostscriptLoadDLL method is:
1530 %
1531 % int NTGhostscriptLoadDLL(void)
1532 %
1533 */
NTGhostscriptHasValidHandle()1534 static inline int NTGhostscriptHasValidHandle()
1535 {
1536 if ((nt_ghost_info.delete_instance == NULL) || (ghost_info.exit == NULL) ||
1537 (ghost_info.init_with_args == NULL) ||
1538 (nt_ghost_info.new_instance == NULL) ||
1539 (ghost_info.run_string == NULL) || (ghost_info.set_stdio == NULL) ||
1540 (ghost_info.revision == NULL))
1541 {
1542 return(FALSE);
1543 }
1544 return(TRUE);
1545 }
1546
NTGhostscriptLoadDLL(void)1547 MagickPrivate int NTGhostscriptLoadDLL(void)
1548 {
1549 char
1550 path[MagickPathExtent];
1551
1552 if (ghost_semaphore == (SemaphoreInfo *) NULL)
1553 ActivateSemaphoreInfo(&ghost_semaphore);
1554 LockSemaphoreInfo(ghost_semaphore);
1555 if (ghost_handle != (void *) NULL)
1556 {
1557 UnlockSemaphoreInfo(ghost_semaphore);
1558 return(NTGhostscriptHasValidHandle());
1559 }
1560 if (NTGhostscriptDLL(path,sizeof(path)) == FALSE)
1561 {
1562 UnlockSemaphoreInfo(ghost_semaphore);
1563 return(FALSE);
1564 }
1565 ghost_handle=lt_dlopen(path);
1566 if (ghost_handle == (void *) NULL)
1567 {
1568 UnlockSemaphoreInfo(ghost_semaphore);
1569 return(FALSE);
1570 }
1571 (void) memset((void *) &nt_ghost_info,0,sizeof(NTGhostInfo));
1572 nt_ghost_info.delete_instance=(void (MagickDLLCall *)(gs_main_instance *)) (
1573 lt_dlsym(ghost_handle,"gsapi_delete_instance"));
1574 nt_ghost_info.new_instance=(int (MagickDLLCall *)(gs_main_instance **,
1575 void *)) (lt_dlsym(ghost_handle,"gsapi_new_instance"));
1576 nt_ghost_info.has_instance=MagickFalse;
1577 (void) memset((void *) &ghost_info,0,sizeof(GhostInfo));
1578 ghost_info.delete_instance=NTGhostscriptDeleteInstance;
1579 ghost_info.exit=(int (MagickDLLCall *)(gs_main_instance*))
1580 lt_dlsym(ghost_handle,"gsapi_exit");
1581 ghost_info.init_with_args=(int (MagickDLLCall *)(gs_main_instance *,int,
1582 char **)) (lt_dlsym(ghost_handle,"gsapi_init_with_args"));
1583 ghost_info.new_instance=NTGhostscriptNewInstance;
1584 ghost_info.run_string=(int (MagickDLLCall *)(gs_main_instance *,const char *,
1585 int,int *)) (lt_dlsym(ghost_handle,"gsapi_run_string"));
1586 ghost_info.set_stdio=(int (MagickDLLCall *)(gs_main_instance *,int(
1587 MagickDLLCall *)(void *,char *,int),int(MagickDLLCall *)(void *,
1588 const char *,int),int(MagickDLLCall *)(void *,const char *,int)))
1589 (lt_dlsym(ghost_handle,"gsapi_set_stdio"));
1590 ghost_info.revision=(int (MagickDLLCall *)(gsapi_revision_t *,int)) (
1591 lt_dlsym(ghost_handle,"gsapi_revision"));
1592 UnlockSemaphoreInfo(ghost_semaphore);
1593 return(NTGhostscriptHasValidHandle());
1594 }
1595
1596 /*
1597 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1598 % %
1599 % %
1600 % %
1601 % N T G h o s t s c r i p t U n L o a d D L L %
1602 % %
1603 % %
1604 % %
1605 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1606 %
1607 % NTGhostscriptUnLoadDLL() unloads the Ghostscript DLL and returns TRUE if
1608 % it succeeds.
1609 %
1610 % The format of the NTGhostscriptUnLoadDLL method is:
1611 %
1612 % int NTGhostscriptUnLoadDLL(void)
1613 %
1614 */
NTGhostscriptUnLoadDLL(void)1615 MagickPrivate void NTGhostscriptUnLoadDLL(void)
1616 {
1617 if (ghost_semaphore == (SemaphoreInfo *) NULL)
1618 ActivateSemaphoreInfo(&ghost_semaphore);
1619 LockSemaphoreInfo(ghost_semaphore);
1620 if (ghost_handle != (void *) NULL)
1621 {
1622 (void) lt_dlclose(ghost_handle);
1623 ghost_handle=(void *) NULL;
1624 (void) memset((void *) &ghost_info,0,sizeof(GhostInfo));
1625 }
1626 UnlockSemaphoreInfo(ghost_semaphore);
1627 RelinquishSemaphoreInfo(&ghost_semaphore);
1628 }
1629
1630 /*
1631 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1632 % %
1633 % %
1634 % %
1635 % N T I n i t i a l i z e L i b r a r y %
1636 % %
1637 % %
1638 % %
1639 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1640 %
1641 % NTInitializeLibrary() initializes the dynamic module loading subsystem.
1642 %
1643 % The format of the NTInitializeLibrary method is:
1644 %
1645 % int NTInitializeLibrary(void)
1646 %
1647 */
NTInitializeLibrary(void)1648 MagickPrivate int NTInitializeLibrary(void)
1649 {
1650 return(0);
1651 }
1652
1653 /*
1654 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1655 % %
1656 % %
1657 % %
1658 % N T I n i t i a l i z e W i n s o c k %
1659 % %
1660 % %
1661 % %
1662 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1663 %
1664 % NTInitializeWinsock() initializes Winsock.
1665 %
1666 % The format of the NTInitializeWinsock method is:
1667 %
1668 % void NTInitializeWinsock(void)
1669 %
1670 */
NTInitializeWinsock(MagickBooleanType use_lock)1671 MagickPrivate void NTInitializeWinsock(MagickBooleanType use_lock)
1672 {
1673 if (use_lock)
1674 {
1675 if (winsock_semaphore == (SemaphoreInfo *) NULL)
1676 ActivateSemaphoreInfo(&winsock_semaphore);
1677 LockSemaphoreInfo(winsock_semaphore);
1678 }
1679 if (wsaData == (WSADATA *) NULL)
1680 {
1681 wsaData=(WSADATA *) AcquireMagickMemory(sizeof(WSADATA));
1682 if (WSAStartup(MAKEWORD(2,2),wsaData) != 0)
1683 ThrowFatalException(CacheFatalError,"WSAStartup failed");
1684 }
1685 if (use_lock)
1686 UnlockSemaphoreInfo(winsock_semaphore);
1687 }
1688
1689 /*
1690 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1691 % %
1692 % %
1693 % %
1694 % N T L o n g P a t h s E n a b l e d %
1695 % %
1696 % %
1697 % %
1698 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1699 %
1700 % NTLongPathsEnabled() returns a boolean indicating whether long paths are
1701 $ enabled.
1702 %
1703 % The format of the NTLongPathsEnabled method is:
1704 %
1705 % MagickBooleanType NTLongPathsEnabled()
1706 %
1707 */
NTLongPathsEnabled()1708 MagickExport MagickBooleanType NTLongPathsEnabled()
1709 {
1710 if (long_paths_enabled == 2)
1711 {
1712 DWORD
1713 size,
1714 type,
1715 value;
1716
1717 HKEY
1718 registry_key;
1719
1720 LONG
1721 status;
1722
1723 registry_key=(HKEY) INVALID_HANDLE_VALUE;
1724 status=RegOpenKeyExA(HKEY_LOCAL_MACHINE,
1725 "SYSTEM\\CurrentControlSet\\Control\\FileSystem",0,KEY_READ,
1726 ®istry_key);
1727 if (status != ERROR_SUCCESS)
1728 {
1729 RegCloseKey(registry_key);
1730 long_paths_enabled=0;
1731 return(MagickFalse);
1732 }
1733 value=0;
1734 status=RegQueryValueExA(registry_key,"LongPathsEnabled",0,&type,NULL,
1735 NULL);
1736 if ((status != ERROR_SUCCESS) || (type != REG_DWORD))
1737 {
1738 RegCloseKey(registry_key);
1739 long_paths_enabled=0;
1740 return(MagickFalse);
1741 }
1742 status=RegQueryValueExA(registry_key,"LongPathsEnabled",0,&type,
1743 (LPBYTE) &value,&size);
1744 RegCloseKey(registry_key);
1745 if (status != ERROR_SUCCESS)
1746 {
1747 long_paths_enabled=0;
1748 return(MagickFalse);
1749 }
1750 long_paths_enabled=(size_t) value;
1751 }
1752 return(long_paths_enabled == 1 ? MagickTrue : MagickFalse);
1753 }
1754
1755 /*
1756 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1757 % %
1758 % %
1759 % %
1760 + N T M a p M e m o r y %
1761 % %
1762 % %
1763 % %
1764 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1765 %
1766 % Mmap() emulates the Unix method of the same name.
1767 %
1768 % The format of the NTMapMemory method is:
1769 %
1770 % MagickPrivate void *NTMapMemory(char *address,size_t length,int protection,
1771 % int access,int file,MagickOffsetType offset)
1772 %
1773 */
NTMapMemory(char * address,size_t length,int protection,int flags,int file,MagickOffsetType offset)1774 MagickPrivate void *NTMapMemory(char *address,size_t length,int protection,
1775 int flags,int file,MagickOffsetType offset)
1776 {
1777 DWORD
1778 access_mode,
1779 high_length,
1780 high_offset,
1781 low_length,
1782 low_offset,
1783 protection_mode;
1784
1785 HANDLE
1786 file_handle,
1787 map_handle;
1788
1789 void
1790 *map;
1791
1792 (void) address;
1793 access_mode=0;
1794 file_handle=INVALID_HANDLE_VALUE;
1795 low_length=(DWORD) (length & 0xFFFFFFFFUL);
1796 high_length=(DWORD) ((((MagickOffsetType) length) >> 32) & 0xFFFFFFFFUL);
1797 map_handle=INVALID_HANDLE_VALUE;
1798 map=(void *) NULL;
1799 low_offset=(DWORD) (offset & 0xFFFFFFFFUL);
1800 high_offset=(DWORD) ((offset >> 32) & 0xFFFFFFFFUL);
1801 protection_mode=0;
1802 if (protection & PROT_WRITE)
1803 {
1804 access_mode=FILE_MAP_WRITE;
1805 if (!(flags & MAP_PRIVATE))
1806 protection_mode=PAGE_READWRITE;
1807 else
1808 {
1809 access_mode=FILE_MAP_COPY;
1810 protection_mode=PAGE_WRITECOPY;
1811 }
1812 }
1813 else
1814 if (protection & PROT_READ)
1815 {
1816 access_mode=FILE_MAP_READ;
1817 protection_mode=PAGE_READONLY;
1818 }
1819 if ((file == -1) && (flags & MAP_ANONYMOUS))
1820 file_handle=INVALID_HANDLE_VALUE;
1821 else
1822 file_handle=(HANDLE) _get_osfhandle(file);
1823 map_handle=CreateFileMapping(file_handle,0,protection_mode,high_length,
1824 low_length,0);
1825 if (map_handle)
1826 {
1827 map=(void *) MapViewOfFile(map_handle,access_mode,high_offset,low_offset,
1828 length);
1829 CloseHandle(map_handle);
1830 }
1831 if (map == (void *) NULL)
1832 return((void *) ((char *) MAP_FAILED));
1833 return((void *) ((char *) map));
1834 }
1835
1836 /*
1837 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1838 % %
1839 % %
1840 % %
1841 % N T O p e n D i r e c t o r y %
1842 % %
1843 % %
1844 % %
1845 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1846 %
1847 % NTOpenDirectory() opens the directory named by filename and associates a
1848 % directory stream with it.
1849 %
1850 % The format of the NTOpenDirectory method is:
1851 %
1852 % DIR *NTOpenDirectory(const char *path)
1853 %
1854 % A description of each parameter follows:
1855 %
1856 % o entry: Specifies a pointer to a DIR structure.
1857 %
1858 */
NTOpenDirectory(const char * path)1859 MagickPrivate DIR *NTOpenDirectory(const char *path)
1860 {
1861 DIR
1862 *entry;
1863
1864 size_t
1865 length;
1866
1867 wchar_t
1868 file_specification[MagickPathExtent];
1869
1870 assert(path != (const char *) NULL);
1871 length=MultiByteToWideChar(CP_UTF8,0,path,-1,file_specification,
1872 MagickPathExtent);
1873 if (length == 0)
1874 return((DIR *) NULL);
1875 if (wcsncat(file_specification,(const wchar_t*) DirectorySeparator,
1876 MagickPathExtent-wcslen(file_specification)-1) == (wchar_t *) NULL)
1877 return((DIR *) NULL);
1878 entry=(DIR *) AcquireCriticalMemory(sizeof(DIR));
1879 entry->firsttime=TRUE;
1880 entry->hSearch=FindFirstFileW(file_specification,&entry->Win32FindData);
1881 if (entry->hSearch == INVALID_HANDLE_VALUE)
1882 {
1883 if(wcsncat(file_specification,L"*.*",
1884 MagickPathExtent-wcslen(file_specification)-1) == (wchar_t *) NULL)
1885 {
1886 entry=(DIR *) RelinquishMagickMemory(entry);
1887 return((DIR *) NULL);
1888 }
1889 entry->hSearch=FindFirstFileW(file_specification,&entry->Win32FindData);
1890 if (entry->hSearch == INVALID_HANDLE_VALUE)
1891 {
1892 entry=(DIR *) RelinquishMagickMemory(entry);
1893 return((DIR *) NULL);
1894 }
1895 }
1896 return(entry);
1897 }
1898
1899 /*
1900 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1901 % %
1902 % %
1903 % %
1904 % N T O p e n L i b r a r y %
1905 % %
1906 % %
1907 % %
1908 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1909 %
1910 % NTOpenLibrary() loads a dynamic module into memory and returns a handle that
1911 % can be used to access the various procedures in the module.
1912 %
1913 % The format of the NTOpenLibrary method is:
1914 %
1915 % void *NTOpenLibrary(const char *filename)
1916 %
1917 % A description of each parameter follows:
1918 %
1919 % o path: Specifies a pointer to string representing dynamic module that
1920 % is to be loaded.
1921 %
1922 */
1923
GetSearchPath(void)1924 static inline const char *GetSearchPath(void)
1925 {
1926 #if defined(MAGICKCORE_LTDL_DELEGATE)
1927 return(lt_dlgetsearchpath());
1928 #else
1929 return(lt_slsearchpath);
1930 #endif
1931 }
1932
ChangeErrorMode(void)1933 static UINT ChangeErrorMode(void)
1934 {
1935 typedef UINT
1936 (CALLBACK *GETERRORMODE)(void);
1937
1938 GETERRORMODE
1939 getErrorMode;
1940
1941 HMODULE
1942 handle;
1943
1944 UINT
1945 mode;
1946
1947 mode=SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX;
1948
1949 handle=GetModuleHandle("kernel32.dll");
1950 if (handle == (HMODULE) NULL)
1951 return SetErrorMode(mode);
1952
1953 getErrorMode=(GETERRORMODE) NTGetLibrarySymbol(handle,"GetErrorMode");
1954 if (getErrorMode != (GETERRORMODE) NULL)
1955 mode=getErrorMode() | SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX;
1956
1957 return SetErrorMode(mode);
1958 }
1959
NTLoadLibrary(const char * filename)1960 static inline void *NTLoadLibrary(const char *filename)
1961 {
1962 int
1963 length;
1964
1965 wchar_t
1966 path[MagickPathExtent];
1967
1968 length=MultiByteToWideChar(CP_UTF8,0,filename,-1,path,MagickPathExtent);
1969 if (length == 0)
1970 return((void *) NULL);
1971 return (void *) LoadLibraryExW(path,NULL,LOAD_WITH_ALTERED_SEARCH_PATH);
1972 }
1973
NTOpenLibrary(const char * filename)1974 MagickPrivate void *NTOpenLibrary(const char *filename)
1975 {
1976 char
1977 path[MagickPathExtent];
1978
1979 register const char
1980 *p,
1981 *q;
1982
1983 UINT
1984 mode;
1985
1986 void
1987 *handle;
1988
1989 mode=ChangeErrorMode();
1990 handle=NTLoadLibrary(filename);
1991 if (handle == (void *) NULL)
1992 {
1993 p=GetSearchPath();
1994 while (p != (const char*) NULL)
1995 {
1996 q=strchr(p,DirectoryListSeparator);
1997 if (q != (const char*) NULL)
1998 (void) CopyMagickString(path,p,q-p+1);
1999 else
2000 (void) CopyMagickString(path,p,MagickPathExtent);
2001 (void) ConcatenateMagickString(path,DirectorySeparator,MagickPathExtent);
2002 (void) ConcatenateMagickString(path,filename,MagickPathExtent);
2003 handle=NTLoadLibrary(path);
2004 if (handle != (void *) NULL || q == (const char*) NULL)
2005 break;
2006 p=q+1;
2007 }
2008 }
2009 SetErrorMode(mode);
2010 return(handle);
2011 }
2012
2013 /*
2014 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2015 % %
2016 % %
2017 % %
2018 % N T R e a d D i r e c t o r y %
2019 % %
2020 % %
2021 % %
2022 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2023 %
2024 % NTReadDirectory() returns a pointer to a structure representing the
2025 % directory entry at the current position in the directory stream to which
2026 % entry refers.
2027 %
2028 % The format of the NTReadDirectory
2029 %
2030 % NTReadDirectory(entry)
2031 %
2032 % A description of each parameter follows:
2033 %
2034 % o entry: Specifies a pointer to a DIR structure.
2035 %
2036 */
NTReadDirectory(DIR * entry)2037 MagickPrivate struct dirent *NTReadDirectory(DIR *entry)
2038 {
2039 int
2040 status;
2041
2042 size_t
2043 length;
2044
2045 if (entry == (DIR *) NULL)
2046 return((struct dirent *) NULL);
2047 if (!entry->firsttime)
2048 {
2049 status=FindNextFileW(entry->hSearch,&entry->Win32FindData);
2050 if (status == 0)
2051 return((struct dirent *) NULL);
2052 }
2053 length=WideCharToMultiByte(CP_UTF8,0,entry->Win32FindData.cFileName,-1,
2054 entry->file_info.d_name,sizeof(entry->file_info.d_name),NULL,NULL);
2055 if (length == 0)
2056 return((struct dirent *) NULL);
2057 entry->firsttime=FALSE;
2058 entry->file_info.d_namlen=(int) strlen(entry->file_info.d_name);
2059 return(&entry->file_info);
2060 }
2061
2062 /*
2063 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2064 % %
2065 % %
2066 % %
2067 % N T R e g i s t r y K e y L o o k u p %
2068 % %
2069 % %
2070 % %
2071 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2072 %
2073 % NTRegistryKeyLookup() returns ImageMagick installation path settings
2074 % stored in the Windows Registry. Path settings are specific to the
2075 % installed ImageMagick version so that multiple Image Magick installations
2076 % may coexist.
2077 %
2078 % Values are stored in the registry under a base path path similar to
2079 % "HKEY_LOCAL_MACHINE/SOFTWARE\ImageMagick\6.7.4\Q:16" or
2080 % "HKEY_CURRENT_USER/SOFTWARE\ImageMagick\6.7.4\Q:16". The provided subkey
2081 % is appended to this base path to form the full key.
2082 %
2083 % The format of the NTRegistryKeyLookup method is:
2084 %
2085 % unsigned char *NTRegistryKeyLookup(const char *subkey)
2086 %
2087 % A description of each parameter follows:
2088 %
2089 % o subkey: Specifies a string that identifies the registry object.
2090 % Currently supported sub-keys include: "BinPath", "ConfigurePath",
2091 % "LibPath", "CoderModulesPath", "FilterModulesPath", "SharePath".
2092 %
2093 */
NTRegistryKeyLookup(const char * subkey)2094 MagickPrivate unsigned char *NTRegistryKeyLookup(const char *subkey)
2095 {
2096 char
2097 package_key[MagickPathExtent];
2098
2099 DWORD
2100 size,
2101 type;
2102
2103 HKEY
2104 registry_key;
2105
2106 LONG
2107 status;
2108
2109 unsigned char
2110 *value;
2111
2112 /*
2113 Look-up base key.
2114 */
2115 (void) FormatLocaleString(package_key,MagickPathExtent,
2116 "SOFTWARE\\%s\\%s\\Q:%d",MagickPackageName,MagickLibVersionText,
2117 MAGICKCORE_QUANTUM_DEPTH);
2118 (void) LogMagickEvent(ConfigureEvent,GetMagickModule(),"%s",package_key);
2119 registry_key=(HKEY) INVALID_HANDLE_VALUE;
2120 status=RegOpenKeyExA(HKEY_LOCAL_MACHINE,package_key,0,KEY_READ,®istry_key);
2121 if (status != ERROR_SUCCESS)
2122 status=RegOpenKeyExA(HKEY_CURRENT_USER,package_key,0,KEY_READ,
2123 ®istry_key);
2124 if (status != ERROR_SUCCESS)
2125 return((unsigned char *) NULL);
2126 /*
2127 Look-up sub key.
2128 */
2129 size=32;
2130 value=(unsigned char *) AcquireQuantumMemory(size,sizeof(*value));
2131 if (value == (unsigned char *) NULL)
2132 {
2133 RegCloseKey(registry_key);
2134 return((unsigned char *) NULL);
2135 }
2136 (void) LogMagickEvent(ConfigureEvent,GetMagickModule(),"%s",subkey);
2137 status=RegQueryValueExA(registry_key,subkey,0,&type,value,&size);
2138 if ((status == ERROR_MORE_DATA) && (type == REG_SZ))
2139 {
2140 value=(unsigned char *) ResizeQuantumMemory(value,size,sizeof(*value));
2141 if (value == (BYTE *) NULL)
2142 {
2143 RegCloseKey(registry_key);
2144 return((unsigned char *) NULL);
2145 }
2146 status=RegQueryValueExA(registry_key,subkey,0,&type,value,&size);
2147 }
2148 RegCloseKey(registry_key);
2149 if ((type != REG_SZ) || (status != ERROR_SUCCESS))
2150 value=(unsigned char *) RelinquishMagickMemory(value);
2151 return((unsigned char *) value);
2152 }
2153
2154 /*
2155 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2156 % %
2157 % %
2158 % %
2159 % N T R e p o r t E v e n t %
2160 % %
2161 % %
2162 % %
2163 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2164 %
2165 % NTReportEvent() reports an event.
2166 %
2167 % The format of the NTReportEvent method is:
2168 %
2169 % MagickBooleanType NTReportEvent(const char *event,
2170 % const MagickBooleanType error)
2171 %
2172 % A description of each parameter follows:
2173 %
2174 % o event: the event.
2175 %
2176 % o error: MagickTrue the event is an error.
2177 %
2178 */
NTReportEvent(const char * event,const MagickBooleanType error)2179 MagickPrivate MagickBooleanType NTReportEvent(const char *event,
2180 const MagickBooleanType error)
2181 {
2182 const char
2183 *events[1];
2184
2185 HANDLE
2186 handle;
2187
2188 WORD
2189 type;
2190
2191 handle=RegisterEventSource(NULL,MAGICKCORE_PACKAGE_NAME);
2192 if (handle == NULL)
2193 return(MagickFalse);
2194 events[0]=event;
2195 type=error ? EVENTLOG_ERROR_TYPE : EVENTLOG_WARNING_TYPE;
2196 ReportEvent(handle,type,0,0,NULL,1,0,events,NULL);
2197 DeregisterEventSource(handle);
2198 return(MagickTrue);
2199 }
2200
2201 /*
2202 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2203 % %
2204 % %
2205 % %
2206 % N T R e s o u r c e T o B l o b %
2207 % %
2208 % %
2209 % %
2210 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2211 %
2212 % NTResourceToBlob() returns a blob containing the contents of the resource
2213 % in the current executable specified by the id parameter. This currently
2214 % used to retrieve MGK files tha have been embedded into the various command
2215 % line utilities.
2216 %
2217 % The format of the NTResourceToBlob method is:
2218 %
2219 % unsigned char *NTResourceToBlob(const char *id)
2220 %
2221 % A description of each parameter follows:
2222 %
2223 % o id: Specifies a string that identifies the resource.
2224 %
2225 */
NTResourceToBlob(const char * id)2226 MagickPrivate unsigned char *NTResourceToBlob(const char *id)
2227 {
2228
2229 #ifndef MAGICKCORE_LIBRARY_NAME
2230 char
2231 path[MagickPathExtent];
2232 #endif
2233
2234 DWORD
2235 length;
2236
2237 HGLOBAL
2238 global;
2239
2240 HMODULE
2241 handle;
2242
2243 HRSRC
2244 resource;
2245
2246 unsigned char
2247 *blob,
2248 *value;
2249
2250 assert(id != (const char *) NULL);
2251 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",id);
2252 #ifdef MAGICKCORE_LIBRARY_NAME
2253 handle=GetModuleHandle(MAGICKCORE_LIBRARY_NAME);
2254 #else
2255 (void) FormatLocaleString(path,MagickPathExtent,"%s%s%s",GetClientPath(),
2256 DirectorySeparator,GetClientName());
2257 if (IsPathAccessible(path) != MagickFalse)
2258 handle=GetModuleHandle(path);
2259 else
2260 handle=GetModuleHandle(0);
2261 #endif
2262 if (!handle)
2263 return((unsigned char *) NULL);
2264 resource=FindResource(handle,id,"IMAGEMAGICK");
2265 if (!resource)
2266 return((unsigned char *) NULL);
2267 global=LoadResource(handle,resource);
2268 if (!global)
2269 return((unsigned char *) NULL);
2270 length=SizeofResource(handle,resource);
2271 value=(unsigned char *) LockResource(global);
2272 if (!value)
2273 {
2274 FreeResource(global);
2275 return((unsigned char *) NULL);
2276 }
2277 blob=(unsigned char *) AcquireQuantumMemory(length+MagickPathExtent,
2278 sizeof(*blob));
2279 if (blob != (unsigned char *) NULL)
2280 {
2281 (void) memcpy(blob,value,length);
2282 blob[length]='\0';
2283 }
2284 UnlockResource(global);
2285 FreeResource(global);
2286 return(blob);
2287 }
2288
2289 /*
2290 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2291 % %
2292 % %
2293 % %
2294 % N T S e e k D i r e c t o r y %
2295 % %
2296 % %
2297 % %
2298 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2299 %
2300 % NTSeekDirectory() sets the position of the next NTReadDirectory() operation
2301 % on the directory stream.
2302 %
2303 % The format of the NTSeekDirectory method is:
2304 %
2305 % void NTSeekDirectory(DIR *entry,ssize_t position)
2306 %
2307 % A description of each parameter follows:
2308 %
2309 % o entry: Specifies a pointer to a DIR structure.
2310 %
2311 % o position: specifies the position associated with the directory
2312 % stream.
2313 %
2314 */
NTSeekDirectory(DIR * entry,ssize_t position)2315 MagickPrivate void NTSeekDirectory(DIR *entry,ssize_t position)
2316 {
2317 (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2318 assert(entry != (DIR *) NULL);
2319 (void) entry;
2320 (void) position;
2321 }
2322
2323 /*
2324 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2325 % %
2326 % %
2327 % %
2328 % N T S e t S e a r c h P a t h %
2329 % %
2330 % %
2331 % %
2332 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2333 %
2334 % NTSetSearchPath() sets the current locations that the subsystem should
2335 % look at to find dynamically loadable modules.
2336 %
2337 % The format of the NTSetSearchPath method is:
2338 %
2339 % int NTSetSearchPath(const char *path)
2340 %
2341 % A description of each parameter follows:
2342 %
2343 % o path: Specifies a pointer to string representing the search path
2344 % for DLL's that can be dynamically loaded.
2345 %
2346 */
NTSetSearchPath(const char * path)2347 MagickPrivate int NTSetSearchPath(const char *path)
2348 {
2349 #if defined(MAGICKCORE_LTDL_DELEGATE)
2350 lt_dlsetsearchpath(path);
2351 #else
2352 if (lt_slsearchpath != (char *) NULL)
2353 lt_slsearchpath=DestroyString(lt_slsearchpath);
2354 if (path != (char *) NULL)
2355 lt_slsearchpath=AcquireString(path);
2356 #endif
2357 return(0);
2358 }
2359
2360 /*
2361 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2362 % %
2363 % %
2364 % %
2365 + N T S y n c M e m o r y %
2366 % %
2367 % %
2368 % %
2369 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2370 %
2371 % NTSyncMemory() emulates the Unix method of the same name.
2372 %
2373 % The format of the NTSyncMemory method is:
2374 %
2375 % int NTSyncMemory(void *address,size_t length,int flags)
2376 %
2377 % A description of each parameter follows:
2378 %
2379 % o address: the address of the binary large object.
2380 %
2381 % o length: the length of the binary large object.
2382 %
2383 % o flags: Option flags (ignored for Windows).
2384 %
2385 */
NTSyncMemory(void * address,size_t length,int flags)2386 MagickPrivate int NTSyncMemory(void *address,size_t length,int flags)
2387 {
2388 (void) flags;
2389 if (FlushViewOfFile(address,length) == MagickFalse)
2390 return(-1);
2391 return(0);
2392 }
2393
2394 /*
2395 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2396 % %
2397 % %
2398 % %
2399 % N T S y s t e m C o m m a n d %
2400 % %
2401 % %
2402 % %
2403 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2404 %
2405 % NTSystemCommand() executes the specified command and waits until it
2406 % terminates. The returned value is the exit status of the command.
2407 %
2408 % The format of the NTSystemCommand method is:
2409 %
2410 % int NTSystemCommand(MagickFalse,const char *command)
2411 %
2412 % A description of each parameter follows:
2413 %
2414 % o command: This string is the command to execute.
2415 %
2416 % o output: an optional buffer to store the output from stderr/stdout.
2417 %
2418 */
NTSystemCommand(const char * command,char * output)2419 MagickPrivate int NTSystemCommand(const char *command,char *output)
2420 {
2421 #define CleanupOutputHandles \
2422 if (read_output != (HANDLE) NULL) \
2423 { \
2424 CloseHandle(read_output); \
2425 read_output=(HANDLE) NULL; \
2426 CloseHandle(write_output); \
2427 write_output=(HANDLE) NULL; \
2428 }
2429
2430 #define CopyLastError \
2431 if (output != (char *) NULL) \
2432 { \
2433 error=NTGetLastError(); \
2434 if (error != (char *) NULL) \
2435 { \
2436 CopyMagickString(output,error,MagickPathExtent); \
2437 error=DestroyString(error); \
2438 } \
2439 }
2440
2441 char
2442 *error,
2443 local_command[MagickPathExtent];
2444
2445 DWORD
2446 bytes_read,
2447 child_status,
2448 size;
2449
2450 int
2451 status;
2452
2453 MagickBooleanType
2454 asynchronous;
2455
2456 HANDLE
2457 read_output,
2458 write_output;
2459
2460 PROCESS_INFORMATION
2461 process_info;
2462
2463 SECURITY_ATTRIBUTES
2464 sa;
2465
2466 STARTUPINFO
2467 startup_info;
2468
2469 if (command == (char *) NULL)
2470 return(-1);
2471 read_output=(HANDLE) NULL;
2472 write_output=(HANDLE) NULL;
2473 GetStartupInfo(&startup_info);
2474 startup_info.dwFlags=STARTF_USESHOWWINDOW;
2475 startup_info.wShowWindow=SW_SHOWMINNOACTIVE;
2476 (void) CopyMagickString(local_command,command,MagickPathExtent);
2477 asynchronous=command[strlen(command)-1] == '&' ? MagickTrue : MagickFalse;
2478 if (asynchronous != MagickFalse)
2479 {
2480 local_command[strlen(command)-1]='\0';
2481 startup_info.wShowWindow=SW_SHOWDEFAULT;
2482 }
2483 else
2484 {
2485 if (command[strlen(command)-1] == '|')
2486 local_command[strlen(command)-1]='\0';
2487 else
2488 startup_info.wShowWindow=SW_HIDE;
2489 read_output=(HANDLE) NULL;
2490 if (output != (char *) NULL)
2491 {
2492 sa.nLength=sizeof(SECURITY_ATTRIBUTES);
2493 sa.bInheritHandle=TRUE;
2494 sa.lpSecurityDescriptor=NULL;
2495 if (CreatePipe(&read_output,&write_output,NULL,0))
2496 {
2497 if (SetHandleInformation(write_output,HANDLE_FLAG_INHERIT,
2498 HANDLE_FLAG_INHERIT))
2499 {
2500 startup_info.dwFlags|=STARTF_USESTDHANDLES;
2501 startup_info.hStdOutput=write_output;
2502 startup_info.hStdError=write_output;
2503 }
2504 else
2505 CleanupOutputHandles;
2506 }
2507 else
2508 read_output=(HANDLE) NULL;
2509 }
2510 }
2511 status=CreateProcess((LPCTSTR) NULL,local_command,(LPSECURITY_ATTRIBUTES)
2512 NULL,(LPSECURITY_ATTRIBUTES) NULL,(BOOL) TRUE,(DWORD)
2513 NORMAL_PRIORITY_CLASS,(LPVOID) NULL,(LPCSTR) NULL,&startup_info,
2514 &process_info);
2515 if (status == 0)
2516 {
2517 CopyLastError;
2518 CleanupOutputHandles;
2519 return(-1);
2520 }
2521 if (asynchronous != MagickFalse)
2522 return(status == 0);
2523 status=WaitForSingleObject(process_info.hProcess,INFINITE);
2524 if (status != WAIT_OBJECT_0)
2525 {
2526 CopyLastError;
2527 CleanupOutputHandles;
2528 return(status);
2529 }
2530 status=GetExitCodeProcess(process_info.hProcess,&child_status);
2531 if (status == 0)
2532 {
2533 CopyLastError;
2534 CleanupOutputHandles;
2535 return(-1);
2536 }
2537 CloseHandle(process_info.hProcess);
2538 CloseHandle(process_info.hThread);
2539 if (read_output != (HANDLE) NULL)
2540 if (PeekNamedPipe(read_output,(LPVOID) NULL,0,(LPDWORD) NULL,&size,(LPDWORD) NULL))
2541 if ((size > 0) && (ReadFile(read_output,output,MagickPathExtent-1,&bytes_read,NULL)))
2542 output[bytes_read]='\0';
2543 CleanupOutputHandles;
2544 return((int) child_status);
2545 }
2546
2547 /*
2548 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2549 % %
2550 % %
2551 % %
2552 % N T S y s t e m C o n i f i g u r a t i o n %
2553 % %
2554 % %
2555 % %
2556 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2557 %
2558 % NTSystemConfiguration() provides a way for the application to determine
2559 % values for system limits or options at runtime.
2560 %
2561 % The format of the exit method is:
2562 %
2563 % ssize_t NTSystemConfiguration(int name)
2564 %
2565 % A description of each parameter follows:
2566 %
2567 % o name: _SC_PAGE_SIZE or _SC_PHYS_PAGES.
2568 %
2569 */
NTSystemConfiguration(int name)2570 MagickPrivate ssize_t NTSystemConfiguration(int name)
2571 {
2572 switch (name)
2573 {
2574 case _SC_PAGESIZE:
2575 {
2576 SYSTEM_INFO
2577 system_info;
2578
2579 GetSystemInfo(&system_info);
2580 return(system_info.dwPageSize);
2581 }
2582 case _SC_PHYS_PAGES:
2583 {
2584 HMODULE
2585 handle;
2586
2587 LPFNDLLFUNC2
2588 module;
2589
2590 NTMEMORYSTATUSEX
2591 status;
2592
2593 SYSTEM_INFO
2594 system_info;
2595
2596 handle=GetModuleHandle("kernel32.dll");
2597 if (handle == (HMODULE) NULL)
2598 return(0L);
2599 GetSystemInfo(&system_info);
2600 module=(LPFNDLLFUNC2) NTGetLibrarySymbol(handle,"GlobalMemoryStatusEx");
2601 if (module == (LPFNDLLFUNC2) NULL)
2602 {
2603 MEMORYSTATUS
2604 global_status;
2605
2606 GlobalMemoryStatus(&global_status);
2607 return((ssize_t) global_status.dwTotalPhys/system_info.dwPageSize/4);
2608 }
2609 status.dwLength=sizeof(status);
2610 if (module(&status) == 0)
2611 return(0L);
2612 return((ssize_t) status.ullTotalPhys/system_info.dwPageSize/4);
2613 }
2614 case _SC_OPEN_MAX:
2615 return(2048);
2616 default:
2617 break;
2618 }
2619 return(-1);
2620 }
2621
2622 /*
2623 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2624 % %
2625 % %
2626 % %
2627 % N T T e l l D i r e c t o r y %
2628 % %
2629 % %
2630 % %
2631 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2632 %
2633 % NTTellDirectory() returns the current location associated with the named
2634 % directory stream.
2635 %
2636 % The format of the NTTellDirectory method is:
2637 %
2638 % ssize_t NTTellDirectory(DIR *entry)
2639 %
2640 % A description of each parameter follows:
2641 %
2642 % o entry: Specifies a pointer to a DIR structure.
2643 %
2644 */
NTTellDirectory(DIR * entry)2645 MagickPrivate ssize_t NTTellDirectory(DIR *entry)
2646 {
2647 magick_unreferenced(entry);
2648 assert(entry != (DIR *) NULL);
2649 return(0);
2650 }
2651
2652 /*
2653 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2654 % %
2655 % %
2656 % %
2657 % N T T r u n c a t e F i l e %
2658 % %
2659 % %
2660 % %
2661 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2662 %
2663 % NTTruncateFile() truncates a file to a specified length.
2664 %
2665 % The format of the NTTruncateFile method is:
2666 %
2667 % int NTTruncateFile(int file,off_t length)
2668 %
2669 % A description of each parameter follows:
2670 %
2671 % o file: the file.
2672 %
2673 % o length: the file length.
2674 %
2675 */
NTTruncateFile(int file,off_t length)2676 MagickPrivate int NTTruncateFile(int file,off_t length)
2677 {
2678 DWORD
2679 file_pointer;
2680
2681 HANDLE
2682 file_handle;
2683
2684 long
2685 high,
2686 low;
2687
2688 file_handle=(HANDLE) _get_osfhandle(file);
2689 if (file_handle == INVALID_HANDLE_VALUE)
2690 return(-1);
2691 low=(long) (length & 0xffffffffUL);
2692 high=(long) ((((MagickOffsetType) length) >> 32) & 0xffffffffUL);
2693 file_pointer=SetFilePointer(file_handle,low,&high,FILE_BEGIN);
2694 if ((file_pointer == 0xFFFFFFFF) && (GetLastError() != NO_ERROR))
2695 return(-1);
2696 if (SetEndOfFile(file_handle) == 0)
2697 return(-1);
2698 return(0);
2699 }
2700
2701 /*
2702 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2703 % %
2704 % %
2705 % %
2706 + N T U n m a p M e m o r y %
2707 % %
2708 % %
2709 % %
2710 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2711 %
2712 % NTUnmapMemory() emulates the Unix munmap method.
2713 %
2714 % The format of the NTUnmapMemory method is:
2715 %
2716 % int NTUnmapMemory(void *map,size_t length)
2717 %
2718 % A description of each parameter follows:
2719 %
2720 % o map: the address of the binary large object.
2721 %
2722 % o length: the length of the binary large object.
2723 %
2724 */
NTUnmapMemory(void * map,size_t length)2725 MagickPrivate int NTUnmapMemory(void *map,size_t length)
2726 {
2727 (void) length;
2728 if (UnmapViewOfFile(map) == 0)
2729 return(-1);
2730 return(0);
2731 }
2732
2733 /*
2734 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2735 % %
2736 % %
2737 % %
2738 % N T U s e r T i m e %
2739 % %
2740 % %
2741 % %
2742 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2743 %
2744 % NTUserTime() returns the total time the process has been scheduled (e.g.
2745 % seconds) since the last call to StartTimer().
2746 %
2747 % The format of the UserTime method is:
2748 %
2749 % double NTUserTime(void)
2750 %
2751 */
NTUserTime(void)2752 MagickPrivate double NTUserTime(void)
2753 {
2754 DWORD
2755 status;
2756
2757 FILETIME
2758 create_time,
2759 exit_time;
2760
2761 OSVERSIONINFO
2762 OsVersionInfo;
2763
2764 union
2765 {
2766 FILETIME
2767 filetime;
2768
2769 __int64
2770 filetime64;
2771 } kernel_time;
2772
2773 union
2774 {
2775 FILETIME
2776 filetime;
2777
2778 __int64
2779 filetime64;
2780 } user_time;
2781
2782 OsVersionInfo.dwOSVersionInfoSize=sizeof(OSVERSIONINFO);
2783 GetVersionEx(&OsVersionInfo);
2784 if (OsVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT)
2785 return(NTElapsedTime());
2786 status=GetProcessTimes(GetCurrentProcess(),&create_time,&exit_time,
2787 &kernel_time.filetime,&user_time.filetime);
2788 if (status != TRUE)
2789 return(0.0);
2790 return((double) 1.0e-7*(kernel_time.filetime64+user_time.filetime64));
2791 }
2792
2793 /*
2794 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2795 % %
2796 % %
2797 % %
2798 % N T W a r n i n g H a n d l e r %
2799 % %
2800 % %
2801 % %
2802 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2803 %
2804 % NTWarningHandler() displays a warning reason.
2805 %
2806 % The format of the NTWarningHandler method is:
2807 %
2808 % void NTWarningHandler(const ExceptionType severity,const char *reason,
2809 % const char *description)
2810 %
2811 % A description of each parameter follows:
2812 %
2813 % o severity: Specifies the numeric warning category.
2814 %
2815 % o reason: Specifies the reason to display before terminating the
2816 % program.
2817 %
2818 % o description: Specifies any description to the reason.
2819 %
2820 */
NTWarningHandler(const ExceptionType severity,const char * reason,const char * description)2821 MagickPrivate void NTWarningHandler(const ExceptionType severity,
2822 const char *reason,const char *description)
2823 {
2824 char
2825 buffer[2*MagickPathExtent];
2826
2827 (void) severity;
2828 if (reason == (char *) NULL)
2829 return;
2830 if (description == (char *) NULL)
2831 (void) FormatLocaleString(buffer,MagickPathExtent,"%s: %s.\n",GetClientName(),
2832 reason);
2833 else
2834 (void) FormatLocaleString(buffer,MagickPathExtent,"%s: %s (%s).\n",
2835 GetClientName(),reason,description);
2836 (void) MessageBox(NULL,buffer,"ImageMagick Warning",MB_OK | MB_TASKMODAL |
2837 MB_SETFOREGROUND | MB_ICONINFORMATION);
2838 }
2839
2840 /*
2841 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2842 % %
2843 % %
2844 % %
2845 % N T W i n d o w s G e n e s i s %
2846 % %
2847 % %
2848 % %
2849 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2850 %
2851 % NTWindowsGenesis() initializes the MagickCore Windows environment.
2852 %
2853 % The format of the NTWindowsGenesis method is:
2854 %
2855 % void NTWindowsGenesis(void)
2856 %
2857 */
2858
NTUncaughtException(EXCEPTION_POINTERS * info)2859 static LONG WINAPI NTUncaughtException(EXCEPTION_POINTERS *info)
2860 {
2861 magick_unreferenced(info);
2862 AsynchronousResourceComponentTerminus();
2863 return(EXCEPTION_CONTINUE_SEARCH);
2864 }
2865
NTWindowsGenesis(void)2866 MagickPrivate void NTWindowsGenesis(void)
2867 {
2868 char
2869 *mode;
2870
2871 SetUnhandledExceptionFilter(NTUncaughtException);
2872 mode=GetEnvironmentValue("MAGICK_ERRORMODE");
2873 if (mode != (char *) NULL)
2874 {
2875 (void) SetErrorMode(StringToInteger(mode));
2876 mode=DestroyString(mode);
2877 }
2878 #if defined(_DEBUG) && !defined(__BORLANDC__) && !defined(__MINGW32__)
2879 if (IsEventLogging() != MagickFalse)
2880 {
2881 int
2882 debug;
2883
2884 debug=_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
2885 //debug |= _CRTDBG_CHECK_ALWAYS_DF;
2886 debug |= _CRTDBG_DELAY_FREE_MEM_DF;
2887 debug |= _CRTDBG_LEAK_CHECK_DF;
2888 (void) _CrtSetDbgFlag(debug);
2889
2890 //_ASSERTE(_CrtCheckMemory());
2891
2892 //_CrtSetBreakAlloc(42);
2893 }
2894 #endif
2895 #if defined(MAGICKCORE_INSTALLED_SUPPORT)
2896 {
2897 unsigned char
2898 *path;
2899
2900 path=NTRegistryKeyLookup("LibPath");
2901 if (path != (unsigned char *) NULL)
2902 {
2903 size_t
2904 length;
2905
2906 wchar_t
2907 lib_path[MagickPathExtent];
2908
2909 length=MultiByteToWideChar(CP_UTF8,0,(char *) path,-1,lib_path,
2910 MagickPathExtent);
2911 if (length != 0)
2912 SetDllDirectoryW(lib_path);
2913 path=(unsigned char *) RelinquishMagickMemory(path);
2914 }
2915 }
2916 #endif
2917 }
2918
2919 /*
2920 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2921 % %
2922 % %
2923 % %
2924 % N T W i n d o w s T e r m i n u s %
2925 % %
2926 % %
2927 % %
2928 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2929 %
2930 % NTWindowsTerminus() terminates the MagickCore Windows environment.
2931 %
2932 % The format of the NTWindowsTerminus method is:
2933 %
2934 % void NTWindowsTerminus(void)
2935 %
2936 */
NTWindowsTerminus(void)2937 MagickPrivate void NTWindowsTerminus(void)
2938 {
2939 NTGhostscriptUnLoadDLL();
2940 if (winsock_semaphore == (SemaphoreInfo *) NULL)
2941 ActivateSemaphoreInfo(&winsock_semaphore);
2942 LockSemaphoreInfo(winsock_semaphore);
2943 if (wsaData != (WSADATA *) NULL)
2944 {
2945 WSACleanup();
2946 wsaData=(WSADATA *) RelinquishMagickMemory((void *) wsaData);
2947 }
2948 UnlockSemaphoreInfo(winsock_semaphore);
2949 RelinquishSemaphoreInfo(&winsock_semaphore);
2950 }
2951 #endif
2952