MagickCore  6.9.11-60
Convert, Edit, Or Compose Bitmap Images
utility-private.h
Go to the documentation of this file.
1 /*
2  Copyright 1999-2021 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. You may
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 
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) && (NTLongPathsEnabled() == MagickFalse))
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) || (count >= MAX_PATH))
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__)
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__)
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__)
189  return(popen(command,type));
190 #else
191  FILE
192  *file;
193 
194  int
195  length;
196 
197  wchar_t
198  *command_wide,
199  type_wide[5];
200 
201  file=(FILE *) NULL;
202  length=MultiByteToWideChar(CP_UTF8,0,type,-1,type_wide,5);
203  if (length == 0)
204  return(file);
205  length=MultiByteToWideChar(CP_UTF8,0,command,-1,NULL,0);
206  if (length == 0)
207  return(file);
208  command_wide=(wchar_t *) AcquireQuantumMemory(length,sizeof(*command_wide));
209  if (command_wide == (wchar_t *) NULL)
210  return(file);
211  length=MultiByteToWideChar(CP_UTF8,0,command,-1,command_wide,length);
212  if (length != 0)
213  file=_wpopen(command_wide,type_wide);
214  command_wide=(wchar_t *) RelinquishMagickMemory(command_wide);
215  return(file);
216 #endif
217 }
218 
219 static inline int remove_utf8(const char *path)
220 {
221 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__)
222  return(unlink(path));
223 #else
224  int
225  status;
226 
227  wchar_t
228  *path_wide;
229 
230  path_wide=create_wchar_path(path);
231  if (path_wide == (wchar_t *) NULL)
232  return(-1);
233  status=_wremove(path_wide);
234  path_wide=(wchar_t *) RelinquishMagickMemory(path_wide);
235  return(status);
236 #endif
237 }
238 
239 static inline int rename_utf8(const char *source,const char *destination)
240 {
241 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__)
242  return(rename(source,destination));
243 #else
244  int
245  status;
246 
247  wchar_t
248  *destination_wide,
249  *source_wide;
250 
251  source_wide=create_wchar_path(source);
252  if (source_wide == (wchar_t *) NULL)
253  return(-1);
254  destination_wide=create_wchar_path(destination);
255  if (destination_wide == (wchar_t *) NULL)
256  {
257  source_wide=(wchar_t *) RelinquishMagickMemory(source_wide);
258  return(-1);
259  }
260  status=_wrename(source_wide,destination_wide);
261  destination_wide=(wchar_t *) RelinquishMagickMemory(destination_wide);
262  source_wide=(wchar_t *) RelinquishMagickMemory(source_wide);
263  return(status);
264 #endif
265 }
266 
267 static inline int stat_utf8(const char *path,struct stat *attributes)
268 {
269 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__)
270  return(stat(path,attributes));
271 #else
272  int
273  status;
274 
275  wchar_t
276  *path_wide;
277 
278  path_wide=create_wchar_path(path);
279  if (path_wide == (WCHAR *) NULL)
280  return(-1);
281  status=wstat(path_wide,attributes);
282  path_wide=(WCHAR *) RelinquishMagickMemory(path_wide);
283  return(status);
284 #endif
285 }
286 
287 #if defined(__cplusplus) || defined(c_plusplus)
288 }
289 #endif
290 
291 #endif
MagickExport ssize_t FormatLocaleString(char *magick_restrict string, const size_t length, const char *magick_restrict format,...)
Definition: locale.c:497
MagickExport struct dirent * readdir(DIR *)
MagickBooleanType
Definition: magick-type.h:203
@ MagickFalse
Definition: magick-type.h:204
MagickExport void * RelinquishMagickMemory(void *memory)
Definition: memory.c:1162
MagickExport void * AcquireQuantumMemory(const size_t count, const size_t quantum)
Definition: memory.c:665
#define MagickPrivate
Definition: method-attribute.h:81
#define MaxTextExtent
Definition: method-attribute.h:89
Definition: mac.h:42
Definition: mac.h:54
static int open_utf8(const char *path, int flags, mode_t mode)
Definition: utility-private.h:166
static int MagickReadDirectory(DIR *directory, struct dirent *entry, struct dirent **result)
Definition: utility-private.h:32
static int remove_utf8(const char *path)
Definition: utility-private.h:219
static int access_utf8(const char *path, int mode)
Definition: utility-private.h:96
static int stat_utf8(const char *path, struct stat *attributes)
Definition: utility-private.h:267
static FILE * popen_utf8(const char *command, const char *type)
Definition: utility-private.h:186
static FILE * fopen_utf8(const char *path, const char *mode)
Definition: utility-private.h:116
static void getcwd_utf8(char *path, size_t extent)
Definition: utility-private.h:144
MagickPrivate MagickBooleanType ShredFile(const char *)
Definition: utility.c:1826
static int rename_utf8(const char *source, const char *destination)
Definition: utility-private.h:239