MagickCore  6.9.10
Convert, Edit, Or Compose Bitmap Images
utility-private.h
Go to the documentation of this file.
1 /*
2  Copyright 1999-2018 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://www.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)
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 int remove_utf8(const char *path)
215 {
216 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__) || defined(__MINGW32__)
217  return(unlink(path));
218 #else
219  int
220  status;
221 
222  wchar_t
223  *path_wide;
224 
225  path_wide=create_wchar_path(path);
226  if (path_wide == (wchar_t *) NULL)
227  return(-1);
228  status=_wremove(path_wide);
229  path_wide=(wchar_t *) RelinquishMagickMemory(path_wide);
230  return(status);
231 #endif
232 }
233 
234 static inline int rename_utf8(const char *source,const char *destination)
235 {
236 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__) || defined(__MINGW32__)
237  return(rename(source,destination));
238 #else
239  int
240  status;
241 
242  wchar_t
243  *destination_wide,
244  *source_wide;
245 
246  source_wide=create_wchar_path(source);
247  if (source_wide == (wchar_t *) NULL)
248  return(-1);
249  destination_wide=create_wchar_path(destination);
250  if (destination_wide == (wchar_t *) NULL)
251  {
252  source_wide=(wchar_t *) RelinquishMagickMemory(source_wide);
253  return(-1);
254  }
255  status=_wrename(source_wide,destination_wide);
256  destination_wide=(wchar_t *) RelinquishMagickMemory(destination_wide);
257  source_wide=(wchar_t *) RelinquishMagickMemory(source_wide);
258  return(status);
259 #endif
260 }
261 
262 static inline int stat_utf8(const char *path,struct stat *attributes)
263 {
264 #if !defined(MAGICKCORE_WINDOWS_SUPPORT) || defined(__CYGWIN__) || defined(__MINGW32__)
265  return(stat(path,attributes));
266 #else
267  int
268  status;
269 
270  wchar_t
271  *path_wide;
272 
273  path_wide=create_wchar_path(path);
274  if (path_wide == (WCHAR *) NULL)
275  return(-1);
276  status=wstat(path_wide,attributes);
277  path_wide=(WCHAR *) RelinquishMagickMemory(path_wide);
278  return(status);
279 #endif
280 }
281 
282 #if defined(__cplusplus) || defined(c_plusplus)
283 }
284 #endif
285 
286 #endif
static FILE * popen_utf8(const char *command, const char *type)
Definition: utility-private.h:186
MagickExport ssize_t FormatLocaleString(char *magick_restrict string, const size_t length, const char *magick_restrict format,...)
Definition: locale.c:502
static void getcwd_utf8(char *path, size_t extent)
Definition: utility-private.h:144
char * path
Definition: type.h:56
Definition: mac.h:53
Definition: mac.h:41
static int stat_utf8(const char *path, struct stat *attributes)
Definition: utility-private.h:262
MagickBooleanType
Definition: magick-type.h:189
static int remove_utf8(const char *path)
Definition: utility-private.h:214
MagickExport void * AcquireQuantumMemory(const size_t count, const size_t quantum)
Definition: memory.c:534
static FILE * fopen_utf8(const char *path, const char *mode)
Definition: utility-private.h:116
#define MaxTextExtent
Definition: method-attribute.h:107
static int open_utf8(const char *path, int flags, mode_t mode)
Definition: utility-private.h:166
MagickPrivate MagickBooleanType ShredFile(const char *)
Definition: utility.c:1791
MagickExport struct dirent * readdir(DIR *)
static int rename_utf8(const char *source, const char *destination)
Definition: utility-private.h:234
static int access_utf8(const char *path, int mode)
Definition: utility-private.h:96
static int MagickReadDirectory(DIR *directory, struct dirent *entry, struct dirent **result)
Definition: utility-private.h:32
MagickExport void * RelinquishMagickMemory(void *memory)
Definition: memory.c:1066
#define MagickPrivate
Definition: method-attribute.h:99