granicus.if.org Git - imagemagick/blob - MagickCore/nt-base.c

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