]>
Commit | Line | Data |
---|---|---|
e05f3227 | 1 | /* cygpath.cc -- convert pathnames between Windows and Unix format |
ac674bc8 | 2 | Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Red Hat, Inc. |
1fd5e000 CF |
3 | |
4 | This file is part of Cygwin. | |
5 | ||
6 | This software is a copyrighted work licensed under the terms of the | |
7 | Cygwin license. Please consult the file "CYGWIN_LICENSE" for | |
8 | details. */ | |
9 | ||
3cdacffc CV |
10 | #define NOCOMATTRIBUTE |
11 | ||
12 | #include <shlobj.h> | |
1fd5e000 CF |
13 | #include <stdio.h> |
14 | #include <string.h> | |
15 | #include <stdlib.h> | |
16 | #include <limits.h> | |
17 | #include <getopt.h> | |
e73a56e9 | 18 | #include <windows.h> |
138d4f51 CF |
19 | #include <io.h> |
20 | #include <sys/fcntl.h> | |
1fd5e000 | 21 | #include <sys/cygwin.h> |
418068d4 | 22 | #include <ctype.h> |
7c03f799 | 23 | #include <errno.h> |
1fd5e000 | 24 | |
6a344609 CF |
25 | static const char version[] = "$Revision$"; |
26 | ||
1fd5e000 | 27 | static char *prog_name; |
138d4f51 | 28 | static char *file_arg; |
418068d4 | 29 | static int path_flag, unix_flag, windows_flag, absolute_flag; |
5bb52de4 CV |
30 | static int shortname_flag, longname_flag; |
31 | static int ignore_flag, allusers_flag, output_flag; | |
2bd6505b | 32 | static int mixed_flag; |
1050e57c | 33 | static const char *format_type_arg; |
1fd5e000 | 34 | |
6a344609 | 35 | static struct option long_options[] = { |
6a344609 | 36 | {(char *) "absolute", no_argument, NULL, 'a'}, |
1050e57c CF |
37 | {(char *) "close", required_argument, NULL, 'c'}, |
38 | {(char *) "dos", no_argument, NULL, 'd'}, | |
39 | {(char *) "file", required_argument, NULL, 'f'}, | |
40 | {(char *) "help", no_argument, NULL, 'h'}, | |
41 | {(char *) "ignore", no_argument, NULL, 'i'}, | |
42 | {(char *) "long-name", no_argument, NULL, 'l'}, | |
43 | {(char *) "mixed", no_argument, NULL, 'm'}, | |
f135dd3e | 44 | {(char *) "mode", no_argument, NULL, 'M'}, |
6a344609 CF |
45 | {(char *) "option", no_argument, NULL, 'o'}, |
46 | {(char *) "path", no_argument, NULL, 'p'}, | |
1050e57c CF |
47 | {(char *) "short-name", no_argument, NULL, 's'}, |
48 | {(char *) "type", required_argument, NULL, 't'}, | |
6a344609 | 49 | {(char *) "unix", no_argument, NULL, 'u'}, |
6a344609 CF |
50 | {(char *) "version", no_argument, NULL, 'v'}, |
51 | {(char *) "windows", no_argument, NULL, 'w'}, | |
6a344609 CF |
52 | {(char *) "allusers", no_argument, NULL, 'A'}, |
53 | {(char *) "desktop", no_argument, NULL, 'D'}, | |
e355de81 | 54 | {(char *) "homeroot", no_argument, NULL, 'H'}, |
1050e57c CF |
55 | {(char *) "smprograms", no_argument, NULL, 'P'}, |
56 | {(char *) "sysdir", no_argument, NULL, 'S'}, | |
57 | {(char *) "windir", no_argument, NULL, 'W'}, | |
6a344609 | 58 | {0, no_argument, 0, 0} |
1fd5e000 CF |
59 | }; |
60 | ||
f135dd3e | 61 | static char options[] = "ac:df:hilmMopst:uvwADHPSW"; |
9b566b96 | 62 | |
1fd5e000 | 63 | static void |
6a344609 | 64 | usage (FILE * stream, int status) |
1fd5e000 | 65 | { |
45b80bb4 CF |
66 | if (!ignore_flag || !status) |
67 | fprintf (stream, "\ | |
4c634492 JDF |
68 | Usage: %s (-d|-m|-u|-w|-t TYPE) [-f FILE] [OPTION]... NAME...\n\ |
69 | %s [-c HANDLE] \n\ | |
1050e57c | 70 | %s [-ADHPSW] \n\ |
aa275fe0 | 71 | Convert Unix and Windows format paths, or output system path information\n\ |
bd79b736 | 72 | \n\ |
1050e57c | 73 | Output type options:\n\ |
4c634492 | 74 | -d, --dos print DOS (short) form of NAMEs (C:\\PROGRA~1\\)\n\ |
1050e57c | 75 | -m, --mixed like --windows, but with regular slashes (C:/WINNT)\n\ |
f135dd3e | 76 | -M, --mode report on mode of file (binmode or textmode)\n\ |
4c634492 JDF |
77 | -u, --unix (default) print Unix form of NAMEs (/cygdrive/c/winnt)\n\ |
78 | -w, --windows print Windows form of NAMEs (C:\\WINNT)\n\ | |
1050e57c | 79 | -t, --type TYPE print TYPE form: 'dos', 'mixed', 'unix', or 'windows'\n\ |
33bd2d12 | 80 | Path conversion options:\n\ |
1050e57c | 81 | -a, --absolute output absolute path\n\ |
4c634492 | 82 | -l, --long-name print Windows long form of NAMEs (with -w, -m only)\n\ |
1050e57c | 83 | -p, --path NAME is a PATH list (i.e., '/bin:/usr/bin')\n\ |
4c634492 | 84 | -s, --short-name print DOS (short) form of NAMEs (with -w, -m only)\n\ |
1050e57c CF |
85 | System information:\n\ |
86 | -A, --allusers use `All Users' instead of current user for -D, -P\n\ | |
87 | -D, --desktop output `Desktop' directory and exit\n\ | |
88 | -H, --homeroot output `Profiles' directory (home root) and exit\n\ | |
89 | -P, --smprograms output Start Menu `Programs' directory and exit\n\ | |
90 | -S, --sysdir output system directory and exit\n\ | |
91 | -W, --windir output `Windows' directory and exit\n\ | |
5f8e4efa | 92 | ", prog_name, prog_name, prog_name); |
befdf18b CF |
93 | if (ignore_flag) |
94 | /* nothing to do */; | |
95 | else if (stream != stdout) | |
96 | fprintf(stream, "Try `%s --help' for more information.\n", prog_name); | |
97 | else | |
1050e57c | 98 | { |
befdf18b | 99 | fprintf (stream, "\ |
33bd2d12 | 100 | Other options:\n\ |
1050e57c CF |
101 | -f, --file FILE read FILE for input; use - to read from STDIN\n\ |
102 | -o, --option read options from FILE as well (for use with --file)\n\ | |
103 | -c, --close HANDLE close HANDLE (for use in captured process)\n\ | |
104 | -i, --ignore ignore missing argument\n\ | |
105 | -h, --help output usage information and exit\n\ | |
02eb4ad4 | 106 | -v, --version output version information and exit\n\ |
1050e57c CF |
107 | "); |
108 | } | |
45b80bb4 CF |
109 | exit (ignore_flag ? 0 : status); |
110 | } | |
111 | ||
112 | static char * | |
113 | get_short_paths (char *path) | |
114 | { | |
115 | char *sbuf; | |
116 | char *sptr; | |
117 | char *next; | |
118 | char *ptr = path; | |
119 | char *end = strrchr (path, 0); | |
120 | DWORD acc = 0; | |
121 | DWORD len; | |
122 | ||
123 | while (ptr != NULL) | |
45b80bb4 | 124 | { |
6a344609 CF |
125 | next = ptr; |
126 | ptr = strchr (ptr, ';'); | |
127 | if (ptr) | |
128 | *ptr++ = 0; | |
129 | len = GetShortPathName (next, NULL, 0); | |
cc3ce0bb | 130 | if (!len) |
6a344609 CF |
131 | { |
132 | fprintf (stderr, "%s: cannot create short name of %s\n", prog_name, | |
133 | next); | |
134 | exit (2); | |
135 | } | |
136 | acc += len + 1; | |
45b80bb4 | 137 | } |
6a344609 | 138 | sptr = sbuf = (char *) malloc (acc + 1); |
45b80bb4 | 139 | if (sbuf == NULL) |
45b80bb4 | 140 | { |
6a344609 CF |
141 | fprintf (stderr, "%s: out of memory\n", prog_name); |
142 | exit (1); | |
45b80bb4 | 143 | } |
6a344609 CF |
144 | ptr = path; |
145 | for (;;) | |
146 | { | |
e355de81 | 147 | len = GetShortPathName (ptr, sptr, acc); |
cc3ce0bb | 148 | if (!len) |
6a344609 CF |
149 | { |
150 | fprintf (stderr, "%s: cannot create short name of %s\n", prog_name, | |
151 | ptr); | |
152 | exit (2); | |
153 | } | |
45b80bb4 | 154 | |
6a344609 CF |
155 | ptr = strrchr (ptr, 0); |
156 | sptr = strrchr (sptr, 0); | |
157 | if (ptr == end) | |
158 | break; | |
159 | *sptr = ';'; | |
160 | ++ptr, ++sptr; | |
5bb52de4 | 161 | acc -= len + 1; |
6a344609 | 162 | } |
45b80bb4 CF |
163 | return sbuf; |
164 | } | |
165 | ||
166 | static char * | |
167 | get_short_name (const char *filename) | |
168 | { | |
5bb52de4 CV |
169 | char *sbuf, buf[MAX_PATH]; |
170 | DWORD len = GetShortPathName (filename, buf, MAX_PATH); | |
cc3ce0bb | 171 | if (!len) |
6a344609 CF |
172 | { |
173 | fprintf (stderr, "%s: cannot create short name of %s\n", prog_name, | |
174 | filename); | |
175 | exit (2); | |
176 | } | |
177 | sbuf = (char *) malloc (++len); | |
45b80bb4 | 178 | if (sbuf == NULL) |
6a344609 CF |
179 | { |
180 | fprintf (stderr, "%s: out of memory\n", prog_name); | |
181 | exit (1); | |
182 | } | |
5bb52de4 CV |
183 | return strcpy (sbuf, buf); |
184 | } | |
185 | ||
cf157504 | 186 | static DWORD WINAPI |
5bb52de4 CV |
187 | get_long_path_name_w32impl (LPCSTR src, LPSTR sbuf, DWORD) |
188 | { | |
189 | char buf1[MAX_PATH], buf2[MAX_PATH], *ptr; | |
190 | const char *pelem, *next; | |
191 | WIN32_FIND_DATA w32_fd; | |
192 | int len; | |
cf157504 | 193 | |
5bb52de4 CV |
194 | strcpy (buf1, src); |
195 | *buf2 = 0; | |
196 | pelem = src; | |
197 | ptr = buf2; | |
198 | while (pelem) | |
199 | { | |
200 | next = pelem; | |
201 | if (*next == '\\') | |
202 | { | |
203 | strcat (ptr++, "\\"); | |
204 | pelem++; | |
205 | if (!*pelem) | |
206 | break; | |
207 | continue; | |
208 | } | |
209 | pelem = strchr (next, '\\'); | |
210 | len = pelem ? (pelem++ - next) : strlen (next); | |
211 | strncpy (ptr, next, len); | |
212 | ptr[len] = 0; | |
213 | if (next[1] != ':' && strcmp(next, ".") && strcmp(next, "..")) | |
214 | { | |
215 | if (FindFirstFile (buf2, &w32_fd) != INVALID_HANDLE_VALUE) | |
216 | strcpy (ptr, w32_fd.cFileName); | |
217 | } | |
218 | ptr += strlen (ptr); | |
219 | if (pelem) | |
220 | { | |
221 | *ptr++ = '\\'; | |
222 | *ptr = 0; | |
223 | } | |
224 | } | |
225 | if (sbuf) | |
226 | strcpy (sbuf, buf2); | |
227 | SetLastError (0); | |
228 | return strlen (buf2) + (sbuf ? 0 : 1); | |
229 | } | |
230 | ||
231 | static char * | |
cf157504 | 232 | get_long_name (const char *filename, DWORD& len) |
5bb52de4 | 233 | { |
cf157504 CF |
234 | char *sbuf, buf[MAX_PATH]; |
235 | static HINSTANCE k32 = LoadLibrary ("kernel32.dll"); | |
236 | static DWORD (WINAPI *GetLongPathName) (LPCSTR, LPSTR, DWORD) = | |
4fc92aa7 | 237 | (DWORD (WINAPI *) (LPCSTR, LPSTR, DWORD)) GetProcAddress (k32, "GetLongPathNameA"); |
cf157504 CF |
238 | if (!GetLongPathName) |
239 | GetLongPathName = get_long_path_name_w32impl; | |
5bb52de4 | 240 | |
cf157504 | 241 | len = GetLongPathName (filename, buf, MAX_PATH); |
bc31293a | 242 | if (len == 0) |
5bb52de4 | 243 | { |
acc31d1a CV |
244 | DWORD err = GetLastError (); |
245 | ||
246 | if (err == ERROR_INVALID_PARAMETER) | |
bc31293a CV |
247 | { |
248 | fprintf (stderr, "%s: cannot create long name of %s\n", prog_name, | |
249 | filename); | |
250 | exit (2); | |
251 | } | |
acc31d1a CV |
252 | else if (err == ERROR_FILE_NOT_FOUND) |
253 | len = get_long_path_name_w32impl (filename, buf, MAX_PATH); | |
254 | else | |
255 | { | |
256 | buf[0] = '\0'; | |
257 | strncat (buf, filename, MAX_PATH - 1); | |
258 | len = strlen (buf); | |
259 | } | |
5bb52de4 | 260 | } |
cf157504 CF |
261 | sbuf = (char *) malloc (len + 1); |
262 | if (!sbuf) | |
5bb52de4 CV |
263 | { |
264 | fprintf (stderr, "%s: out of memory\n", prog_name); | |
265 | exit (1); | |
266 | } | |
cf157504 | 267 | return strcpy (sbuf, buf); |
5bb52de4 CV |
268 | } |
269 | ||
270 | static char * | |
cf157504 | 271 | get_long_paths (char *path) |
5bb52de4 | 272 | { |
cf157504 CF |
273 | char *sbuf; |
274 | char *ptr; | |
275 | int n = 1; | |
276 | ||
277 | ptr = path; | |
278 | while ((ptr = strchr (ptr, ';'))) | |
6a344609 | 279 | { |
cf157504 CF |
280 | ptr++; |
281 | n++; | |
6a344609 | 282 | } |
cf157504 CF |
283 | |
284 | char *paths[n]; | |
285 | DWORD acc = 0; | |
286 | int i; | |
287 | if (!n) | |
288 | return strdup (""); | |
289 | ||
290 | for (i = 0, ptr = path; ptr; i++) | |
291 | { | |
292 | DWORD len; | |
293 | char *next = ptr; | |
294 | ptr = strchr (ptr, ';'); | |
295 | if (ptr) | |
296 | *ptr++ = 0; | |
297 | paths[i] = get_long_name (next, len); | |
298 | acc += len + 1; | |
299 | } | |
300 | ||
301 | sbuf = (char *) malloc (acc + 1); | |
5bb52de4 CV |
302 | if (sbuf == NULL) |
303 | { | |
304 | fprintf (stderr, "%s: out of memory\n", prog_name); | |
305 | exit (1); | |
306 | } | |
cf157504 CF |
307 | |
308 | sbuf[0] = '\0'; | |
309 | for (i = 0; i < n; i++) | |
310 | { | |
311 | strcat (strcat (sbuf, paths[i]), ";"); | |
312 | free (paths[i]); | |
313 | } | |
314 | ||
315 | strchr (sbuf, '\0')[-1] = '\0'; | |
316 | return sbuf; | |
5bb52de4 CV |
317 | } |
318 | ||
33bd2d12 CF |
319 | static void |
320 | convert_slashes (char* name) | |
321 | { | |
322 | while ((name = strchr (name, '\\')) != NULL) | |
323 | { | |
324 | if (*name == '\\') | |
325 | *name = '/'; | |
326 | name++; | |
327 | } | |
328 | } | |
329 | ||
330 | static char * | |
331 | get_mixed_name (const char* filename) | |
332 | { | |
333 | char* mixed_buf = strdup (filename); | |
334 | ||
335 | if (mixed_buf == NULL) | |
336 | { | |
337 | fprintf (stderr, "%s: out of memory\n", prog_name); | |
338 | exit (1); | |
339 | } | |
340 | ||
341 | convert_slashes (mixed_buf); | |
342 | ||
343 | return mixed_buf; | |
344 | } | |
345 | ||
5bb52de4 CV |
346 | static void |
347 | dowin (char option) | |
348 | { | |
349 | char *buf, buf1[MAX_PATH], buf2[MAX_PATH]; | |
350 | DWORD len = MAX_PATH; | |
351 | WIN32_FIND_DATA w32_fd; | |
30352c26 | 352 | LPITEMIDLIST id; |
cf157504 | 353 | HINSTANCE k32; |
5bb52de4 | 354 | BOOL (*GetProfilesDirectoryAPtr) (LPSTR, LPDWORD) = 0; |
cf157504 | 355 | |
5bb52de4 CV |
356 | buf = buf1; |
357 | switch (option) | |
358 | { | |
359 | case 'D': | |
30352c26 CV |
360 | SHGetSpecialFolderLocation (NULL, allusers_flag ? |
361 | CSIDL_COMMON_DESKTOPDIRECTORY : CSIDL_DESKTOPDIRECTORY, &id); | |
362 | SHGetPathFromIDList (id, buf); | |
363 | /* This if clause is a Fix for Win95 without any "All Users" */ | |
364 | if (strlen (buf) == 0) | |
365 | { | |
366 | SHGetSpecialFolderLocation (NULL, CSIDL_DESKTOPDIRECTORY, &id); | |
367 | SHGetPathFromIDList (id, buf); | |
368 | } | |
5bb52de4 CV |
369 | break; |
370 | ||
371 | case 'P': | |
30352c26 CV |
372 | SHGetSpecialFolderLocation (NULL, allusers_flag ? |
373 | CSIDL_COMMON_PROGRAMS : CSIDL_PROGRAMS, &id); | |
374 | SHGetPathFromIDList (id, buf); | |
375 | /* This if clause is a Fix for Win95 without any "All Users" */ | |
376 | if (strlen (buf) == 0) | |
377 | { | |
378 | SHGetSpecialFolderLocation (NULL, CSIDL_PROGRAMS, &id); | |
379 | SHGetPathFromIDList (id, buf); | |
380 | } | |
5bb52de4 CV |
381 | break; |
382 | ||
383 | case 'H': | |
cf157504 CF |
384 | k32 = LoadLibrary ("userenv"); |
385 | if (k32) | |
5bb52de4 | 386 | GetProfilesDirectoryAPtr = (BOOL (*) (LPSTR, LPDWORD)) |
cf157504 | 387 | GetProcAddress (k32, "GetProfilesDirectoryA"); |
5bb52de4 | 388 | if (GetProfilesDirectoryAPtr) |
33bd2d12 | 389 | (*GetProfilesDirectoryAPtr) (buf, &len); |
5bb52de4 CV |
390 | else |
391 | { | |
392 | GetWindowsDirectory (buf, MAX_PATH); | |
393 | strcat (buf, "\\Profiles"); | |
394 | } | |
395 | break; | |
396 | ||
397 | case 'S': | |
398 | GetSystemDirectory (buf, MAX_PATH); | |
399 | FindFirstFile (buf, &w32_fd); | |
400 | strcpy (strrchr (buf, '\\') + 1, w32_fd.cFileName); | |
401 | break; | |
402 | ||
403 | case 'W': | |
404 | GetWindowsDirectory (buf, MAX_PATH); | |
405 | break; | |
406 | ||
407 | default: | |
408 | usage (stderr, 1); | |
409 | } | |
410 | ||
411 | if (!windows_flag) | |
412 | { | |
7c03f799 CF |
413 | if (cygwin_conv_to_posix_path (buf, buf2)) |
414 | fprintf (stderr, "%s: error converting \"%s\" - %s\n", | |
415 | prog_name, buf, strerror (errno)); | |
416 | else | |
417 | buf = buf2; | |
5bb52de4 CV |
418 | } |
419 | else | |
420 | { | |
421 | if (shortname_flag) | |
33bd2d12 CF |
422 | buf = get_short_name (buf); |
423 | if (mixed_flag) | |
424 | buf = get_mixed_name (buf); | |
5bb52de4 CV |
425 | } |
426 | printf ("%s\n", buf); | |
427 | exit (0); | |
1fd5e000 CF |
428 | } |
429 | ||
f135dd3e CF |
430 | static void |
431 | report_mode (char *filename) | |
432 | { | |
433 | switch (cygwin_internal (CW_GET_BINMODE, filename)) | |
434 | { | |
435 | case O_BINARY: | |
436 | printf ("%s: binary\n", filename); | |
437 | break; | |
438 | case O_TEXT: | |
439 | printf ("%s: text\n", filename); | |
440 | break; | |
441 | default: | |
442 | fprintf (stderr, "%s: file '%s' - %s\n", prog_name, filename, | |
443 | strerror (errno)); | |
444 | break; | |
445 | } | |
446 | } | |
447 | ||
138d4f51 | 448 | static void |
418068d4 | 449 | doit (char *filename) |
138d4f51 CF |
450 | { |
451 | char *buf; | |
cf157504 | 452 | DWORD len; |
7c03f799 | 453 | int err; |
6a344609 | 454 | int (*conv_func) (const char *, char *); |
138d4f51 | 455 | |
6a344609 | 456 | if (!path_flag) |
c02e32c9 | 457 | { |
cf157504 CF |
458 | len = strlen (filename); |
459 | if (len) | |
7ca68b7e | 460 | len += MAX_PATH + 1001; |
cf157504 CF |
461 | else if (ignore_flag) |
462 | exit (0); | |
463 | else | |
6a344609 | 464 | { |
cf157504 CF |
465 | fprintf (stderr, "%s: can't convert empty path\n", prog_name); |
466 | exit (1); | |
6a344609 | 467 | } |
c02e32c9 | 468 | } |
cf157504 CF |
469 | else if (unix_flag) |
470 | len = cygwin_win32_to_posix_path_list_buf_size (filename); | |
138d4f51 | 471 | else |
cf157504 | 472 | len = cygwin_posix_to_win32_path_list_buf_size (filename); |
138d4f51 CF |
473 | |
474 | buf = (char *) malloc (len); | |
475 | if (buf == NULL) | |
476 | { | |
477 | fprintf (stderr, "%s: out of memory\n", prog_name); | |
478 | exit (1); | |
479 | } | |
480 | ||
481 | if (path_flag) | |
482 | { | |
483 | if (unix_flag) | |
7c03f799 | 484 | err = cygwin_win32_to_posix_path_list (filename, buf); |
138d4f51 | 485 | else |
6a344609 | 486 | { |
7c03f799 CF |
487 | err = cygwin_posix_to_win32_path_list (filename, buf); |
488 | if (err) | |
489 | /* oops */; | |
6a344609 CF |
490 | if (shortname_flag) |
491 | buf = get_short_paths (buf); | |
5bb52de4 CV |
492 | if (longname_flag) |
493 | buf = get_long_paths (buf); | |
2bd6505b CF |
494 | if (mixed_flag) |
495 | buf = get_mixed_name (buf); | |
6a344609 | 496 | } |
7c03f799 CF |
497 | if (err) |
498 | { | |
499 | fprintf (stderr, "%s: error converting \"%s\" - %s\n", | |
500 | prog_name, filename, strerror (errno)); | |
501 | exit (1); | |
502 | } | |
138d4f51 CF |
503 | } |
504 | else | |
505 | { | |
506 | if (unix_flag) | |
6a344609 CF |
507 | conv_func = (absolute_flag ? cygwin_conv_to_full_posix_path : |
508 | cygwin_conv_to_posix_path); | |
138d4f51 | 509 | else |
6a344609 CF |
510 | conv_func = (absolute_flag ? cygwin_conv_to_full_win32_path : |
511 | cygwin_conv_to_win32_path); | |
7c03f799 | 512 | err = conv_func (filename, buf); |
7c03f799 | 513 | if (err) |
6a344609 | 514 | { |
7c03f799 CF |
515 | fprintf (stderr, "%s: error converting \"%s\" - %s\n", |
516 | prog_name, filename, strerror (errno)); | |
6a344609 CF |
517 | exit (1); |
518 | } | |
5bb52de4 CV |
519 | if (!unix_flag) |
520 | { | |
7ca68b7e CF |
521 | if (shortname_flag) |
522 | buf = get_short_name (buf); | |
523 | if (longname_flag) | |
524 | buf = get_long_name (buf, len); | |
4fc92aa7 CV |
525 | if (mixed_flag) |
526 | buf = get_mixed_name (buf); | |
5bb52de4 | 527 | } |
138d4f51 CF |
528 | } |
529 | ||
530 | puts (buf); | |
531 | } | |
532 | ||
6a344609 CF |
533 | static void |
534 | print_version () | |
535 | { | |
536 | const char *v = strchr (version, ':'); | |
537 | int len; | |
538 | if (!v) | |
539 | { | |
540 | v = "?"; | |
541 | len = 1; | |
542 | } | |
543 | else | |
544 | { | |
545 | v += 2; | |
546 | len = strchr (v, ' ') - v; | |
547 | } | |
548 | printf ("\ | |
549 | cygpath (cygwin) %.*s\n\ | |
550 | Path Conversion Utility\n\ | |
ac674bc8 | 551 | Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 Red Hat, Inc.\n\ |
9b566b96 JDF |
552 | Compiled on %s\n\ |
553 | ", len, v, __DATE__); | |
6a344609 CF |
554 | } |
555 | ||
1fd5e000 CF |
556 | int |
557 | main (int argc, char **argv) | |
558 | { | |
6a344609 | 559 | int c, o = 0; |
418068d4 | 560 | int options_from_file_flag; |
f135dd3e | 561 | int mode_flag; |
1fd5e000 CF |
562 | |
563 | prog_name = strrchr (argv[0], '/'); | |
564 | if (prog_name == NULL) | |
565 | prog_name = strrchr (argv[0], '\\'); | |
566 | if (prog_name == NULL) | |
567 | prog_name = argv[0]; | |
c02e32c9 CF |
568 | else |
569 | prog_name++; | |
1fd5e000 CF |
570 | |
571 | path_flag = 0; | |
1050e57c | 572 | unix_flag = 1; |
1fd5e000 | 573 | windows_flag = 0; |
45b80bb4 | 574 | shortname_flag = 0; |
5bb52de4 | 575 | longname_flag = 0; |
2bd6505b | 576 | mixed_flag = 0; |
45b80bb4 | 577 | ignore_flag = 0; |
418068d4 | 578 | options_from_file_flag = 0; |
3cdacffc CV |
579 | allusers_flag = 0; |
580 | output_flag = 0; | |
f135dd3e | 581 | mode_flag = 0; |
9b566b96 | 582 | while ((c = getopt_long (argc, argv, options, |
2bd6505b | 583 | long_options, (int *) NULL)) != EOF) |
1fd5e000 CF |
584 | { |
585 | switch (c) | |
586 | { | |
418068d4 CF |
587 | case 'a': |
588 | absolute_flag = 1; | |
589 | break; | |
590 | ||
591 | case 'c': | |
592 | CloseHandle ((HANDLE) strtoul (optarg, NULL, 16)); | |
593 | break; | |
594 | ||
1050e57c | 595 | case 'd': |
cf157504 | 596 | if (windows_flag) |
1050e57c CF |
597 | usage (stderr, 1); |
598 | unix_flag = 0; | |
599 | windows_flag = 1; | |
600 | shortname_flag = 1; | |
601 | break; | |
602 | ||
138d4f51 CF |
603 | case 'f': |
604 | file_arg = optarg; | |
605 | break; | |
606 | ||
f135dd3e CF |
607 | case 'M': |
608 | mode_flag = 1; | |
609 | break; | |
610 | ||
418068d4 CF |
611 | case 'o': |
612 | options_from_file_flag = 1; | |
613 | break; | |
614 | ||
1fd5e000 CF |
615 | case 'p': |
616 | path_flag = 1; | |
617 | break; | |
618 | ||
619 | case 'u': | |
1050e57c | 620 | if (windows_flag || mixed_flag) |
1fd5e000 CF |
621 | usage (stderr, 1); |
622 | unix_flag = 1; | |
623 | break; | |
624 | ||
625 | case 'w': | |
1050e57c | 626 | if (windows_flag || mixed_flag) |
1fd5e000 | 627 | usage (stderr, 1); |
1050e57c | 628 | unix_flag = 0; |
1fd5e000 CF |
629 | windows_flag = 1; |
630 | break; | |
631 | ||
1050e57c CF |
632 | case 'm': |
633 | unix_flag = 0; | |
634 | windows_flag = 1; | |
635 | mixed_flag = 1; | |
636 | break; | |
637 | ||
5bb52de4 | 638 | case 'l': |
5bb52de4 CV |
639 | longname_flag = 1; |
640 | break; | |
641 | ||
45b80bb4 | 642 | case 's': |
45b80bb4 CF |
643 | shortname_flag = 1; |
644 | break; | |
645 | ||
2bd6505b | 646 | case 't': |
1050e57c | 647 | if (optarg == NULL) |
2bd6505b CF |
648 | usage (stderr, 1); |
649 | ||
1050e57c CF |
650 | format_type_arg = (*optarg == '=') ? (optarg + 1) : (optarg); |
651 | if (strcasecmp (format_type_arg, "dos") == 0) | |
cf157504 CF |
652 | { |
653 | if (windows_flag || longname_flag) | |
654 | usage (stderr, 1); | |
655 | unix_flag = 0; | |
656 | windows_flag = 1; | |
657 | shortname_flag = 1; | |
658 | } | |
1050e57c | 659 | else if (strcasecmp (format_type_arg, "mixed") == 0) |
cf157504 CF |
660 | { |
661 | unix_flag = 0; | |
2bd6505b | 662 | mixed_flag = 1; |
cf157504 | 663 | } |
1050e57c | 664 | else if (strcasecmp (format_type_arg, "unix") == 0) |
cf157504 CF |
665 | { |
666 | if (windows_flag) | |
667 | usage (stderr, 1); | |
1050e57c | 668 | unix_flag = 1; |
cf157504 | 669 | } |
1050e57c | 670 | else if (strcasecmp (format_type_arg, "windows") == 0) |
cf157504 CF |
671 | { |
672 | if (mixed_flag) | |
673 | usage (stderr, 1); | |
674 | unix_flag = 0; | |
675 | windows_flag = 1; | |
676 | } | |
2bd6505b CF |
677 | else |
678 | usage (stderr, 1); | |
679 | break; | |
680 | ||
3cdacffc CV |
681 | case 'A': |
682 | allusers_flag = 1; | |
683 | break; | |
684 | ||
685 | case 'D': | |
e355de81 | 686 | case 'H': |
3cdacffc | 687 | case 'P': |
f00c1d2c | 688 | case 'S': |
3cdacffc CV |
689 | case 'W': |
690 | if (output_flag) | |
691 | usage (stderr, 1); | |
692 | output_flag = 1; | |
e355de81 | 693 | o = c; |
3cdacffc | 694 | break; |
f00c1d2c | 695 | |
45b80bb4 CF |
696 | case 'i': |
697 | ignore_flag = 1; | |
698 | break; | |
699 | ||
1fd5e000 CF |
700 | case 'h': |
701 | usage (stdout, 0); | |
702 | break; | |
703 | ||
704 | case 'v': | |
6a344609 | 705 | print_version (); |
1fd5e000 CF |
706 | exit (0); |
707 | ||
708 | default: | |
709 | usage (stderr, 1); | |
710 | break; | |
711 | } | |
712 | } | |
713 | ||
418068d4 CF |
714 | if (options_from_file_flag && !file_arg) |
715 | usage (stderr, 1); | |
716 | ||
1050e57c CF |
717 | if (longname_flag && !windows_flag) |
718 | usage (stderr, 1); | |
719 | ||
720 | if (shortname_flag && !windows_flag) | |
721 | usage (stderr, 1); | |
722 | ||
723 | if (!unix_flag && !windows_flag && !mixed_flag && !options_from_file_flag) | |
1fd5e000 CF |
724 | usage (stderr, 1); |
725 | ||
138d4f51 | 726 | if (!file_arg) |
1fd5e000 | 727 | { |
5bb52de4 CV |
728 | if (output_flag) |
729 | dowin (o); | |
730 | ||
0a5ea947 | 731 | if (optind > argc - 1) |
138d4f51 | 732 | usage (stderr, 1); |
1fd5e000 | 733 | |
f135dd3e CF |
734 | for (int i = optind; argv[i]; i++) |
735 | if (mode_flag) | |
736 | report_mode (argv[i]); | |
737 | else | |
738 | doit (argv[i]); | |
138d4f51 | 739 | } |
1fd5e000 CF |
740 | else |
741 | { | |
138d4f51 CF |
742 | FILE *fp; |
743 | char buf[PATH_MAX * 2 + 1]; | |
1fd5e000 | 744 | |
138d4f51 CF |
745 | if (argv[optind]) |
746 | usage (stderr, 1); | |
1fd5e000 | 747 | |
138d4f51 CF |
748 | if (strcmp (file_arg, "-") != 0) |
749 | fp = fopen (file_arg, "rt"); | |
1fd5e000 | 750 | else |
138d4f51 CF |
751 | { |
752 | fp = stdin; | |
753 | setmode (0, O_TEXT); | |
754 | } | |
755 | if (fp == NULL) | |
756 | { | |
757 | perror ("cygpath"); | |
758 | exit (1); | |
759 | } | |
1fd5e000 | 760 | |
418068d4 | 761 | setbuf (stdout, NULL); |
138d4f51 CF |
762 | while (fgets (buf, sizeof (buf), fp) != NULL) |
763 | { | |
418068d4 CF |
764 | char *s = buf; |
765 | char *p = strchr (s, '\n'); | |
138d4f51 CF |
766 | if (p) |
767 | *p = '\0'; | |
418068d4 CF |
768 | if (options_from_file_flag && *s == '-') |
769 | { | |
770 | char c; | |
771 | for (c = *++s; c && !isspace (c); c = *++s) | |
772 | switch (c) | |
773 | { | |
774 | case 'a': | |
775 | absolute_flag = 1; | |
776 | break; | |
45b80bb4 CF |
777 | case 'i': |
778 | ignore_flag = 1; | |
779 | break; | |
780 | case 's': | |
781 | shortname_flag = 1; | |
5bb52de4 CV |
782 | longname_flag = 0; |
783 | break; | |
784 | case 'l': | |
785 | shortname_flag = 0; | |
786 | longname_flag = 1; | |
45b80bb4 | 787 | break; |
1050e57c CF |
788 | case 'm': |
789 | unix_flag = 0; | |
790 | windows_flag = 1; | |
791 | mixed_flag = 1; | |
418068d4 CF |
792 | case 'w': |
793 | unix_flag = 0; | |
794 | windows_flag = 1; | |
795 | break; | |
796 | case 'u': | |
797 | windows_flag = 0; | |
798 | unix_flag = 1; | |
799 | break; | |
800 | case 'p': | |
801 | path_flag = 1; | |
5bb52de4 CV |
802 | break; |
803 | case 'D': | |
804 | case 'H': | |
805 | case 'P': | |
806 | case 'S': | |
807 | case 'W': | |
2bd6505b | 808 | output_flag = 1; |
5bb52de4 | 809 | o = c; |
2bd6505b | 810 | break; |
418068d4 CF |
811 | } |
812 | if (*s) | |
813 | do | |
814 | s++; | |
815 | while (*s && isspace (*s)); | |
816 | } | |
5bb52de4 | 817 | if (*s && !output_flag) |
418068d4 | 818 | doit (s); |
5bb52de4 CV |
819 | if (!*s && output_flag) |
820 | dowin (o); | |
138d4f51 CF |
821 | } |
822 | } | |
1fd5e000 CF |
823 | |
824 | exit (0); | |
825 | } |