Fix longstanding mismerge of ALL_CFLAGS vs BASIC_CFLAGS
[git] / builtin-push.c
1 /*
2  * "git push"
3  */
4 #include "cache.h"
5 #include "refs.h"
6 #include "run-command.h"
7 #include "builtin.h"
8
9 #define MAX_URI (16)
10
11 static const char push_usage[] = "git-push [--all] [--tags] [--receive-pack=<git-receive-pack>] [--repo=all] [-f | --force] [-v] [<repository> <refspec>...]";
12
13 static int all, tags, force, thin = 1, verbose;
14 static const char *receivepack;
15
16 #define BUF_SIZE (2084)
17 static char buffer[BUF_SIZE];
18
19 static const char **refspec;
20 static int refspec_nr;
21
22 static void add_refspec(const char *ref)
23 {
24         int nr = refspec_nr + 1;
25         refspec = xrealloc(refspec, nr * sizeof(char *));
26         refspec[nr-1] = ref;
27         refspec_nr = nr;
28 }
29
30 static int expand_one_ref(const char *ref, const unsigned char *sha1, int flag, void *cb_data)
31 {
32         /* Ignore the "refs/" at the beginning of the refname */
33         ref += 5;
34
35         if (!strncmp(ref, "tags/", 5))
36                 add_refspec(xstrdup(ref));
37         return 0;
38 }
39
40 static void expand_refspecs(void)
41 {
42         if (all) {
43                 if (refspec_nr)
44                         die("cannot mix '--all' and a refspec");
45
46                 /*
47                  * No need to expand "--all" - we'll just use
48                  * the "--all" flag to send-pack
49                  */
50                 return;
51         }
52         if (!tags)
53                 return;
54         for_each_ref(expand_one_ref, NULL);
55 }
56
57 static void set_refspecs(const char **refs, int nr)
58 {
59         if (nr) {
60                 int pass;
61                 for (pass = 0; pass < 2; pass++) {
62                         /* pass 0 counts and allocates, pass 1 fills */
63                         int i, cnt;
64                         for (i = cnt = 0; i < nr; i++) {
65                                 if (!strcmp("tag", refs[i])) {
66                                         int len;
67                                         char *tag;
68                                         if (nr <= ++i)
69                                                 die("tag <tag> shorthand without <tag>");
70                                         if (pass) {
71                                                 len = strlen(refs[i]) + 11;
72                                                 tag = xmalloc(len);
73                                                 strcpy(tag, "refs/tags/");
74                                                 strcat(tag, refs[i]);
75                                                 refspec[cnt] = tag;
76                                         }
77                                         cnt++;
78                                         continue;
79                                 }
80                                 if (pass)
81                                         refspec[cnt] = refs[i];
82                                 cnt++;
83                         }
84                         if (!pass) {
85                                 size_t bytes = cnt * sizeof(char *);
86                                 refspec_nr = cnt;
87                                 refspec = xrealloc(refspec, bytes);
88                         }
89                 }
90         }
91         expand_refspecs();
92 }
93
94 static int get_remotes_uri(const char *repo, const char *uri[MAX_URI])
95 {
96         int n = 0;
97         FILE *f = fopen(git_path("remotes/%s", repo), "r");
98         int has_explicit_refspec = refspec_nr || all || tags;
99
100         if (!f)
101                 return -1;
102         while (fgets(buffer, BUF_SIZE, f)) {
103                 int is_refspec;
104                 char *s, *p;
105
106                 if (!strncmp("URL:", buffer, 4)) {
107                         is_refspec = 0;
108                         s = buffer + 4;
109                 } else if (!strncmp("Push:", buffer, 5)) {
110                         is_refspec = 1;
111                         s = buffer + 5;
112                 } else
113                         continue;
114
115                 /* Remove whitespace at the head.. */
116                 while (isspace(*s))
117                         s++;
118                 if (!*s)
119                         continue;
120
121                 /* ..and at the end */
122                 p = s + strlen(s);
123                 while (isspace(p[-1]))
124                         *--p = 0;
125
126                 if (!is_refspec) {
127                         if (n < MAX_URI)
128                                 uri[n++] = xstrdup(s);
129                         else
130                                 error("more than %d URL's specified, ignoring the rest", MAX_URI);
131                 }
132                 else if (is_refspec && !has_explicit_refspec)
133                         add_refspec(xstrdup(s));
134         }
135         fclose(f);
136         if (!n)
137                 die("remote '%s' has no URL", repo);
138         return n;
139 }
140
141 static const char **config_uri;
142 static const char *config_repo;
143 static int config_repo_len;
144 static int config_current_uri;
145 static int config_get_refspecs;
146 static int config_get_receivepack;
147
148 static int get_remote_config(const char* key, const char* value)
149 {
150         if (!strncmp(key, "remote.", 7) &&
151             !strncmp(key + 7, config_repo, config_repo_len)) {
152                 if (!strcmp(key + 7 + config_repo_len, ".url")) {
153                         if (config_current_uri < MAX_URI)
154                                 config_uri[config_current_uri++] = xstrdup(value);
155                         else
156                                 error("more than %d URL's specified, ignoring the rest", MAX_URI);
157                 }
158                 else if (config_get_refspecs &&
159                          !strcmp(key + 7 + config_repo_len, ".push"))
160                         add_refspec(xstrdup(value));
161                 else if (config_get_receivepack &&
162                          !strcmp(key + 7 + config_repo_len, ".receivepack")) {
163                         if (!receivepack) {
164                                 char *rp = xmalloc(strlen(value) + 16);
165                                 sprintf(rp, "--receive-pack=%s", value);
166                                 receivepack = rp;
167                         } else
168                                 error("more than one receivepack given, using the first");
169                 }
170         }
171         return 0;
172 }
173
174 static int get_config_remotes_uri(const char *repo, const char *uri[MAX_URI])
175 {
176         config_repo_len = strlen(repo);
177         config_repo = repo;
178         config_current_uri = 0;
179         config_uri = uri;
180         config_get_refspecs = !(refspec_nr || all || tags);
181         config_get_receivepack = (receivepack == NULL);
182
183         git_config(get_remote_config);
184         return config_current_uri;
185 }
186
187 static int get_branches_uri(const char *repo, const char *uri[MAX_URI])
188 {
189         const char *slash = strchr(repo, '/');
190         int n = slash ? slash - repo : 1000;
191         FILE *f = fopen(git_path("branches/%.*s", n, repo), "r");
192         char *s, *p;
193         int len;
194
195         if (!f)
196                 return 0;
197         s = fgets(buffer, BUF_SIZE, f);
198         fclose(f);
199         if (!s)
200                 return 0;
201         while (isspace(*s))
202                 s++;
203         if (!*s)
204                 return 0;
205         p = s + strlen(s);
206         while (isspace(p[-1]))
207                 *--p = 0;
208         len = p - s;
209         if (slash)
210                 len += strlen(slash);
211         p = xmalloc(len + 1);
212         strcpy(p, s);
213         if (slash)
214                 strcat(p, slash);
215         uri[0] = p;
216         return 1;
217 }
218
219 /*
220  * Read remotes and branches file, fill the push target URI
221  * list.  If there is no command line refspecs, read Push: lines
222  * to set up the *refspec list as well.
223  * return the number of push target URIs
224  */
225 static int read_config(const char *repo, const char *uri[MAX_URI])
226 {
227         int n;
228
229         if (*repo != '/') {
230                 n = get_remotes_uri(repo, uri);
231                 if (n > 0)
232                         return n;
233
234                 n = get_config_remotes_uri(repo, uri);
235                 if (n > 0)
236                         return n;
237
238                 n = get_branches_uri(repo, uri);
239                 if (n > 0)
240                         return n;
241         }
242
243         uri[0] = repo;
244         return 1;
245 }
246
247 static int do_push(const char *repo)
248 {
249         const char *uri[MAX_URI];
250         int i, n;
251         int common_argc;
252         const char **argv;
253         int argc;
254
255         n = read_config(repo, uri);
256         if (n <= 0)
257                 die("bad repository '%s'", repo);
258
259         argv = xmalloc((refspec_nr + 10) * sizeof(char *));
260         argv[0] = "dummy-send-pack";
261         argc = 1;
262         if (all)
263                 argv[argc++] = "--all";
264         if (force)
265                 argv[argc++] = "--force";
266         if (receivepack)
267                 argv[argc++] = receivepack;
268         common_argc = argc;
269
270         for (i = 0; i < n; i++) {
271                 int err;
272                 int dest_argc = common_argc;
273                 int dest_refspec_nr = refspec_nr;
274                 const char **dest_refspec = refspec;
275                 const char *dest = uri[i];
276                 const char *sender = "git-send-pack";
277                 if (!strncmp(dest, "http://", 7) ||
278                     !strncmp(dest, "https://", 8))
279                         sender = "git-http-push";
280                 else if (thin)
281                         argv[dest_argc++] = "--thin";
282                 argv[0] = sender;
283                 argv[dest_argc++] = dest;
284                 while (dest_refspec_nr--)
285                         argv[dest_argc++] = *dest_refspec++;
286                 argv[dest_argc] = NULL;
287                 if (verbose)
288                         fprintf(stderr, "Pushing to %s\n", dest);
289                 err = run_command_v(argv);
290                 if (!err)
291                         continue;
292                 switch (err) {
293                 case -ERR_RUN_COMMAND_FORK:
294                         die("unable to fork for %s", sender);
295                 case -ERR_RUN_COMMAND_EXEC:
296                         die("unable to exec %s", sender);
297                 case -ERR_RUN_COMMAND_WAITPID:
298                 case -ERR_RUN_COMMAND_WAITPID_WRONG_PID:
299                 case -ERR_RUN_COMMAND_WAITPID_SIGNAL:
300                 case -ERR_RUN_COMMAND_WAITPID_NOEXIT:
301                         die("%s died with strange error", sender);
302                 default:
303                         return -err;
304                 }
305         }
306         return 0;
307 }
308
309 int cmd_push(int argc, const char **argv, const char *prefix)
310 {
311         int i;
312         const char *repo = "origin";    /* default repository */
313
314         for (i = 1; i < argc; i++) {
315                 const char *arg = argv[i];
316
317                 if (arg[0] != '-') {
318                         repo = arg;
319                         i++;
320                         break;
321                 }
322                 if (!strcmp(arg, "-v")) {
323                         verbose=1;
324                         continue;
325                 }
326                 if (!strncmp(arg, "--repo=", 7)) {
327                         repo = arg+7;
328                         continue;
329                 }
330                 if (!strcmp(arg, "--all")) {
331                         all = 1;
332                         continue;
333                 }
334                 if (!strcmp(arg, "--tags")) {
335                         tags = 1;
336                         continue;
337                 }
338                 if (!strcmp(arg, "--force") || !strcmp(arg, "-f")) {
339                         force = 1;
340                         continue;
341                 }
342                 if (!strcmp(arg, "--thin")) {
343                         thin = 1;
344                         continue;
345                 }
346                 if (!strcmp(arg, "--no-thin")) {
347                         thin = 0;
348                         continue;
349                 }
350                 if (!strncmp(arg, "--receive-pack=", 15)) {
351                         receivepack = arg;
352                         continue;
353                 }
354                 if (!strncmp(arg, "--exec=", 7)) {
355                         receivepack = arg;
356                         continue;
357                 }
358                 usage(push_usage);
359         }
360         set_refspecs(argv + i, argc - i);
361         return do_push(repo);
362 }