/* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % U U TTTTT IIIII L IIIII TTTTT Y Y % % U U T I L I T Y Y % % U U T I L I T Y % % U U T I L I T Y % % UUU T IIIII LLLLL IIIII T Y % % % % % % MagickCore Utility Methods % % % % Software Design % % Cristy % % January 1993 % % % % % % Copyright 1999-2019 ImageMagick Studio LLC, a non-profit organization % % dedicated to making software imaging solutions freely available. % % % % You may not use this file except in compliance with the License. You may % % obtain a copy of the License at % % % % https://imagemagick.org/script/license.php % % % % Unless required by applicable law or agreed to in writing, software % % distributed under the License is distributed on an "AS IS" BASIS, % % WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. % % See the License for the specific language governing permissions and % % limitations under the License. % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % */ /* Include declarations. */ #include "MagickCore/studio.h" #include "MagickCore/property.h" #include "MagickCore/blob.h" #include "MagickCore/color.h" #include "MagickCore/exception.h" #include "MagickCore/exception-private.h" #include "MagickCore/geometry.h" #include "MagickCore/image-private.h" #include "MagickCore/list.h" #include "MagickCore/log.h" #include "MagickCore/magick-private.h" #include "MagickCore/memory_.h" #include "MagickCore/nt-base-private.h" #include "MagickCore/option.h" #include "MagickCore/policy.h" #include "MagickCore/random_.h" #include "MagickCore/registry.h" #include "MagickCore/resource_.h" #include "MagickCore/semaphore.h" #include "MagickCore/signature-private.h" #include "MagickCore/statistic.h" #include "MagickCore/string_.h" #include "MagickCore/string-private.h" #include "MagickCore/token.h" #include "MagickCore/token-private.h" #include "MagickCore/utility.h" #include "MagickCore/utility-private.h" #if defined(MAGICKCORE_HAVE_PROCESS_H) #include #endif #if defined(MAGICKCORE_HAVE_MACH_O_DYLD_H) #include #endif /* Static declarations. */ static const char Base64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; /* Forward declaration. */ static int IsPathDirectory(const char *); /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % A c q u i r e U n i q u e F i l e n a m e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % AcquireUniqueFilename() replaces the contents of path by a unique path name. % % The format of the AcquireUniqueFilename method is: % % MagickBooleanType AcquireUniqueFilename(char *path) % % A description of each parameter follows. % % o path: Specifies a pointer to an array of characters. The unique path % name is returned in this array. % */ MagickExport MagickBooleanType AcquireUniqueFilename(char *path) { int file; file=AcquireUniqueFileResource(path); if (file == -1) return(MagickFalse); file=close(file)-1; return(MagickTrue); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % A c q u i r e U n i q u e S ym b o l i c L i n k % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % AcquireUniqueSymbolicLink() creates a unique symbolic link to the specified % source path and returns MagickTrue on success otherwise MagickFalse. If the % symlink() method fails or is not available, a unique file name is generated % and the source file copied to it. When you are finished with the file, use % RelinquishUniqueFilename() to destroy it. % % The format of the AcquireUniqueSymbolicLink method is: % % MagickBooleanType AcquireUniqueSymbolicLink(const char *source, % char destination) % % A description of each parameter follows. % % o source: the source path. % % o destination: the destination path. % */ MagickExport MagickBooleanType AcquireUniqueSymbolicLink(const char *source, char *destination) { int destination_file, source_file; MagickBooleanType status; size_t length, quantum; ssize_t count; struct stat attributes; unsigned char *buffer; assert(source != (const char *) NULL); assert(destination != (char *) NULL); #if defined(MAGICKCORE_HAVE_SYMLINK) { char *passes; (void) AcquireUniqueFilename(destination); (void) RelinquishUniqueFileResource(destination); passes=GetPolicyValue("system:shred"); if (passes != (char *) NULL) passes=DestroyString(passes); else { if (*source == *DirectorySeparator) { if (symlink(source,destination) == 0) return(MagickTrue); } else { char path[MagickPathExtent]; *path='\0'; if (getcwd(path,MagickPathExtent) == (char *) NULL) return(MagickFalse); (void) ConcatenateMagickString(path,DirectorySeparator, MagickPathExtent); (void) ConcatenateMagickString(path,source,MagickPathExtent); if (symlink(path,destination) == 0) return(MagickTrue); } } } #endif destination_file=AcquireUniqueFileResource(destination); if (destination_file == -1) return(MagickFalse); source_file=open_utf8(source,O_RDONLY | O_BINARY,0); if (source_file == -1) { (void) close(destination_file); (void) RelinquishUniqueFileResource(destination); return(MagickFalse); } quantum=(size_t) MagickMaxBufferExtent; if ((fstat(source_file,&attributes) == 0) && (attributes.st_size > 0)) quantum=(size_t) MagickMin(attributes.st_size,MagickMaxBufferExtent); buffer=(unsigned char *) AcquireQuantumMemory(quantum,sizeof(*buffer)); if (buffer == (unsigned char *) NULL) { (void) close(source_file); (void) close(destination_file); (void) RelinquishUniqueFileResource(destination); return(MagickFalse); } status=MagickTrue; for (length=0; ; ) { count=(ssize_t) read(source_file,buffer,quantum); if (count <= 0) break; length=(size_t) count; count=(ssize_t) write(destination_file,buffer,length); if ((size_t) count != length) { (void) RelinquishUniqueFileResource(destination); status=MagickFalse; break; } } (void) close(destination_file); (void) close(source_file); buffer=(unsigned char *) RelinquishMagickMemory(buffer); return(status); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % A p p e n d I m a g e F o r m a t % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % AppendImageFormat() appends the image format type to the filename. If an % extension to the file already exists, it is first removed. % % The format of the AppendImageFormat method is: % % void AppendImageFormat(const char *format,char *filename) % % A description of each parameter follows. % % o format: Specifies a pointer to an array of characters. This the % format of the image. % % o filename: Specifies a pointer to an array of characters. The unique % file name is returned in this array. % */ MagickExport void AppendImageFormat(const char *format,char *filename) { char extension[MagickPathExtent], root[MagickPathExtent]; assert(format != (char *) NULL); assert(filename != (char *) NULL); (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",filename); if ((*format == '\0') || (*filename == '\0')) return; if (LocaleCompare(filename,"-") == 0) { char message[MagickPathExtent]; (void) FormatLocaleString(message,MagickPathExtent,"%s:%s",format, filename); (void) CopyMagickString(filename,message,MagickPathExtent); return; } GetPathComponent(filename,ExtensionPath,extension); if ((LocaleCompare(extension,"Z") == 0) || (LocaleCompare(extension,"bz2") == 0) || (LocaleCompare(extension,"gz") == 0) || (LocaleCompare(extension,"wmz") == 0) || (LocaleCompare(extension,"svgz") == 0)) { GetPathComponent(filename,RootPath,root); (void) CopyMagickString(filename,root,MagickPathExtent); GetPathComponent(filename,RootPath,root); (void) FormatLocaleString(filename,MagickPathExtent,"%s.%s.%s",root, format,extension); return; } GetPathComponent(filename,RootPath,root); (void) FormatLocaleString(filename,MagickPathExtent,"%s.%s",root,format); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % B a s e 6 4 D e c o d e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % Base64Decode() decodes Base64-encoded text and returns its binary % equivalent. NULL is returned if the text is not valid Base64 data, or a % memory allocation failure occurs. % % The format of the Base64Decode method is: % % unsigned char *Base64Decode(const char *source,length_t *length) % % A description of each parameter follows: % % o source: A pointer to a Base64-encoded string. % % o length: the number of bytes decoded. % */ MagickExport unsigned char *Base64Decode(const char *source,size_t *length) { int state; register const char *p, *q; register size_t i; unsigned char *decode; (void) LogMagickEvent(TraceEvent,GetMagickModule(),"..."); assert(source != (char *) NULL); assert(length != (size_t *) NULL); *length=0; decode=(unsigned char *) AcquireQuantumMemory((strlen(source)+3)/4, 3*sizeof(*decode)); if (decode == (unsigned char *) NULL) return((unsigned char *) NULL); i=0; state=0; for (p=source; *p != '\0'; p++) { if (isspace((int) ((unsigned char) *p)) != 0) continue; if (*p == '=') break; q=strchr(Base64,*p); if (q == (char *) NULL) { decode=(unsigned char *) RelinquishMagickMemory(decode); return((unsigned char *) NULL); /* non-Base64 character */ } switch (state) { case 0: { decode[i]=(q-Base64) << 2; state++; break; } case 1: { decode[i++]|=(q-Base64) >> 4; decode[i]=((q-Base64) & 0x0f) << 4; state++; break; } case 2: { decode[i++]|=(q-Base64) >> 2; decode[i]=((q-Base64) & 0x03) << 6; state++; break; } case 3: { decode[i++]|=(q-Base64); state=0; break; } } } /* Verify Base-64 string has proper terminal characters. */ if (*p != '=') { if (state != 0) { decode=(unsigned char *) RelinquishMagickMemory(decode); return((unsigned char *) NULL); } } else { p++; switch (state) { case 0: case 1: { /* Unrecognized '=' character. */ decode=(unsigned char *) RelinquishMagickMemory(decode); return((unsigned char *) NULL); } case 2: { for ( ; *p != '\0'; p++) if (isspace((int) ((unsigned char) *p)) == 0) break; if (*p != '=') { decode=(unsigned char *) RelinquishMagickMemory(decode); return((unsigned char *) NULL); } p++; } case 3: { for ( ; *p != '\0'; p++) if (isspace((int) ((unsigned char) *p)) == 0) { decode=(unsigned char *) RelinquishMagickMemory(decode); return((unsigned char *) NULL); } if ((int) decode[i] != 0) { decode=(unsigned char *) RelinquishMagickMemory(decode); return((unsigned char *) NULL); } break; } } } *length=i; return(decode); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % B a s e 6 4 E n c o d e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % Base64Encode() encodes arbitrary binary data to Base64 encoded format as % described by the "Base64 Content-Transfer-Encoding" section of RFC 2045 and % returns the result as a null-terminated ASCII string. NULL is returned if % a memory allocation failure occurs. % % The format of the Base64Encode method is: % % char *Base64Encode(const unsigned char *blob,const size_t blob_length, % size_t *encode_length) % % A description of each parameter follows: % % o blob: A pointer to binary data to encode. % % o blob_length: the number of bytes to encode. % % o encode_length: The number of bytes encoded. % */ MagickExport char *Base64Encode(const unsigned char *blob, const size_t blob_length,size_t *encode_length) { char *encode; register const unsigned char *p; register size_t i; size_t remainder; (void) LogMagickEvent(TraceEvent,GetMagickModule(),"..."); assert(blob != (const unsigned char *) NULL); assert(blob_length != 0); assert(encode_length != (size_t *) NULL); *encode_length=0; encode=(char *) AcquireQuantumMemory(blob_length/3+4,4*sizeof(*encode)); if (encode == (char *) NULL) return((char *) NULL); i=0; for (p=blob; p < (blob+blob_length-2); p+=3) { encode[i++]=Base64[(int) (*p >> 2)]; encode[i++]=Base64[(int) (((*p & 0x03) << 4)+(*(p+1) >> 4))]; encode[i++]=Base64[(int) (((*(p+1) & 0x0f) << 2)+(*(p+2) >> 6))]; encode[i++]=Base64[(int) (*(p+2) & 0x3f)]; } remainder=blob_length % 3; if (remainder != 0) { ssize_t j; unsigned char code[3]; code[0]='\0'; code[1]='\0'; code[2]='\0'; for (j=0; j < (ssize_t) remainder; j++) code[j]=(*p++); encode[i++]=Base64[(int) (code[0] >> 2)]; encode[i++]=Base64[(int) (((code[0] & 0x03) << 4)+(code[1] >> 4))]; if (remainder == 1) encode[i++]='='; else encode[i++]=Base64[(int) (((code[1] & 0x0f) << 2)+(code[2] >> 6))]; encode[i++]='='; } *encode_length=i; encode[i++]='\0'; return(encode); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % C h o p P a t h C o m p o n e n t s % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % ChopPathComponents() removes the number of specified file components from a % path. % % The format of the ChopPathComponents method is: % % ChopPathComponents(char *path,size_t components) % % A description of each parameter follows: % % o path: The path. % % o components: The number of components to chop. % */ MagickPrivate void ChopPathComponents(char *path,const size_t components) { register ssize_t i; for (i=0; i < (ssize_t) components; i++) GetPathComponent(path,HeadPath,path); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % E x p a n d F i l e n a m e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % ExpandFilename() expands '~' in a path. % % The format of the ExpandFilename function is: % % ExpandFilename(char *path) % % A description of each parameter follows: % % o path: Specifies a pointer to a character array that contains the % path. % */ MagickPrivate void ExpandFilename(char *path) { char expand_path[MagickPathExtent]; if (path == (char *) NULL) return; if (*path != '~') return; (void) CopyMagickString(expand_path,path,MagickPathExtent); if ((*(path+1) == *DirectorySeparator) || (*(path+1) == '\0')) { char *home; /* Substitute ~ with $HOME. */ (void) CopyMagickString(expand_path,".",MagickPathExtent); (void) ConcatenateMagickString(expand_path,path+1,MagickPathExtent); home=GetEnvironmentValue("HOME"); if (home == (char *) NULL) home=GetEnvironmentValue("USERPROFILE"); if (home != (char *) NULL) { (void) CopyMagickString(expand_path,home,MagickPathExtent); (void) ConcatenateMagickString(expand_path,path+1,MagickPathExtent); home=DestroyString(home); } } else { #if defined(MAGICKCORE_POSIX_SUPPORT) && !defined(__OS2__) char username[MagickPathExtent]; register char *p; struct passwd *entry; /* Substitute ~ with home directory from password file. */ (void) CopyMagickString(username,path+1,MagickPathExtent); p=strchr(username,'/'); if (p != (char *) NULL) *p='\0'; entry=getpwnam(username); if (entry == (struct passwd *) NULL) return; (void) CopyMagickString(expand_path,entry->pw_dir,MagickPathExtent); if (p != (char *) NULL) { (void) ConcatenateMagickString(expand_path,"/",MagickPathExtent); (void) ConcatenateMagickString(expand_path,p+1,MagickPathExtent); } #endif } (void) CopyMagickString(path,expand_path,MagickPathExtent); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % E x p a n d F i l e n a m e s % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % ExpandFilenames() checks each argument of the given argument array, and % expands it if they have a wildcard character. % % Any coder prefix (EG: 'coder:filename') or read modifier postfix (EG: % 'filename[...]') are ignored during the file the expansion, but will be % included in the final argument. If no filename matching the meta-character % 'glob' is found the original argument is returned. % % For example, an argument of '*.gif[20x20]' will be replaced by the list % 'abc.gif[20x20]', 'foobar.gif[20x20]', 'xyzzy.gif[20x20]' % if such filenames exist, (in the current directory in this case). % % Meta-characters handled... % @ read a list of filenames (no further expansion performed) % ~ At start of filename expands to HOME environemtn variable % * matches any string including an empty string % ? matches by any single character % % WARNING: filenames starting with '.' (hidden files in a UNIX file system) % will never be expanded. Attempting to epand '.*' will produce no change. % % Expansion is ignored for coders "label:" "caption:" "pango:" and "vid:". % Which provide their own '@' meta-character handling. % % You can see the results of the expansion using "Configure" log events. % % The returned list should be freed using DestroyStringList(). % % However the strings in the original pointed to argv are not % freed (TO BE CHECKED). So a copy of the original pointer (and count) % should be kept separate if they need to be freed later. % % The format of the ExpandFilenames function is: % % status=ExpandFilenames(int *number_arguments,char ***arguments) % % A description of each parameter follows: % % o number_arguments: Specifies a pointer to an integer describing the % number of elements in the argument vector. % % o arguments: Specifies a pointer to a text array containing the command % line arguments. % */ MagickExport MagickBooleanType ExpandFilenames(int *number_arguments, char ***arguments) { char home_directory[MagickPathExtent], **vector; register ssize_t i, j; size_t number_files; ssize_t count, parameters; /* Allocate argument vector. */ (void) LogMagickEvent(TraceEvent,GetMagickModule(),"..."); assert(number_arguments != (int *) NULL); assert(arguments != (char ***) NULL); vector=(char **) AcquireQuantumMemory((size_t) (*number_arguments+1), sizeof(*vector)); if (vector == (char **) NULL) ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed"); /* Expand any wildcard filenames. */ *home_directory='\0'; count=0; for (i=0; i < (ssize_t) *number_arguments; i++) { char **filelist, filename[MagickPathExtent], magick[MagickPathExtent], *option, path[MagickPathExtent], subimage[MagickPathExtent]; MagickBooleanType destroy; option=(*arguments)[i]; *magick='\0'; *path='\0'; *filename='\0'; *subimage='\0'; number_files=0; vector[count++]=ConstantString(option); destroy=MagickTrue; parameters=ParseCommandOption(MagickCommandOptions,MagickFalse,option); if (parameters > 0) { /* Do not expand command option parameters. */ for (j=0; j < parameters; j++) { i++; if (i == (ssize_t) *number_arguments) break; option=(*arguments)[i]; vector[count++]=ConstantString(option); } continue; } if ((*option == '"') || (*option == '\'')) continue; GetPathComponent(option,TailPath,filename); GetPathComponent(option,MagickPath,magick); if ((LocaleCompare(magick,"CAPTION") == 0) || (LocaleCompare(magick,"LABEL") == 0) || (LocaleCompare(magick,"PANGO") == 0) || (LocaleCompare(magick,"VID") == 0)) continue; if ((IsGlob(filename) == MagickFalse) && (*option != '@')) continue; if (*option != '@') { /* Generate file list from wildcard filename (e.g. *.jpg). */ GetPathComponent(option,HeadPath,path); GetPathComponent(option,SubimagePath,subimage); ExpandFilename(path); if (*home_directory == '\0') getcwd_utf8(home_directory,MagickPathExtent-1); filelist=ListFiles(*path == '\0' ? home_directory : path,filename, &number_files); } else { char *files; ExceptionInfo *exception; int length; /* Generate file list from file list (e.g. @filelist.txt). */ exception=AcquireExceptionInfo(); files=FileToString(option+1,~0UL,exception); exception=DestroyExceptionInfo(exception); if (files == (char *) NULL) continue; filelist=StringToArgv(files,&length); if (filelist == (char **) NULL) continue; files=DestroyString(files); filelist[0]=DestroyString(filelist[0]); for (j=0; j < (ssize_t) (length-1); j++) filelist[j]=filelist[j+1]; number_files=(size_t) length-1; } if (filelist == (char **) NULL) continue; for (j=0; j < (ssize_t) number_files; j++) if (IsPathDirectory(filelist[j]) <= 0) break; if (j == (ssize_t) number_files) { for (j=0; j < (ssize_t) number_files; j++) filelist[j]=DestroyString(filelist[j]); filelist=(char **) RelinquishMagickMemory(filelist); continue; } /* Transfer file list to argument vector. */ vector=(char **) ResizeQuantumMemory(vector,(size_t) *number_arguments+ count+number_files+1,sizeof(*vector)); if (vector == (char **) NULL) { for (j=0; j < (ssize_t) number_files; j++) filelist[j]=DestroyString(filelist[j]); filelist=(char **) RelinquishMagickMemory(filelist); return(MagickFalse); } for (j=0; j < (ssize_t) number_files; j++) { option=filelist[j]; parameters=ParseCommandOption(MagickCommandOptions,MagickFalse,option); if (parameters > 0) { ssize_t k; /* Do not expand command option parameters. */ vector[count++]=ConstantString(option); for (k=0; k < parameters; k++) { j++; if (j == (ssize_t) number_files) break; option=filelist[j]; vector[count++]=ConstantString(option); } continue; } (void) CopyMagickString(filename,path,MagickPathExtent); if (*path != '\0') (void) ConcatenateMagickString(filename,DirectorySeparator, MagickPathExtent); if (filelist[j] != (char *) NULL) (void) ConcatenateMagickString(filename,filelist[j],MagickPathExtent); filelist[j]=DestroyString(filelist[j]); if (strlen(filename) >= (MagickPathExtent-1)) ThrowFatalException(OptionFatalError,"FilenameTruncated"); if (IsPathDirectory(filename) <= 0) { char file_path[MagickPathExtent]; *file_path='\0'; if (*magick != '\0') { (void) ConcatenateMagickString(file_path,magick, MagickPathExtent); (void) ConcatenateMagickString(file_path,":",MagickPathExtent); } (void) ConcatenateMagickString(file_path,filename,MagickPathExtent); if (*subimage != '\0') { (void) ConcatenateMagickString(file_path,"[",MagickPathExtent); (void) ConcatenateMagickString(file_path,subimage, MagickPathExtent); (void) ConcatenateMagickString(file_path,"]",MagickPathExtent); } if (strlen(file_path) >= (MagickPathExtent-1)) ThrowFatalException(OptionFatalError,"FilenameTruncated"); if (destroy != MagickFalse) { count--; vector[count]=DestroyString(vector[count]); destroy=MagickFalse; } vector[count++]=ConstantString(file_path); } } filelist=(char **) RelinquishMagickMemory(filelist); } vector[count]=(char *) NULL; if (IsEventLogging() != MagickFalse) { char *command_line; command_line=AcquireString(vector[0]); for (i=1; i < count; i++) { (void) ConcatenateString(&command_line," {"); (void) ConcatenateString(&command_line,vector[i]); (void) ConcatenateString(&command_line,"}"); } (void) LogMagickEvent(ConfigureEvent,GetMagickModule(), "Command line: %s",command_line); command_line=DestroyString(command_line); } *number_arguments=(int) count; *arguments=vector; return(MagickTrue); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % G e t E x e c u t i o n P a t h % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % GetExecutionPath() returns the pathname of the executable that started % the process. On success MagickTrue is returned, otherwise MagickFalse. % % The format of the GetExecutionPath method is: % % MagickBooleanType GetExecutionPath(char *path,const size_t extent) % % A description of each parameter follows: % % o path: the pathname of the executable that started the process. % % o extent: the maximum extent of the path. % */ MagickPrivate MagickBooleanType GetExecutionPath(char *path,const size_t extent) { char *directory; *path='\0'; directory=getcwd(path,(unsigned long) extent); (void) directory; #if defined(MAGICKCORE_HAVE_GETPID) && defined(MAGICKCORE_HAVE_READLINK) && defined(PATH_MAX) { char execution_path[PATH_MAX+1], link_path[MagickPathExtent]; ssize_t count; (void) FormatLocaleString(link_path,MagickPathExtent,"/proc/%.20g/exe", (double) getpid()); count=readlink(link_path,execution_path,PATH_MAX); if (count == -1) { (void) FormatLocaleString(link_path,MagickPathExtent,"/proc/%.20g/file", (double) getpid()); count=readlink(link_path,execution_path,PATH_MAX); } if ((count > 0) && (count <= (ssize_t) PATH_MAX)) { execution_path[count]='\0'; (void) CopyMagickString(path,execution_path,extent); } } #endif #if defined(MAGICKCORE_HAVE__NSGETEXECUTABLEPATH) { char executable_path[PATH_MAX << 1], execution_path[PATH_MAX+1]; uint32_t length; length=sizeof(executable_path); if ((_NSGetExecutablePath(executable_path,&length) == 0) && (realpath(executable_path,execution_path) != (char *) NULL)) (void) CopyMagickString(path,execution_path,extent); } #endif #if defined(MAGICKCORE_HAVE_GETEXECNAME) { const char *execution_path; execution_path=(const char *) getexecname(); if (execution_path != (const char *) NULL) { if (*execution_path != *DirectorySeparator) (void) ConcatenateMagickString(path,DirectorySeparator,extent); (void) ConcatenateMagickString(path,execution_path,extent); } } #endif #if defined(MAGICKCORE_WINDOWS_SUPPORT) NTGetExecutionPath(path,extent); #endif #if defined(__GNU__) { char *program_name; ssize_t count; count=0; program_name=program_invocation_name; if (*program_invocation_name != '/') { size_t extent; extent=strlen(directory)+strlen(program_name)+2; program_name=AcquireQuantumMemory(extent,sizeof(*program_name)); if (program_name == (char *) NULL) program_name=program_invocation_name; else count=FormatLocaleString(program_name,extent,"%s/%s",directory, program_invocation_name); } if (count != -1) { char execution_path[PATH_MAX+1]; if (realpath(program_name,execution_path) != (char *) NULL) (void) CopyMagickString(path,execution_path,extent); } if (program_name != program_invocation_name) program_name=(char *) RelinquishMagickMemory(program_name); } #endif #if defined(__OpenBSD__) { extern char *__progname; (void) CopyMagickString(path,__progname,extent); } #endif return(IsPathAccessible(path)); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % G e t M a g i c k P a g e S i z e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % GetMagickPageSize() returns the memory page size. % % The format of the GetMagickPageSize method is: % % ssize_t GetMagickPageSize() % */ MagickPrivate ssize_t GetMagickPageSize(void) { static ssize_t page_size = -1; if (page_size > 0) return(page_size); #if defined(MAGICKCORE_HAVE_SYSCONF) && defined(_SC_PAGE_SIZE) page_size=(ssize_t) sysconf(_SC_PAGE_SIZE); #elif defined(MAGICKCORE_HAVE_GETPAGESIZE) page_size=(ssize_t) getpagesize(); #elif defined(MAGICKCORE_WINDOWS_SUPPORT) page_size=NTGetPageSize(); #endif if (page_size <= 0) page_size=4096; return(page_size); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % G e t P a t h A t t r i b u t e s % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % GetPathAttributes() returns attributes (e.g. size of file) about a path. % % The path of the GetPathAttributes method is: % % MagickBooleanType GetPathAttributes(const char *path,void *attributes) % % A description of each parameter follows. % % o path: the file path. % % o attributes: the path attributes are returned here. % */ MagickExport MagickBooleanType GetPathAttributes(const char *path, void *attributes) { MagickBooleanType status; if (path == (const char *) NULL) { errno=EINVAL; return(MagickFalse); } (void) memset(attributes,0,sizeof(struct stat)); status=stat_utf8(path,(struct stat *) attributes) == 0 ? MagickTrue : MagickFalse; return(status); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % G e t P a t h C o m p o n e n t % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % GetPathComponent() returns the parent directory name, filename, basename, or % extension of a file path. % % The component string pointed to must have at least MagickPathExtent space % for the results to be stored. % % The format of the GetPathComponent function is: % % GetPathComponent(const char *path,PathType type,char *component) % % A description of each parameter follows: % % o path: Specifies a pointer to a character array that contains the % file path. % % o type: Specififies which file path component to return. % % o component: the selected file path component is returned here. % */ MagickExport void GetPathComponent(const char *path,PathType type, char *component) { char *q; register char *p; size_t magick_length, subimage_offset, subimage_length; assert(path != (const char *) NULL); (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",path); assert(component != (char *) NULL); if (*path == '\0') { *component='\0'; return; } (void) CopyMagickString(component,path,MagickPathExtent); subimage_length=0; subimage_offset=0; if (type != SubcanonicalPath) { p=component+strlen(component)-1; q=strrchr(component,'['); if ((strlen(component) > 2) && (*p == ']') && (q != (char *) NULL) && ((q == component) || (*(q-1) != ']')) && (IsPathAccessible(path) == MagickFalse)) { /* Look for scene specification (e.g. img0001.pcd[4]). */ *p='\0'; if ((IsSceneGeometry(q+1,MagickFalse) == MagickFalse) && (IsGeometry(q+1) == MagickFalse)) *p=']'; else { subimage_length=(size_t) (p-q); subimage_offset=(size_t) (q-component+1); *q='\0'; } } } magick_length=0; #if defined(__OS2__) if (path[1] != ":") #endif for (p=component; *p != '\0'; p++) { if ((*p == '%') && (*(p+1) == '[')) { /* Skip over %[...]. */ for (p++; (*p != ']') && (*p != '\0'); p++) ; if (*p == '\0') break; } if ((p != component) && (*p == ':') && (IsPathDirectory(component) < 0) && (IsPathAccessible(component) == MagickFalse)) { /* Look for image format specification (e.g. ps3:image). */ *p='\0'; if (IsMagickConflict(component) != MagickFalse) *p=':'; else { magick_length=(size_t) (p-component+1); for (q=component; *(++p) != '\0'; q++) *q=(*p); *q='\0'; } break; } } p=component; if (*p != '\0') for (p=component+strlen(component)-1; p > component; p--) if (IsBasenameSeparator(*p) != MagickFalse) break; switch (type) { case MagickPath: { if (magick_length != 0) (void) CopyMagickString(component,path,magick_length); else *component='\0'; break; } case RootPath: { if (*component != '\0') { for (p=component+(strlen(component)-1); p > component; p--) { if (IsBasenameSeparator(*p) != MagickFalse) break; if (*p == '.') break; } if (*p == '.') *p='\0'; break; } } case HeadPath: { *p='\0'; break; } case TailPath: { if (IsBasenameSeparator(*p) != MagickFalse) (void) CopyMagickString(component,p+1,MagickPathExtent); break; } case BasePath: { if (IsBasenameSeparator(*p) != MagickFalse) (void) CopyMagickString(component,p+1,MagickPathExtent); if (*component != '\0') for (p=component+(strlen(component)-1); p > component; p--) if (*p == '.') { *p='\0'; break; } break; } case ExtensionPath: { if (IsBasenameSeparator(*p) != MagickFalse) (void) CopyMagickString(component,p+1,MagickPathExtent); if (*component != '\0') for (p=component+strlen(component)-1; p > component; p--) if (*p == '.') break; *component='\0'; if (*p == '.') (void) CopyMagickString(component,p+1,MagickPathExtent); break; } case SubimagePath: { *component='\0'; if ((subimage_length != 0) && (magick_length < subimage_offset)) (void) CopyMagickString(component,path+subimage_offset,subimage_length); break; } case SubcanonicalPath: case CanonicalPath: case UndefinedPath: break; } } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % G e t P a t h C o m p o n e n t s % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % GetPathComponents() returns a list of path components. % % The format of the GetPathComponents method is: % % char **GetPathComponents(const char *path, % size_t *number_componenets) % % A description of each parameter follows: % % o path: Specifies the string to segment into a list. % % o number_components: return the number of components in the list % */ MagickPrivate char **GetPathComponents(const char *path, size_t *number_components) { char **components; register const char *p, *q; register ssize_t i; if (path == (char *) NULL) return((char **) NULL); *number_components=1; for (p=path; *p != '\0'; p++) if (IsBasenameSeparator(*p)) (*number_components)++; components=(char **) AcquireQuantumMemory((size_t) *number_components+1UL, sizeof(*components)); if (components == (char **) NULL) ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed"); p=path; for (i=0; i < (ssize_t) *number_components; i++) { for (q=p; *q != '\0'; q++) if (IsBasenameSeparator(*q)) break; components[i]=(char *) AcquireQuantumMemory((size_t) (q-p)+MagickPathExtent, sizeof(**components)); if (components[i] == (char *) NULL) ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed"); (void) CopyMagickString(components[i],p,(size_t) (q-p+1)); p=q+1; } components[i]=(char *) NULL; return(components); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % I s P a t h A c c e s s i b l e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % IsPathAccessible() returns MagickTrue if the file as defined by the path is % accessible. % % The format of the IsPathAccessible method is: % % MagickBooleanType IsPathAccessible(const char *path) % % A description of each parameter follows. % % o path: Specifies a path to a file. % */ MagickExport MagickBooleanType IsPathAccessible(const char *path) { MagickBooleanType status; struct stat attributes; if ((path == (const char *) NULL) || (*path == '\0')) return(MagickFalse); if (LocaleCompare(path,"-") == 0) return(MagickTrue); status=GetPathAttributes(path,&attributes); if (status == MagickFalse) return(status); if (S_ISREG(attributes.st_mode) == 0) return(MagickFalse); if (access_utf8(path,F_OK) != 0) return(MagickFalse); return(MagickTrue); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % + I s P a t h D i r e c t o r y % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % IsPathDirectory() returns -1 if the directory does not exist, 1 is returned % if the path represents a directory otherwise 0. % % The format of the IsPathDirectory method is: % % int IsPathDirectory(const char *path) % % A description of each parameter follows. % % o path: The directory path. % */ static int IsPathDirectory(const char *path) { MagickBooleanType status; struct stat attributes; if ((path == (const char *) NULL) || (*path == '\0')) return(MagickFalse); status=GetPathAttributes(path,&attributes); if (status == MagickFalse) return(-1); if (S_ISDIR(attributes.st_mode) == 0) return(0); return(1); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % L i s t F i l e s % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % ListFiles() reads the directory specified and returns a list of filenames % contained in the directory sorted in ascending alphabetic order. % % The format of the ListFiles function is: % % char **ListFiles(const char *directory,const char *pattern, % ssize_t *number_entries) % % A description of each parameter follows: % % o filelist: Method ListFiles returns a list of filenames contained % in the directory. If the directory specified cannot be read or it is % a file a NULL list is returned. % % o directory: Specifies a pointer to a text string containing a directory % name. % % o pattern: Specifies a pointer to a text string containing a pattern. % % o number_entries: This integer returns the number of filenames in the % list. % */ #if defined(__cplusplus) || defined(c_plusplus) extern "C" { #endif static int FileCompare(const void *x,const void *y) { register const char **p, **q; p=(const char **) x; q=(const char **) y; return(LocaleCompare(*p,*q)); } #if defined(__cplusplus) || defined(c_plusplus) } #endif MagickPrivate char **ListFiles(const char *directory,const char *pattern, size_t *number_entries) { char **filelist; DIR *current_directory; struct dirent *buffer, *entry; size_t max_entries; /* Open directory. */ assert(directory != (const char *) NULL); (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",directory); assert(pattern != (const char *) NULL); assert(number_entries != (size_t *) NULL); *number_entries=0; current_directory=opendir(directory); if (current_directory == (DIR *) NULL) return((char **) NULL); /* Allocate filelist. */ max_entries=2048; filelist=(char **) AcquireQuantumMemory((size_t) max_entries, sizeof(*filelist)); if (filelist == (char **) NULL) { (void) closedir(current_directory); return((char **) NULL); } /* Save the current and change to the new directory. */ buffer=(struct dirent *) AcquireMagickMemory(sizeof(*buffer)+FILENAME_MAX+1); if (buffer == (struct dirent *) NULL) ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed"); while ((MagickReadDirectory(current_directory,buffer,&entry) == 0) && (entry != (struct dirent *) NULL)) { if (*entry->d_name == '.') continue; if ((IsPathDirectory(entry->d_name) > 0) || #if defined(MAGICKCORE_WINDOWS_SUPPORT) (GlobExpression(entry->d_name,pattern,MagickTrue) != MagickFalse)) #else (GlobExpression(entry->d_name,pattern,MagickFalse) != MagickFalse)) #endif { if (*number_entries >= max_entries) { /* Extend the file list. */ max_entries<<=1; filelist=(char **) ResizeQuantumMemory(filelist,(size_t) max_entries,sizeof(*filelist)); if (filelist == (char **) NULL) break; } #if defined(vms) { register char *p; p=strchr(entry->d_name,';'); if (p) *p='\0'; if (*number_entries > 0) if (LocaleCompare(entry->d_name,filelist[*number_entries-1]) == 0) continue; } #endif filelist[*number_entries]=(char *) AcquireString(entry->d_name); (*number_entries)++; } } buffer=(struct dirent *) RelinquishMagickMemory(buffer); (void) closedir(current_directory); if (filelist == (char **) NULL) return((char **) NULL); /* Sort filelist in ascending order. */ qsort((void *) filelist,(size_t) *number_entries,sizeof(*filelist), FileCompare); return(filelist); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % M a g i c k D e l a y % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % MagickDelay() suspends program execution for the number of milliseconds % specified. % % The format of the Delay method is: % % void MagickDelay(const MagickSizeType milliseconds) % % A description of each parameter follows: % % o milliseconds: Specifies the number of milliseconds to delay before % returning. % */ MagickExport void MagickDelay(const MagickSizeType milliseconds) { if (milliseconds == 0) return; #if defined(MAGICKCORE_HAVE_NANOSLEEP) { struct timespec timer; timer.tv_sec=(time_t) (milliseconds/1000); timer.tv_nsec=(milliseconds % 1000)*1000*1000; (void) nanosleep(&timer,(struct timespec *) NULL); } #elif defined(MAGICKCORE_HAVE_USLEEP) usleep(1000*milliseconds); #elif defined(MAGICKCORE_HAVE_SELECT) { struct timeval timer; timer.tv_sec=(long) milliseconds/1000; timer.tv_usec=(long) (milliseconds % 1000)*1000; (void) select(0,(XFD_SET *) NULL,(XFD_SET *) NULL,(XFD_SET *) NULL,&timer); } #elif defined(MAGICKCORE_HAVE_POLL) (void) poll((struct pollfd *) NULL,0,(int) milliseconds); #elif defined(MAGICKCORE_WINDOWS_SUPPORT) Sleep((long) milliseconds); #elif defined(vms) { float timer; timer=milliseconds/1000.0; lib$wait(&timer); } #elif defined(__BEOS__) snooze(1000*milliseconds); #else # error "Time delay method not defined." #endif } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % M u l t i l i n e C e n s u s % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % MultilineCensus() returns the number of lines within a label. A line is % represented by a \n character. % % The format of the MultilineCenus method is: % % size_t MultilineCensus(const char *label) % % A description of each parameter follows. % % o label: This character string is the label. % */ MagickExport size_t MultilineCensus(const char *label) { size_t number_lines; /* Determine the number of lines within this label. */ if (label == (char *) NULL) return(0); for (number_lines=1; *label != '\0'; label++) if (*label == '\n') number_lines++; return(number_lines); } /* %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % % % % % % S h r e d F i l e % % % % % % % %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% % % ShredFile() overwrites the specified file with zeros or random data and then % removes it. The overwrite is optional and is only required to help keep % the contents of the file private. On the first pass, the file is zeroed. % For subsequent passes, random data is written. % % The format of the ShredFile method is: % % MagickBooleanType ShredFile(const char *path) % % A description of each parameter follows. % % o path: Specifies a path to a file. % */ MagickPrivate MagickBooleanType ShredFile(const char *path) { char *passes; int file, status; MagickSizeType length; register ssize_t i; size_t quantum; struct stat file_stats; if ((path == (const char *) NULL) || (*path == '\0')) return(MagickFalse); passes=GetPolicyValue("system:shred"); if (passes == (char *) NULL) passes=GetEnvironmentValue("MAGICK_SHRED_PASSES"); if (passes == (char *) NULL) { /* Don't shred the file, just remove it. */ status=remove_utf8(path); if (status == -1) { (void) LogMagickEvent(ExceptionEvent,GetMagickModule(), "Failed to remove: %s",path); return(MagickFalse); } return(MagickTrue); } file=open_utf8(path,O_WRONLY | O_EXCL | O_BINARY,S_MODE); if (file == -1) { /* Don't shred the file, just remove it. */ passes=DestroyString(passes); status=remove_utf8(path); if (status == -1) (void) LogMagickEvent(ExceptionEvent,GetMagickModule(), "Failed to remove: %s",path); return(MagickFalse); } /* Shred the file. */ quantum=(size_t) MagickMaxBufferExtent; if ((fstat(file,&file_stats) == 0) && (file_stats.st_size > 0)) quantum=(size_t) MagickMin(file_stats.st_size,MagickMaxBufferExtent); length=(MagickSizeType) file_stats.st_size; for (i=0; i < (ssize_t) StringToInteger(passes); i++) { RandomInfo *random_info; register MagickOffsetType j; ssize_t count; if (lseek(file,0,SEEK_SET) < 0) break; random_info=AcquireRandomInfo(); for (j=0; j < (MagickOffsetType) length; j+=count) { StringInfo *key; key=GetRandomKey(random_info,quantum); if (i == 0) ResetStringInfo(key); /* zero on first pass */ count=write(file,GetStringInfoDatum(key),(size_t) MagickMin((MagickSizeType) quantum,length-j)); key=DestroyStringInfo(key); if (count <= 0) { count=0; if (errno != EINTR) break; } } random_info=DestroyRandomInfo(random_info); if (j < (MagickOffsetType) length) break; } status=close(file); status=remove_utf8(path); if (status != -1) status=StringToInteger(passes); passes=DestroyString(passes); return((status == -1 || i < (ssize_t) status) ? MagickFalse : MagickTrue); }