http: use credential API to handle proxy authentication
[git] / test-path-utils.c
1 #include "cache.h"
2 #include "string-list.h"
3
4 /*
5  * A "string_list_each_func_t" function that normalizes an entry from
6  * GIT_CEILING_DIRECTORIES.  If the path is unusable for some reason,
7  * die with an explanation.
8  */
9 static int normalize_ceiling_entry(struct string_list_item *item, void *unused)
10 {
11         const char *ceil = item->string;
12         int len = strlen(ceil);
13         char buf[PATH_MAX+1];
14
15         if (len == 0)
16                 die("Empty path is not supported");
17         if (len > PATH_MAX)
18                 die("Path \"%s\" is too long", ceil);
19         if (!is_absolute_path(ceil))
20                 die("Path \"%s\" is not absolute", ceil);
21         if (normalize_path_copy(buf, ceil) < 0)
22                 die("Path \"%s\" could not be normalized", ceil);
23         len = strlen(buf);
24         free(item->string);
25         item->string = xstrdup(buf);
26         return 1;
27 }
28
29 static void normalize_argv_string(const char **var, const char *input)
30 {
31         if (!strcmp(input, "<null>"))
32                 *var = NULL;
33         else if (!strcmp(input, "<empty>"))
34                 *var = "";
35         else
36                 *var = input;
37
38         if (*var && (**var == '<' || **var == '('))
39                 die("Bad value: %s\n", input);
40 }
41
42 int main(int argc, char **argv)
43 {
44         if (argc == 3 && !strcmp(argv[1], "normalize_path_copy")) {
45                 char *buf = xmalloc(PATH_MAX + 1);
46                 int rv = normalize_path_copy(buf, argv[2]);
47                 if (rv)
48                         buf = "++failed++";
49                 puts(buf);
50                 return 0;
51         }
52
53         if (argc >= 2 && !strcmp(argv[1], "real_path")) {
54                 while (argc > 2) {
55                         puts(real_path(argv[2]));
56                         argc--;
57                         argv++;
58                 }
59                 return 0;
60         }
61
62         if (argc >= 2 && !strcmp(argv[1], "absolute_path")) {
63                 while (argc > 2) {
64                         puts(absolute_path(argv[2]));
65                         argc--;
66                         argv++;
67                 }
68                 return 0;
69         }
70
71         if (argc == 4 && !strcmp(argv[1], "longest_ancestor_length")) {
72                 int len;
73                 struct string_list ceiling_dirs = STRING_LIST_INIT_DUP;
74                 char *path = xstrdup(argv[2]);
75
76                 /*
77                  * We have to normalize the arguments because under
78                  * Windows, bash mangles arguments that look like
79                  * absolute POSIX paths or colon-separate lists of
80                  * absolute POSIX paths into DOS paths (e.g.,
81                  * "/foo:/foo/bar" might be converted to
82                  * "D:\Src\msysgit\foo;D:\Src\msysgit\foo\bar"),
83                  * whereas longest_ancestor_length() requires paths
84                  * that use forward slashes.
85                  */
86                 if (normalize_path_copy(path, path))
87                         die("Path \"%s\" could not be normalized", argv[2]);
88                 string_list_split(&ceiling_dirs, argv[3], PATH_SEP, -1);
89                 filter_string_list(&ceiling_dirs, 0,
90                                    normalize_ceiling_entry, NULL);
91                 len = longest_ancestor_length(path, &ceiling_dirs);
92                 string_list_clear(&ceiling_dirs, 0);
93                 free(path);
94                 printf("%d\n", len);
95                 return 0;
96         }
97
98         if (argc >= 4 && !strcmp(argv[1], "prefix_path")) {
99                 char *prefix = argv[2];
100                 int prefix_len = strlen(prefix);
101                 int nongit_ok;
102                 setup_git_directory_gently(&nongit_ok);
103                 while (argc > 3) {
104                         puts(prefix_path(prefix, prefix_len, argv[3]));
105                         argc--;
106                         argv++;
107                 }
108                 return 0;
109         }
110
111         if (argc == 4 && !strcmp(argv[1], "strip_path_suffix")) {
112                 char *prefix = strip_path_suffix(argv[2], argv[3]);
113                 printf("%s\n", prefix ? prefix : "(null)");
114                 return 0;
115         }
116
117         if (argc == 3 && !strcmp(argv[1], "print_path")) {
118                 puts(argv[2]);
119                 return 0;
120         }
121
122         if (argc == 4 && !strcmp(argv[1], "relative_path")) {
123                 struct strbuf sb = STRBUF_INIT;
124                 const char *in, *prefix, *rel;
125                 normalize_argv_string(&in, argv[2]);
126                 normalize_argv_string(&prefix, argv[3]);
127                 rel = relative_path(in, prefix, &sb);
128                 if (!rel)
129                         puts("(null)");
130                 else
131                         puts(strlen(rel) > 0 ? rel : "(empty)");
132                 strbuf_release(&sb);
133                 return 0;
134         }
135
136         fprintf(stderr, "%s: unknown function name: %s\n", argv[0],
137                 argv[1] ? argv[1] : "(there was none)");
138         return 1;
139 }