Make git-repo-config a builtin
[git] / git.c
1 #include <stdio.h>
2 #include <sys/types.h>
3 #include <sys/stat.h>
4 #include <dirent.h>
5 #include <unistd.h>
6 #include <stdlib.h>
7 #include <string.h>
8 #include <errno.h>
9 #include <limits.h>
10 #include <stdarg.h>
11 #include "git-compat-util.h"
12 #include "exec_cmd.h"
13 #include "cache.h"
14 #include "quote.h"
15
16 #include "builtin.h"
17
18 const char git_usage_string[] =
19         "git [--version] [--exec-path[=GIT_EXEC_PATH]] [--help] COMMAND [ ARGS ]";
20
21 static void prepend_to_path(const char *dir, int len)
22 {
23         const char *old_path = getenv("PATH");
24         char *path;
25         int path_len = len;
26
27         if (!old_path)
28                 old_path = "/usr/local/bin:/usr/bin:/bin";
29
30         path_len = len + strlen(old_path) + 1;
31
32         path = malloc(path_len + 1);
33
34         memcpy(path, dir, len);
35         path[len] = ':';
36         memcpy(path + len + 1, old_path, path_len - len);
37
38         setenv("PATH", path, 1);
39 }
40
41 static int handle_options(const char*** argv, int* argc)
42 {
43         int handled = 0;
44
45         while (*argc > 0) {
46                 const char *cmd = (*argv)[0];
47                 if (cmd[0] != '-')
48                         break;
49
50                 /*
51                  * For legacy reasons, the "version" and "help"
52                  * commands can be written with "--" prepended
53                  * to make them look like flags.
54                  */
55                 if (!strcmp(cmd, "--help") || !strcmp(cmd, "--version"))
56                         break;
57
58                 /*
59                  * Check remaining flags.
60                  */
61                 if (!strncmp(cmd, "--exec-path", 11)) {
62                         cmd += 11;
63                         if (*cmd == '=')
64                                 git_set_exec_path(cmd + 1);
65                         else {
66                                 puts(git_exec_path());
67                                 exit(0);
68                         }
69                 } else if (!strcmp(cmd, "-p") || !strcmp(cmd, "--paginate")) {
70                         setup_pager();
71                 } else if (!strcmp(cmd, "--git-dir")) {
72                         if (*argc < 1)
73                                 return -1;
74                         setenv("GIT_DIR", (*argv)[1], 1);
75                         (*argv)++;
76                         (*argc)--;
77                 } else if (!strncmp(cmd, "--git-dir=", 10)) {
78                         setenv("GIT_DIR", cmd + 10, 1);
79                 } else if (!strcmp(cmd, "--bare")) {
80                         static char git_dir[1024];
81                         setenv("GIT_DIR", getcwd(git_dir, 1024), 1);
82                 } else {
83                         fprintf(stderr, "Unknown option: %s\n", cmd);
84                         usage(git_usage_string);
85                 }
86
87                 (*argv)++;
88                 (*argc)--;
89                 handled++;
90         }
91         return handled;
92 }
93
94 static const char *alias_command;
95 static char *alias_string = NULL;
96
97 static int git_alias_config(const char *var, const char *value)
98 {
99         if (!strncmp(var, "alias.", 6) && !strcmp(var + 6, alias_command)) {
100                 alias_string = strdup(value);
101         }
102         return 0;
103 }
104
105 static int split_cmdline(char *cmdline, const char ***argv)
106 {
107         int src, dst, count = 0, size = 16;
108         char quoted = 0;
109
110         *argv = malloc(sizeof(char*) * size);
111
112         /* split alias_string */
113         (*argv)[count++] = cmdline;
114         for (src = dst = 0; cmdline[src];) {
115                 char c = cmdline[src];
116                 if (!quoted && isspace(c)) {
117                         cmdline[dst++] = 0;
118                         while (cmdline[++src]
119                                         && isspace(cmdline[src]))
120                                 ; /* skip */
121                         if (count >= size) {
122                                 size += 16;
123                                 *argv = realloc(*argv, sizeof(char*) * size);
124                         }
125                         (*argv)[count++] = cmdline + dst;
126                 } else if(!quoted && (c == '\'' || c == '"')) {
127                         quoted = c;
128                         src++;
129                 } else if (c == quoted) {
130                         quoted = 0;
131                         src++;
132                 } else {
133                         if (c == '\\' && quoted != '\'') {
134                                 src++;
135                                 c = cmdline[src];
136                                 if (!c) {
137                                         free(*argv);
138                                         *argv = NULL;
139                                         return error("cmdline ends with \\");
140                                 }
141                         }
142                         cmdline[dst++] = c;
143                         src++;
144                 }
145         }
146
147         cmdline[dst] = 0;
148
149         if (quoted) {
150                 free(*argv);
151                 *argv = NULL;
152                 return error("unclosed quote");
153         }
154
155         return count;
156 }
157
158 static int handle_alias(int *argcp, const char ***argv)
159 {
160         int nongit = 0, ret = 0, saved_errno = errno;
161         const char *subdir;
162         int count, option_count;
163         const char** new_argv;
164
165         subdir = setup_git_directory_gently(&nongit);
166
167         alias_command = (*argv)[0];
168         git_config(git_alias_config);
169         if (alias_string) {
170                 count = split_cmdline(alias_string, &new_argv);
171                 option_count = handle_options(&new_argv, &count);
172                 memmove(new_argv - option_count, new_argv,
173                                 count * sizeof(char *));
174                 new_argv -= option_count;
175
176                 if (count < 1)
177                         die("empty alias for %s", alias_command);
178
179                 if (!strcmp(alias_command, new_argv[0]))
180                         die("recursive alias: %s", alias_command);
181
182                 if (getenv("GIT_TRACE")) {
183                         int i;
184                         fprintf(stderr, "trace: alias expansion: %s =>",
185                                 alias_command);
186                         for (i = 0; i < count; ++i) {
187                                 fputc(' ', stderr);
188                                 sq_quote_print(stderr, new_argv[i]);
189                         }
190                         fputc('\n', stderr);
191                         fflush(stderr);
192                 }
193
194                 new_argv = realloc(new_argv, sizeof(char*) *
195                                    (count + *argcp + 1));
196                 /* insert after command name */
197                 memcpy(new_argv + count, *argv + 1, sizeof(char*) * *argcp);
198                 new_argv[count+*argcp] = NULL;
199
200                 *argv = new_argv;
201                 *argcp += count - 1;
202
203                 ret = 1;
204         }
205
206         if (subdir)
207                 chdir(subdir);
208
209         errno = saved_errno;
210
211         return ret;
212 }
213
214 const char git_version_string[] = GIT_VERSION;
215
216 #define NEEDS_PREFIX 1
217 #define USE_PAGER 2
218
219 static void handle_internal_command(int argc, const char **argv, char **envp)
220 {
221         const char *cmd = argv[0];
222         static struct cmd_struct {
223                 const char *cmd;
224                 int (*fn)(int, const char **, const char *);
225                 int option;
226         } commands[] = {
227                 { "version", cmd_version },
228                 { "help", cmd_help },
229                 { "log", cmd_log, NEEDS_PREFIX | USE_PAGER },
230                 { "whatchanged", cmd_whatchanged, NEEDS_PREFIX | USE_PAGER },
231                 { "show", cmd_show, NEEDS_PREFIX | USE_PAGER },
232                 { "push", cmd_push },
233                 { "format-patch", cmd_format_patch, NEEDS_PREFIX },
234                 { "count-objects", cmd_count_objects },
235                 { "diff", cmd_diff, NEEDS_PREFIX },
236                 { "grep", cmd_grep, NEEDS_PREFIX },
237                 { "rm", cmd_rm, NEEDS_PREFIX },
238                 { "add", cmd_add, NEEDS_PREFIX },
239                 { "rev-list", cmd_rev_list, NEEDS_PREFIX },
240                 { "init-db", cmd_init_db },
241                 { "get-tar-commit-id", cmd_get_tar_commit_id },
242                 { "upload-tar", cmd_upload_tar },
243                 { "check-ref-format", cmd_check_ref_format },
244                 { "ls-files", cmd_ls_files, NEEDS_PREFIX },
245                 { "ls-tree", cmd_ls_tree, NEEDS_PREFIX },
246                 { "tar-tree", cmd_tar_tree, NEEDS_PREFIX },
247                 { "read-tree", cmd_read_tree, NEEDS_PREFIX },
248                 { "commit-tree", cmd_commit_tree, NEEDS_PREFIX },
249                 { "apply", cmd_apply },
250                 { "show-branch", cmd_show_branch, NEEDS_PREFIX },
251                 { "diff-files", cmd_diff_files, NEEDS_PREFIX },
252                 { "diff-index", cmd_diff_index, NEEDS_PREFIX },
253                 { "diff-stages", cmd_diff_stages, NEEDS_PREFIX },
254                 { "diff-tree", cmd_diff_tree, NEEDS_PREFIX },
255                 { "cat-file", cmd_cat_file, NEEDS_PREFIX },
256                 { "rev-parse", cmd_rev_parse, NEEDS_PREFIX },
257                 { "write-tree", cmd_write_tree, NEEDS_PREFIX },
258                 { "mailsplit", cmd_mailsplit },
259                 { "mailinfo", cmd_mailinfo },
260                 { "stripspace", cmd_stripspace },
261                 { "update-index", cmd_update_index, NEEDS_PREFIX },
262                 { "update-ref", cmd_update_ref, NEEDS_PREFIX },
263                 { "fmt-merge-msg", cmd_fmt_merge_msg, NEEDS_PREFIX },
264                 { "prune", cmd_prune, NEEDS_PREFIX },
265                 { "mv", cmd_mv, NEEDS_PREFIX },
266                 { "prune-packed", cmd_prune_packed, NEEDS_PREFIX },
267                 { "repo-config", cmd_repo_config },
268         };
269         int i;
270
271         /* Turn "git cmd --help" into "git help cmd" */
272         if (argc > 1 && !strcmp(argv[1], "--help")) {
273                 argv[1] = argv[0];
274                 argv[0] = cmd = "help";
275         }
276
277         for (i = 0; i < ARRAY_SIZE(commands); i++) {
278                 struct cmd_struct *p = commands+i;
279                 const char *prefix;
280                 if (strcmp(p->cmd, cmd))
281                         continue;
282
283                 prefix = NULL;
284                 if (p->option & NEEDS_PREFIX)
285                         prefix = setup_git_directory();
286                 if (p->option & USE_PAGER)
287                         setup_pager();
288                 if (getenv("GIT_TRACE")) {
289                         int i;
290                         fprintf(stderr, "trace: built-in: git");
291                         for (i = 0; i < argc; ++i) {
292                                 fputc(' ', stderr);
293                                 sq_quote_print(stderr, argv[i]);
294                         }
295                         putc('\n', stderr);
296                         fflush(stderr);
297                 }
298
299                 exit(p->fn(argc, argv, prefix));
300         }
301 }
302
303 int main(int argc, const char **argv, char **envp)
304 {
305         const char *cmd = argv[0];
306         char *slash = strrchr(cmd, '/');
307         const char *exec_path = NULL;
308         int done_alias = 0;
309
310         /*
311          * Take the basename of argv[0] as the command
312          * name, and the dirname as the default exec_path
313          * if it's an absolute path and we don't have
314          * anything better.
315          */
316         if (slash) {
317                 *slash++ = 0;
318                 if (*cmd == '/')
319                         exec_path = cmd;
320                 cmd = slash;
321         }
322
323         /*
324          * "git-xxxx" is the same as "git xxxx", but we obviously:
325          *
326          *  - cannot take flags in between the "git" and the "xxxx".
327          *  - cannot execute it externally (since it would just do
328          *    the same thing over again)
329          *
330          * So we just directly call the internal command handler, and
331          * die if that one cannot handle it.
332          */
333         if (!strncmp(cmd, "git-", 4)) {
334                 cmd += 4;
335                 argv[0] = cmd;
336                 handle_internal_command(argc, argv, envp);
337                 die("cannot handle %s internally", cmd);
338         }
339
340         /* Look for flags.. */
341         argv++;
342         argc--;
343         handle_options(&argv, &argc);
344         if (argc > 0) {
345                 if (!strncmp(argv[0], "--", 2))
346                         argv[0] += 2;
347         } else {
348                 /* Default command: "help" */
349                 argv[0] = "help";
350                 argc = 1;
351         }
352         cmd = argv[0];
353
354         /*
355          * We search for git commands in the following order:
356          *  - git_exec_path()
357          *  - the path of the "git" command if we could find it
358          *    in $0
359          *  - the regular PATH.
360          */
361         if (exec_path)
362                 prepend_to_path(exec_path, strlen(exec_path));
363         exec_path = git_exec_path();
364         prepend_to_path(exec_path, strlen(exec_path));
365
366         while (1) {
367                 /* See if it's an internal command */
368                 handle_internal_command(argc, argv, envp);
369
370                 /* .. then try the external ones */
371                 execv_git_cmd(argv);
372
373                 /* It could be an alias -- this works around the insanity
374                  * of overriding "git log" with "git show" by having
375                  * alias.log = show
376                  */
377                 if (done_alias || !handle_alias(&argc, &argv))
378                         break;
379                 done_alias = 1;
380         }
381
382         if (errno == ENOENT)
383                 help_unknown_cmd(cmd);
384
385         fprintf(stderr, "Failed to run command '%s': %s\n",
386                 cmd, strerror(errno));
387
388         return 1;
389 }