MagickCore  6.9.10
Convert, Edit, Or Compose Bitmap Images
utility-private.h
Go to the documentation of this file.
1 /*
2  Copyright 1999-2019 ImageMagick Studio LLC, a non-profit organization
3  dedicated to making software imaging solutions freely available.
4 
5  You may not use this file except in compliance with the License.
6  obtain a copy of the License at
7 
8  https://imagemagick.org/script/license.php
9 
10  Unless required by applicable law or agreed to in writing, software
11  distributed under the License is distributed on an "AS IS" BASIS,
12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  See the License for the specific language governing permissions and
14  limitations under the License.
15 
16  MagickCore private utility methods.
17 */
18 #ifndef MAGICKCORE_UTILITY_PRIVATE_H
19 #define MAGICKCORE_UTILITY_PRIVATE_H
20 
21 #include "magick/memory_.h"
22 #include "magick/nt-base.h"
23 #include "magick/nt-base-private.h"
24 
25 #if defined(__cplusplus) || defined(c_plusplus)
26 extern "C" {
27 #endif
28 
29 extern MagickPrivate MagickBooleanType
30  ShredFile(const char *);
31 
32 static inline int MagickReadDirectory(DIR *directory,struct dirent *entry,
33  struct dirent **result)
34 {
35 #if defined(MAGICKCORE_HAVE_READDIR_R)
36  return(readdir_r(directory,entry,result));
37 #else
38  (void) entry;
39  errno=0;
40  *result=readdir(directory);
41  return(errno);
42 #endif
43 }
44 
45 /*
46  Windows UTF8 compatibility methods.
47 */
48 
49 #if defined(MAGICKCORE_WINDOWS_SUPPORT)
50 static inline wchar_t *create_wchar_path(const char *utf8)
51 {
52  int
53  count;
54 
55  wchar_t
56  *wideChar;
57 
58  count=MultiByteToWideChar(CP_UTF8,0,utf8,-1,NULL,0);
59  if (count > MAX_PATH)
60  {
61  char
62  buffer[MaxTextExtent];
63 
64  wchar_t
65  shortPath[MAX_PATH],
66  *longPath;
67 
68  (void) FormatLocaleString(buffer,MaxTextExtent,"\\\\?\\%s",utf8);
69  count+=4;
70  longPath=(wchar_t *) AcquireQuantumMemory(count,sizeof(*longPath));
71  if (longPath == (wchar_t *) NULL)
72  return((wchar_t *) NULL);
73  count=MultiByteToWideChar(CP_UTF8,0,buffer,-1,longPath,count);
74  if (count != 0)
75  count=GetShortPathNameW(longPath,shortPath,MAX_PATH);
76  longPath=(wchar_t *) RelinquishMagickMemory(longPath);
77  if (count < 5)
78  return((wchar_t *) NULL);
79  wideChar=(wchar_t *) AcquireQuantumMemory(count-3,sizeof(*wideChar));
80  wcscpy(wideChar,shortPath+4);
81  return(wideChar);
82  }
83  wideChar=(wchar_t *) AcquireQuantumMemory(count,sizeof(*wideChar));
84  if (wideChar == (wchar_t *) NULL)
85  return((wchar_t *) NULL);
86  count=MultiByteToWideChar(CP_UTF8,0,utf8,-1,wideChar,count);
87  if (count == 0)
88  {
89  wideChar=(wchar_t *) RelinquishMagickMemory(wideChar);
90  return((wchar_t *) NULL);
91  }
92  return(wideChar);
93 }
94 #endif
95 
96 static inline int access_utf8(const char *path,int mode)
97 {
98 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__)
99  return(access(path,mode));
100 #else
101  int
102  status;
103 
104  wchar_t
105  *path_wide;
106 
107  path_wide=create_wchar_path(path);
108  if (path_wide == (wchar_t *) NULL)
109  return(-1);
110  status=_waccess(path_wide,mode);
111  path_wide=(wchar_t *) RelinquishMagickMemory(path_wide);
112  return(status);
113 #endif
114 }
115 
116 static inline FILE *fopen_utf8(const char *path,const char *mode)
117 {
118 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__) || defined(__MINGW32__)
119  return(fopen(path,mode));
120 #else
121  FILE
122  *file;
123 
124  wchar_t
125  *mode_wide,
126  *path_wide;
127 
128  path_wide=create_wchar_path(path);
129  if (path_wide == (wchar_t *) NULL)
130  return((FILE *) NULL);
131  mode_wide=create_wchar_path(mode);
132  if (mode_wide == (wchar_t *) NULL)
133  {
134  path_wide=(wchar_t *) RelinquishMagickMemory(path_wide);
135  return((FILE *) NULL);
136  }
137  file=_wfopen(path_wide,mode_wide);
138  mode_wide=(wchar_t *) RelinquishMagickMemory(mode_wide);
139  path_wide=(wchar_t *) RelinquishMagickMemory(path_wide);
140  return(file);
141 #endif
142 }
143 
144 static inline void getcwd_utf8(char *path,size_t extent)
145 {
146 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__)
147  char
148  *directory;
149 
150  directory=getcwd(path,extent);
151  (void) directory;
152 #else
153  wchar_t
154  wide_path[MaxTextExtent];
155 
156  (void) _wgetcwd(wide_path,MaxTextExtent-1);
157  (void) WideCharToMultiByte(CP_UTF8,0,wide_path,-1,path,(int) extent,NULL,NULL);
158 #endif
159 }
160 
161 #if defined(MAGICKCORE_WINDOWS_SUPPORT) && !defined(__CYGWIN__) && !defined(__MINGW32__)
162 typedef int
163  mode_t;
164 #endif
165 
166 static inline int open_utf8(const char *path,int flags,mode_t mode)
167 {
168 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__) || defined(__MINGW32__)
169  return(open(path,flags,mode));
170 #else
171  int
172  status;
173 
174  wchar_t
175  *path_wide;
176 
177  path_wide=create_wchar_path(path);
178  if (path_wide == (wchar_t *) NULL)
179  return(-1);
180  status=_wopen(path_wide,flags,mode);
181  path_wide=(wchar_t *) RelinquishMagickMemory(path_wide);
182  return(status);
183 #endif
184 }
185 
186 static inline FILE *popen_utf8(const char *command,const char *type)
187 {
188 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__) || defined(__MINGW32__)
189  return(popen(command,type));
190 #else
191  FILE
192  *file;
193 
194  wchar_t
195  *type_wide,
196  *command_wide;
197 
198  command_wide=create_wchar_path(command);
199  if (command_wide == (wchar_t *) NULL)
200  return((FILE *) NULL);
201  type_wide=create_wchar_path(type);
202  if (type_wide == (wchar_t *) NULL)
203  {
204  command_wide=(wchar_t *) RelinquishMagickMemory(command_wide);
205  return((FILE *) NULL);
206  }
207  file=_wpopen(command_wide,type_wide);
208  type_wide=(wchar_t *) RelinquishMagickMemory(type_wide);
209  command_wide=(wchar_t *) RelinquishMagickMemory(command_wide);
210  return(file);
211 #endif
212 }
213 
214 static inline char *realpath_utf8(const char *path)
215 {
216 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__)
217 #if defined(MAGICKCORE_HAVE_REALPATH)
218  if (path == (const char *) NULL)
219  return((char *) NULL);
220  return(realpath(path,(char *) NULL));
221 #else
222  if (path == (const char *) NULL)
223  return((char *) NULL);
224  return(AcquireString(path));
225 #endif
226 #else
227  char
228  *real_path;
229 
230  DWORD
231  final_path_length,
232  full_path_length;
233 
234  HANDLE
235  file_handle;
236 
237  int
238  length,
239  utf8_length;
240 
241  wchar_t
242  *clean_path,
243  *full_path,
244  *wide_path;
245 
246  if (path == (const char *) NULL)
247  return((char *) NULL);
248  length=MultiByteToWideChar(CP_UTF8,0,path,-1,NULL,0);
249  if (length <= 0)
250  return((char *) NULL);
251  wide_path=(wchar_t *) AcquireQuantumMemory(length,sizeof(wchar_t));
252  if (wide_path == (wchar_t *) NULL)
253  return((char *) NULL);
254  MultiByteToWideChar(CP_UTF8,0,path,-1,wide_path,length);
255  full_path_length=GetFullPathNameW(wide_path,0,NULL,NULL);
256  if (full_path_length == 0)
257  {
258  wide_path=(wchar_t *) RelinquishMagickMemory(wide_path);
259  return((char *) NULL);
260  }
261  full_path=(wchar_t *) AcquireQuantumMemory(full_path_length,sizeof(wchar_t));
262  if (full_path == (wchar_t *) NULL)
263  {
264  wide_path=(wchar_t *) RelinquishMagickMemory(wide_path);
265  return((char *) NULL);
266  }
267  GetFullPathNameW(wide_path,full_path_length,full_path,NULL);
268  wide_path=(wchar_t *) RelinquishMagickMemory(wide_path);
269  file_handle=CreateFileW(full_path,GENERIC_READ,FILE_SHARE_READ |
270  FILE_SHARE_WRITE | FILE_SHARE_DELETE,NULL,OPEN_EXISTING,
271  FILE_FLAG_BACKUP_SEMANTICS,NULL);
272  if (file_handle != INVALID_HANDLE_VALUE)
273  {
274  final_path_length=GetFinalPathNameByHandleW(file_handle,NULL,0,
275  FILE_NAME_NORMALIZED);
276  if (final_path_length == 0)
277  {
278  CloseHandle(file_handle);
279  full_path=(wchar_t *) RelinquishMagickMemory(full_path);
280  return((char *) NULL);
281  }
282  full_path=(wchar_t *) RelinquishMagickMemory(full_path);
283  full_path=(wchar_t *) AcquireQuantumMemory(final_path_length,
284  sizeof(wchar_t));
285  if (full_path == (wchar_t *) NULL)
286  {
287  CloseHandle(file_handle);
288  return((char *) NULL);
289  }
290  GetFinalPathNameByHandleW(file_handle,full_path,final_path_length,
291  FILE_NAME_NORMALIZED);
292  CloseHandle(file_handle);
293  }
294  clean_path=full_path;
295  if (wcsncmp(full_path,L"\\\\?\\",4) == 0)
296  clean_path=full_path+4;
297  utf8_length=WideCharToMultiByte(CP_UTF8,0,clean_path,-1,NULL,0,NULL,NULL);
298  if (utf8_length <= 0)
299  {
300  full_path=(wchar_t *) RelinquishMagickMemory(full_path);
301  return((char *) NULL);
302  }
303  real_path=(char *) AcquireQuantumMemory(utf8_length,sizeof(char));
304  if (real_path == (char *) NULL)
305  {
306  full_path=(wchar_t *) RelinquishMagickMemory(full_path);
307  return((char *) NULL);
308  }
309  WideCharToMultiByte(CP_UTF8,0,clean_path,-1,real_path,utf8_length,NULL,NULL);
310  full_path=(wchar_t *) RelinquishMagickMemory(full_path);
311  return(real_path);
312 #endif
313 }
314 
315 static inline int remove_utf8(const char *path)
316 {
317 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__) || defined(__MINGW32__)
318  return(unlink(path));
319 #else
320  int
321  status;
322 
323  wchar_t
324  *path_wide;
325 
326  path_wide=create_wchar_path(path);
327  if (path_wide == (wchar_t *) NULL)
328  return(-1);
329  status=_wremove(path_wide);
330  path_wide=(wchar_t *) RelinquishMagickMemory(path_wide);
331  return(status);
332 #endif
333 }
334 
335 static inline int rename_utf8(const char *source,const char *destination)
336 {
337 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__) || defined(__MINGW32__)
338  return(rename(source,destination));
339 #else
340  int
341  status;
342 
343  wchar_t
344  *destination_wide,
345  *source_wide;
346 
347  source_wide=create_wchar_path(source);
348  if (source_wide == (wchar_t *) NULL)
349  return(-1);
350  destination_wide=create_wchar_path(destination);
351  if (destination_wide == (wchar_t *) NULL)
352  {
353  source_wide=(wchar_t *) RelinquishMagickMemory(source_wide);
354  return(-1);
355  }
356  status=_wrename(source_wide,destination_wide);
357  destination_wide=(wchar_t *) RelinquishMagickMemory(destination_wide);
358  source_wide=(wchar_t *) RelinquishMagickMemory(source_wide);
359  return(status);
360 #endif
361 }
362 
363 static inline int stat_utf8(const char *path,struct stat *attributes)
364 {
365 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__) || defined(__MINGW32__)
366  return(stat(path,attributes));
367 #else
368  int
369  status;
370 
371  wchar_t
372  *path_wide;
373 
374  path_wide=create_wchar_path(path);
375  if (path_wide == (WCHAR *) NULL)
376  return(-1);
377  status=wstat(path_wide,attributes);
378  path_wide=(WCHAR *) RelinquishMagickMemory(path_wide);
379  return(status);
380 #endif
381 }
382 
383 #if defined(__cplusplus) || defined(c_plusplus)
384 }
385 #endif
386 
387 #endif
_DIR
Definition: mac.h:42
nt-base-private.h
FormatLocaleString
MagickExport ssize_t FormatLocaleString(char *magick_restrict string, const size_t length, const char *magick_restrict format,...)
Definition: locale.c:502
MagickReadDirectory
static int MagickReadDirectory(DIR *directory, struct dirent *entry, struct dirent **result)
Definition: utility-private.h:32
getcwd_utf8
static void getcwd_utf8(char *path, size_t extent)
Definition: utility-private.h:144
readdir
MagickExport struct dirent * readdir(DIR *)
_TypeInfo::path
char * path
Definition: type.h:56
nt-base.h
dirent
Definition: mac.h:54
remove_utf8
static int remove_utf8(const char *path)
Definition: utility-private.h:315
MagickPrivate
#define MagickPrivate
Definition: method-attribute.h:81
popen_utf8
static FILE * popen_utf8(const char *command, const char *type)
Definition: utility-private.h:186
fopen_utf8
static FILE * fopen_utf8(const char *path, const char *mode)
Definition: utility-private.h:116
MagickBooleanType
MagickBooleanType
Definition: magick-type.h:192
stat_utf8
static int stat_utf8(const char *path, struct stat *attributes)
Definition: utility-private.h:363
RelinquishMagickMemory
MagickExport void * RelinquishMagickMemory(void *memory)
Definition: memory.c:1077
ShredFile
MagickPrivate MagickBooleanType ShredFile(const char *)
Definition: utility.c:1817
access_utf8
static int access_utf8(const char *path, int mode)
Definition: utility-private.h:96
realpath_utf8
static char * realpath_utf8(const char *path)
Definition: utility-private.h:214
memory_.h
MaxTextExtent
#define MaxTextExtent
Definition: method-attribute.h:89
AcquireString
MagickExport char * AcquireString(const char *source)
Definition: string.c:125
open_utf8
static int open_utf8(const char *path, int flags, mode_t mode)
Definition: utility-private.h:166
rename_utf8
static int rename_utf8(const char *source, const char *destination)
Definition: utility-private.h:335
AcquireQuantumMemory
MagickExport void * AcquireQuantumMemory(const size_t count, const size_t quantum)
Definition: memory.c:544