3 #include "repository.h"
9 #include "run-command.h"
10 #include "string-list.h"
12 #include "argv-array.h"
14 #include "object-store.h"
17 static const char content_type
[] = "Content-Type";
18 static const char content_length
[] = "Content-Length";
19 static const char last_modified
[] = "Last-Modified";
20 static int getanyfile
= 1;
21 static unsigned long max_request_buffer
= 10 * 1024 * 1024;
23 static struct string_list
*query_params
;
27 const char *config_name
;
28 unsigned buffer_input
: 1;
32 static struct rpc_service rpc_service
[] = {
33 { "upload-pack", "uploadpack", 1, 1 },
34 { "receive-pack", "receivepack", 0, -1 },
37 static struct string_list
*get_parameters(void)
40 const char *query
= getenv("QUERY_STRING");
42 query_params
= xcalloc(1, sizeof(*query_params
));
43 while (query
&& *query
) {
44 char *name
= url_decode_parameter_name(&query
);
45 char *value
= url_decode_parameter_value(&query
);
46 struct string_list_item
*i
;
48 i
= string_list_lookup(query_params
, name
);
50 i
= string_list_insert(query_params
, name
);
59 static const char *get_parameter(const char *name
)
61 struct string_list_item
*i
;
62 i
= string_list_lookup(get_parameters(), name
);
63 return i
? i
->util
: NULL
;
66 __attribute__((format (printf
, 2, 3)))
67 static void format_write(int fd
, const char *fmt
, ...)
69 static char buffer
[1024];
75 n
= vsnprintf(buffer
, sizeof(buffer
), fmt
, args
);
77 if (n
>= sizeof(buffer
))
78 die("protocol error: impossibly long line");
80 write_or_die(fd
, buffer
, n
);
83 static void http_status(struct strbuf
*hdr
, unsigned code
, const char *msg
)
85 strbuf_addf(hdr
, "Status: %u %s\r\n", code
, msg
);
88 static void hdr_str(struct strbuf
*hdr
, const char *name
, const char *value
)
90 strbuf_addf(hdr
, "%s: %s\r\n", name
, value
);
93 static void hdr_int(struct strbuf
*hdr
, const char *name
, uintmax_t value
)
95 strbuf_addf(hdr
, "%s: %" PRIuMAX
"\r\n", name
, value
);
98 static void hdr_date(struct strbuf
*hdr
, const char *name
, timestamp_t when
)
100 const char *value
= show_date(when
, 0, DATE_MODE(RFC2822
));
101 hdr_str(hdr
, name
, value
);
104 static void hdr_nocache(struct strbuf
*hdr
)
106 hdr_str(hdr
, "Expires", "Fri, 01 Jan 1980 00:00:00 GMT");
107 hdr_str(hdr
, "Pragma", "no-cache");
108 hdr_str(hdr
, "Cache-Control", "no-cache, max-age=0, must-revalidate");
111 static void hdr_cache_forever(struct strbuf
*hdr
)
113 timestamp_t now
= time(NULL
);
114 hdr_date(hdr
, "Date", now
);
115 hdr_date(hdr
, "Expires", now
+ 31536000);
116 hdr_str(hdr
, "Cache-Control", "public, max-age=31536000");
119 static void end_headers(struct strbuf
*hdr
)
121 strbuf_add(hdr
, "\r\n", 2);
122 write_or_die(1, hdr
->buf
, hdr
->len
);
126 __attribute__((format (printf
, 2, 3)))
127 static NORETURN
void not_found(struct strbuf
*hdr
, const char *err
, ...)
131 http_status(hdr
, 404, "Not Found");
135 va_start(params
, err
);
137 vfprintf(stderr
, err
, params
);
142 __attribute__((format (printf
, 2, 3)))
143 static NORETURN
void forbidden(struct strbuf
*hdr
, const char *err
, ...)
147 http_status(hdr
, 403, "Forbidden");
151 va_start(params
, err
);
153 vfprintf(stderr
, err
, params
);
158 static void select_getanyfile(struct strbuf
*hdr
)
161 forbidden(hdr
, "Unsupported service: getanyfile");
164 static void send_strbuf(struct strbuf
*hdr
,
165 const char *type
, struct strbuf
*buf
)
167 hdr_int(hdr
, content_length
, buf
->len
);
168 hdr_str(hdr
, content_type
, type
);
170 write_or_die(1, buf
->buf
, buf
->len
);
173 static void send_local_file(struct strbuf
*hdr
, const char *the_type
,
176 char *p
= git_pathdup("%s", name
);
177 size_t buf_alloc
= 8192;
178 char *buf
= xmalloc(buf_alloc
);
182 fd
= open(p
, O_RDONLY
);
184 not_found(hdr
, "Cannot open '%s': %s", p
, strerror(errno
));
185 if (fstat(fd
, &sb
) < 0)
186 die_errno("Cannot stat '%s'", p
);
188 hdr_int(hdr
, content_length
, sb
.st_size
);
189 hdr_str(hdr
, content_type
, the_type
);
190 hdr_date(hdr
, last_modified
, sb
.st_mtime
);
194 ssize_t n
= xread(fd
, buf
, buf_alloc
);
196 die_errno("Cannot read '%s'", p
);
199 write_or_die(1, buf
, n
);
206 static void get_text_file(struct strbuf
*hdr
, char *name
)
208 select_getanyfile(hdr
);
210 send_local_file(hdr
, "text/plain", name
);
213 static void get_loose_object(struct strbuf
*hdr
, char *name
)
215 select_getanyfile(hdr
);
216 hdr_cache_forever(hdr
);
217 send_local_file(hdr
, "application/x-git-loose-object", name
);
220 static void get_pack_file(struct strbuf
*hdr
, char *name
)
222 select_getanyfile(hdr
);
223 hdr_cache_forever(hdr
);
224 send_local_file(hdr
, "application/x-git-packed-objects", name
);
227 static void get_idx_file(struct strbuf
*hdr
, char *name
)
229 select_getanyfile(hdr
);
230 hdr_cache_forever(hdr
);
231 send_local_file(hdr
, "application/x-git-packed-objects-toc", name
);
234 static void http_config(void)
237 struct strbuf var
= STRBUF_INIT
;
239 git_config_get_bool("http.getanyfile", &getanyfile
);
240 git_config_get_ulong("http.maxrequestbuffer", &max_request_buffer
);
242 for (i
= 0; i
< ARRAY_SIZE(rpc_service
); i
++) {
243 struct rpc_service
*svc
= &rpc_service
[i
];
244 strbuf_addf(&var
, "http.%s", svc
->config_name
);
245 if (!git_config_get_bool(var
.buf
, &value
))
246 svc
->enabled
= value
;
250 strbuf_release(&var
);
253 static struct rpc_service
*select_service(struct strbuf
*hdr
, const char *name
)
255 const char *svc_name
;
256 struct rpc_service
*svc
= NULL
;
259 if (!skip_prefix(name
, "git-", &svc_name
))
260 forbidden(hdr
, "Unsupported service: '%s'", name
);
262 for (i
= 0; i
< ARRAY_SIZE(rpc_service
); i
++) {
263 struct rpc_service
*s
= &rpc_service
[i
];
264 if (!strcmp(s
->name
, svc_name
)) {
271 forbidden(hdr
, "Unsupported service: '%s'", name
);
273 if (svc
->enabled
< 0) {
274 const char *user
= getenv("REMOTE_USER");
275 svc
->enabled
= (user
&& *user
) ? 1 : 0;
278 forbidden(hdr
, "Service not enabled: '%s'", svc
->name
);
282 static void write_to_child(int out
, const unsigned char *buf
, ssize_t len
, const char *prog_name
)
284 if (write_in_full(out
, buf
, len
) < 0)
285 die("unable to write to '%s'", prog_name
);
289 * This is basically strbuf_read(), except that if we
290 * hit max_request_buffer we die (we'd rather reject a
291 * maliciously large request than chew up infinite memory).
293 static ssize_t
read_request(int fd
, unsigned char **out
)
295 size_t len
= 0, alloc
= 8192;
296 unsigned char *buf
= xmalloc(alloc
);
298 if (max_request_buffer
< alloc
)
299 max_request_buffer
= alloc
;
304 cnt
= read_in_full(fd
, buf
+ len
, alloc
- len
);
310 /* partial read from read_in_full means we hit EOF */
317 /* otherwise, grow and try again (if we can) */
318 if (alloc
== max_request_buffer
)
319 die("request was larger than our maximum size (%lu);"
320 " try setting GIT_HTTP_MAX_REQUEST_BUFFER",
323 alloc
= alloc_nr(alloc
);
324 if (alloc
> max_request_buffer
)
325 alloc
= max_request_buffer
;
326 REALLOC_ARRAY(buf
, alloc
);
330 static void inflate_request(const char *prog_name
, int out
, int buffer_input
)
333 unsigned char *full_request
= NULL
;
334 unsigned char in_buf
[8192];
335 unsigned char out_buf
[8192];
336 unsigned long cnt
= 0;
338 memset(&stream
, 0, sizeof(stream
));
339 git_inflate_init_gzip_only(&stream
);
346 n
= 0; /* nothing left to read */
348 n
= read_request(0, &full_request
);
349 stream
.next_in
= full_request
;
351 n
= xread(0, in_buf
, sizeof(in_buf
));
352 stream
.next_in
= in_buf
;
356 die("request ended in the middle of the gzip stream");
359 while (0 < stream
.avail_in
) {
362 stream
.next_out
= out_buf
;
363 stream
.avail_out
= sizeof(out_buf
);
365 ret
= git_inflate(&stream
, Z_NO_FLUSH
);
366 if (ret
!= Z_OK
&& ret
!= Z_STREAM_END
)
367 die("zlib error inflating request, result %d", ret
);
369 n
= stream
.total_out
- cnt
;
370 write_to_child(out
, out_buf
, stream
.total_out
- cnt
, prog_name
);
371 cnt
= stream
.total_out
;
373 if (ret
== Z_STREAM_END
)
379 git_inflate_end(&stream
);
384 static void copy_request(const char *prog_name
, int out
)
387 ssize_t n
= read_request(0, &buf
);
389 die_errno("error reading request body");
390 write_to_child(out
, buf
, n
, prog_name
);
395 static void run_service(const char **argv
, int buffer_input
)
397 const char *encoding
= getenv("HTTP_CONTENT_ENCODING");
398 const char *user
= getenv("REMOTE_USER");
399 const char *host
= getenv("REMOTE_ADDR");
400 int gzipped_request
= 0;
401 struct child_process cld
= CHILD_PROCESS_INIT
;
403 if (encoding
&& !strcmp(encoding
, "gzip"))
405 else if (encoding
&& !strcmp(encoding
, "x-gzip"))
413 if (!getenv("GIT_COMMITTER_NAME"))
414 argv_array_pushf(&cld
.env_array
, "GIT_COMMITTER_NAME=%s", user
);
415 if (!getenv("GIT_COMMITTER_EMAIL"))
416 argv_array_pushf(&cld
.env_array
,
417 "GIT_COMMITTER_EMAIL=%s@http.%s", user
, host
);
420 if (buffer_input
|| gzipped_request
)
423 if (start_command(&cld
))
428 inflate_request(argv
[0], cld
.in
, buffer_input
);
429 else if (buffer_input
)
430 copy_request(argv
[0], cld
.in
);
434 if (finish_command(&cld
))
438 static int show_text_ref(const char *name
, const struct object_id
*oid
,
439 int flag
, void *cb_data
)
441 const char *name_nons
= strip_namespace(name
);
442 struct strbuf
*buf
= cb_data
;
443 struct object
*o
= parse_object(oid
);
447 strbuf_addf(buf
, "%s\t%s\n", oid_to_hex(oid
), name_nons
);
448 if (o
->type
== OBJ_TAG
) {
449 o
= deref_tag(o
, name
, 0);
452 strbuf_addf(buf
, "%s\t%s^{}\n", oid_to_hex(&o
->oid
),
458 static void get_info_refs(struct strbuf
*hdr
, char *arg
)
460 const char *service_name
= get_parameter("service");
461 struct strbuf buf
= STRBUF_INIT
;
466 const char *argv
[] = {NULL
/* service name */,
467 "--stateless-rpc", "--advertise-refs",
469 struct rpc_service
*svc
= select_service(hdr
, service_name
);
471 strbuf_addf(&buf
, "application/x-git-%s-advertisement",
473 hdr_str(hdr
, content_type
, buf
.buf
);
477 if (determine_protocol_version_server() != protocol_v2
) {
478 packet_write_fmt(1, "# service=git-%s\n", svc
->name
);
483 run_service(argv
, 0);
486 select_getanyfile(hdr
);
487 for_each_namespaced_ref(show_text_ref
, &buf
);
488 send_strbuf(hdr
, "text/plain", &buf
);
490 strbuf_release(&buf
);
493 static int show_head_ref(const char *refname
, const struct object_id
*oid
,
494 int flag
, void *cb_data
)
496 struct strbuf
*buf
= cb_data
;
498 if (flag
& REF_ISSYMREF
) {
499 const char *target
= resolve_ref_unsafe(refname
,
504 strbuf_addf(buf
, "ref: %s\n", strip_namespace(target
));
506 strbuf_addf(buf
, "%s\n", oid_to_hex(oid
));
512 static void get_head(struct strbuf
*hdr
, char *arg
)
514 struct strbuf buf
= STRBUF_INIT
;
516 select_getanyfile(hdr
);
517 head_ref_namespaced(show_head_ref
, &buf
);
518 send_strbuf(hdr
, "text/plain", &buf
);
519 strbuf_release(&buf
);
522 static void get_info_packs(struct strbuf
*hdr
, char *arg
)
524 size_t objdirlen
= strlen(get_object_directory());
525 struct strbuf buf
= STRBUF_INIT
;
526 struct packed_git
*p
;
529 select_getanyfile(hdr
);
530 for (p
= get_packed_git(the_repository
); p
; p
= p
->next
) {
535 strbuf_grow(&buf
, cnt
* 53 + 2);
536 for (p
= get_packed_git(the_repository
); p
; p
= p
->next
) {
538 strbuf_addf(&buf
, "P %s\n", p
->pack_name
+ objdirlen
+ 6);
540 strbuf_addch(&buf
, '\n');
543 send_strbuf(hdr
, "text/plain; charset=utf-8", &buf
);
544 strbuf_release(&buf
);
547 static void check_content_type(struct strbuf
*hdr
, const char *accepted_type
)
549 const char *actual_type
= getenv("CONTENT_TYPE");
554 if (strcmp(actual_type
, accepted_type
)) {
555 http_status(hdr
, 415, "Unsupported Media Type");
559 "Expected POST with Content-Type '%s',"
560 " but received '%s' instead.\n",
561 accepted_type
, actual_type
);
566 static void service_rpc(struct strbuf
*hdr
, char *service_name
)
568 const char *argv
[] = {NULL
, "--stateless-rpc", ".", NULL
};
569 struct rpc_service
*svc
= select_service(hdr
, service_name
);
570 struct strbuf buf
= STRBUF_INIT
;
573 strbuf_addf(&buf
, "application/x-git-%s-request", svc
->name
);
574 check_content_type(hdr
, buf
.buf
);
579 strbuf_addf(&buf
, "application/x-git-%s-result", svc
->name
);
580 hdr_str(hdr
, content_type
, buf
.buf
);
585 run_service(argv
, svc
->buffer_input
);
586 strbuf_release(&buf
);
590 static NORETURN
void die_webcgi(const char *err
, va_list params
)
593 struct strbuf hdr
= STRBUF_INIT
;
595 vreportf("fatal: ", err
, params
);
597 http_status(&hdr
, 500, "Internal Server Error");
601 exit(0); /* we successfully reported a failure ;-) */
604 static int die_webcgi_recursing(void)
609 static char* getdir(void)
611 struct strbuf buf
= STRBUF_INIT
;
612 char *pathinfo
= getenv("PATH_INFO");
613 char *root
= getenv("GIT_PROJECT_ROOT");
614 char *path
= getenv("PATH_TRANSLATED");
617 if (!pathinfo
|| !*pathinfo
)
618 die("GIT_PROJECT_ROOT is set but PATH_INFO is not");
619 if (daemon_avoid_alias(pathinfo
))
620 die("'%s': aliased", pathinfo
);
621 end_url_with_slash(&buf
, root
);
622 if (pathinfo
[0] == '/')
624 strbuf_addstr(&buf
, pathinfo
);
625 return strbuf_detach(&buf
, NULL
);
626 } else if (path
&& *path
) {
627 return xstrdup(path
);
629 die("No GIT_PROJECT_ROOT or PATH_TRANSLATED from server");
633 static struct service_cmd
{
636 void (*imp
)(struct strbuf
*, char *);
638 {"GET", "/HEAD$", get_head
},
639 {"GET", "/info/refs$", get_info_refs
},
640 {"GET", "/objects/info/alternates$", get_text_file
},
641 {"GET", "/objects/info/http-alternates$", get_text_file
},
642 {"GET", "/objects/info/packs$", get_info_packs
},
643 {"GET", "/objects/[0-9a-f]{2}/[0-9a-f]{38}$", get_loose_object
},
644 {"GET", "/objects/pack/pack-[0-9a-f]{40}\\.pack$", get_pack_file
},
645 {"GET", "/objects/pack/pack-[0-9a-f]{40}\\.idx$", get_idx_file
},
647 {"POST", "/git-upload-pack$", service_rpc
},
648 {"POST", "/git-receive-pack$", service_rpc
}
651 static int bad_request(struct strbuf
*hdr
, const struct service_cmd
*c
)
653 const char *proto
= getenv("SERVER_PROTOCOL");
655 if (proto
&& !strcmp(proto
, "HTTP/1.1")) {
656 http_status(hdr
, 405, "Method Not Allowed");
657 hdr_str(hdr
, "Allow",
658 !strcmp(c
->method
, "GET") ? "GET, HEAD" : c
->method
);
660 http_status(hdr
, 400, "Bad Request");
666 int cmd_main(int argc
, const char **argv
)
668 char *method
= getenv("REQUEST_METHOD");
670 struct service_cmd
*cmd
= NULL
;
671 char *cmd_arg
= NULL
;
673 struct strbuf hdr
= STRBUF_INIT
;
675 set_die_routine(die_webcgi
);
676 set_die_is_recursing_routine(die_webcgi_recursing
);
679 die("No REQUEST_METHOD from server");
680 if (!strcmp(method
, "HEAD"))
684 for (i
= 0; i
< ARRAY_SIZE(services
); i
++) {
685 struct service_cmd
*c
= &services
[i
];
689 if (regcomp(&re
, c
->pattern
, REG_EXTENDED
))
690 die("Bogus regex in service table: %s", c
->pattern
);
691 if (!regexec(&re
, dir
, 1, out
, 0)) {
694 if (strcmp(method
, c
->method
))
695 return bad_request(&hdr
, c
);
698 n
= out
[0].rm_eo
- out
[0].rm_so
;
699 cmd_arg
= xmemdupz(dir
+ out
[0].rm_so
+ 1, n
- 1);
700 dir
[out
[0].rm_so
] = 0;
707 not_found(&hdr
, "Request not supported: '%s'", dir
);
710 if (!enter_repo(dir
, 0))
711 not_found(&hdr
, "Not a git repository: '%s'", dir
);
712 if (!getenv("GIT_HTTP_EXPORT_ALL") &&
713 access("git-daemon-export-ok", F_OK
) )
714 not_found(&hdr
, "Repository not exported: '%s'", dir
);
717 max_request_buffer
= git_env_ulong("GIT_HTTP_MAX_REQUEST_BUFFER",
720 cmd
->imp(&hdr
, cmd_arg
);