]>
git.ipfire.org Git - thirdparty/git.git/blob - http-backend.c
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_eof(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 ssize_t
read_request_fixed_len(int fd
, ssize_t req_len
, unsigned char **out
)
332 unsigned char *buf
= NULL
;
335 if (max_request_buffer
< req_len
) {
336 die("request was larger than our maximum size (%lu): "
337 "%" PRIuMAX
"; try setting GIT_HTTP_MAX_REQUEST_BUFFER",
338 max_request_buffer
, (uintmax_t)req_len
);
341 buf
= xmalloc(req_len
);
342 cnt
= read_in_full(fd
, buf
, req_len
);
351 static ssize_t
get_content_length(void)
354 const char *str
= getenv("CONTENT_LENGTH");
356 if (str
&& *str
&& !git_parse_ssize_t(str
, &val
))
357 die("failed to parse CONTENT_LENGTH: %s", str
);
361 static ssize_t
read_request(int fd
, unsigned char **out
, ssize_t req_len
)
364 return read_request_eof(fd
, out
);
366 return read_request_fixed_len(fd
, req_len
, out
);
369 static void inflate_request(const char *prog_name
, int out
, int buffer_input
, ssize_t req_len
)
372 unsigned char *full_request
= NULL
;
373 unsigned char in_buf
[8192];
374 unsigned char out_buf
[8192];
375 unsigned long cnt
= 0;
376 int req_len_defined
= req_len
>= 0;
377 size_t req_remaining_len
= req_len
;
379 memset(&stream
, 0, sizeof(stream
));
380 git_inflate_init_gzip_only(&stream
);
387 n
= 0; /* nothing left to read */
389 n
= read_request(0, &full_request
, req_len
);
390 stream
.next_in
= full_request
;
393 if (req_len_defined
&& req_remaining_len
<= sizeof(in_buf
))
394 buffer_len
= req_remaining_len
;
396 buffer_len
= sizeof(in_buf
);
397 n
= xread(0, in_buf
, buffer_len
);
398 stream
.next_in
= in_buf
;
399 if (req_len_defined
&& n
> 0)
400 req_remaining_len
-= n
;
404 die("request ended in the middle of the gzip stream");
407 while (0 < stream
.avail_in
) {
410 stream
.next_out
= out_buf
;
411 stream
.avail_out
= sizeof(out_buf
);
413 ret
= git_inflate(&stream
, Z_NO_FLUSH
);
414 if (ret
!= Z_OK
&& ret
!= Z_STREAM_END
)
415 die("zlib error inflating request, result %d", ret
);
417 n
= stream
.total_out
- cnt
;
418 write_to_child(out
, out_buf
, stream
.total_out
- cnt
, prog_name
);
419 cnt
= stream
.total_out
;
421 if (ret
== Z_STREAM_END
)
427 git_inflate_end(&stream
);
432 static void copy_request(const char *prog_name
, int out
, ssize_t req_len
)
435 ssize_t n
= read_request(0, &buf
, req_len
);
437 die_errno("error reading request body");
438 write_to_child(out
, buf
, n
, prog_name
);
443 static void pipe_fixed_length(const char *prog_name
, int out
, size_t req_len
)
445 unsigned char buf
[8192];
446 size_t remaining_len
= req_len
;
448 while (remaining_len
> 0) {
449 size_t chunk_length
= remaining_len
> sizeof(buf
) ? sizeof(buf
) : remaining_len
;
450 ssize_t n
= xread(0, buf
, chunk_length
);
452 die_errno("Reading request failed");
453 write_to_child(out
, buf
, n
, prog_name
);
460 static void run_service(const char **argv
, int buffer_input
)
462 const char *encoding
= getenv("HTTP_CONTENT_ENCODING");
463 const char *user
= getenv("REMOTE_USER");
464 const char *host
= getenv("REMOTE_ADDR");
465 int gzipped_request
= 0;
466 struct child_process cld
= CHILD_PROCESS_INIT
;
467 ssize_t req_len
= get_content_length();
469 if (encoding
&& !strcmp(encoding
, "gzip"))
471 else if (encoding
&& !strcmp(encoding
, "x-gzip"))
479 if (!getenv("GIT_COMMITTER_NAME"))
480 argv_array_pushf(&cld
.env_array
, "GIT_COMMITTER_NAME=%s", user
);
481 if (!getenv("GIT_COMMITTER_EMAIL"))
482 argv_array_pushf(&cld
.env_array
,
483 "GIT_COMMITTER_EMAIL=%s@http.%s", user
, host
);
486 if (buffer_input
|| gzipped_request
|| req_len
>= 0)
489 if (start_command(&cld
))
494 inflate_request(argv
[0], cld
.in
, buffer_input
, req_len
);
495 else if (buffer_input
)
496 copy_request(argv
[0], cld
.in
, req_len
);
497 else if (req_len
>= 0)
498 pipe_fixed_length(argv
[0], cld
.in
, req_len
);
502 if (finish_command(&cld
))
506 static int show_text_ref(const char *name
, const struct object_id
*oid
,
507 int flag
, void *cb_data
)
509 const char *name_nons
= strip_namespace(name
);
510 struct strbuf
*buf
= cb_data
;
511 struct object
*o
= parse_object(the_repository
, oid
);
515 strbuf_addf(buf
, "%s\t%s\n", oid_to_hex(oid
), name_nons
);
516 if (o
->type
== OBJ_TAG
) {
517 o
= deref_tag(the_repository
, o
, name
, 0);
520 strbuf_addf(buf
, "%s\t%s^{}\n", oid_to_hex(&o
->oid
),
526 static void get_info_refs(struct strbuf
*hdr
, char *arg
)
528 const char *service_name
= get_parameter("service");
529 struct strbuf buf
= STRBUF_INIT
;
534 const char *argv
[] = {NULL
/* service name */,
535 "--stateless-rpc", "--advertise-refs",
537 struct rpc_service
*svc
= select_service(hdr
, service_name
);
539 strbuf_addf(&buf
, "application/x-git-%s-advertisement",
541 hdr_str(hdr
, content_type
, buf
.buf
);
545 if (determine_protocol_version_server() != protocol_v2
) {
546 packet_write_fmt(1, "# service=git-%s\n", svc
->name
);
551 run_service(argv
, 0);
554 select_getanyfile(hdr
);
555 for_each_namespaced_ref(show_text_ref
, &buf
);
556 send_strbuf(hdr
, "text/plain", &buf
);
558 strbuf_release(&buf
);
561 static int show_head_ref(const char *refname
, const struct object_id
*oid
,
562 int flag
, void *cb_data
)
564 struct strbuf
*buf
= cb_data
;
566 if (flag
& REF_ISSYMREF
) {
567 const char *target
= resolve_ref_unsafe(refname
,
572 strbuf_addf(buf
, "ref: %s\n", strip_namespace(target
));
574 strbuf_addf(buf
, "%s\n", oid_to_hex(oid
));
580 static void get_head(struct strbuf
*hdr
, char *arg
)
582 struct strbuf buf
= STRBUF_INIT
;
584 select_getanyfile(hdr
);
585 head_ref_namespaced(show_head_ref
, &buf
);
586 send_strbuf(hdr
, "text/plain", &buf
);
587 strbuf_release(&buf
);
590 static void get_info_packs(struct strbuf
*hdr
, char *arg
)
592 size_t objdirlen
= strlen(get_object_directory());
593 struct strbuf buf
= STRBUF_INIT
;
594 struct packed_git
*p
;
597 select_getanyfile(hdr
);
598 for (p
= get_all_packs(the_repository
); p
; p
= p
->next
) {
603 strbuf_grow(&buf
, cnt
* 53 + 2);
604 for (p
= get_all_packs(the_repository
); p
; p
= p
->next
) {
606 strbuf_addf(&buf
, "P %s\n", p
->pack_name
+ objdirlen
+ 6);
608 strbuf_addch(&buf
, '\n');
611 send_strbuf(hdr
, "text/plain; charset=utf-8", &buf
);
612 strbuf_release(&buf
);
615 static void check_content_type(struct strbuf
*hdr
, const char *accepted_type
)
617 const char *actual_type
= getenv("CONTENT_TYPE");
622 if (strcmp(actual_type
, accepted_type
)) {
623 http_status(hdr
, 415, "Unsupported Media Type");
627 "Expected POST with Content-Type '%s',"
628 " but received '%s' instead.\n",
629 accepted_type
, actual_type
);
634 static void service_rpc(struct strbuf
*hdr
, char *service_name
)
636 const char *argv
[] = {NULL
, "--stateless-rpc", ".", NULL
};
637 struct rpc_service
*svc
= select_service(hdr
, service_name
);
638 struct strbuf buf
= STRBUF_INIT
;
641 strbuf_addf(&buf
, "application/x-git-%s-request", svc
->name
);
642 check_content_type(hdr
, buf
.buf
);
647 strbuf_addf(&buf
, "application/x-git-%s-result", svc
->name
);
648 hdr_str(hdr
, content_type
, buf
.buf
);
653 run_service(argv
, svc
->buffer_input
);
654 strbuf_release(&buf
);
658 static NORETURN
void die_webcgi(const char *err
, va_list params
)
661 struct strbuf hdr
= STRBUF_INIT
;
663 vreportf("fatal: ", err
, params
);
665 http_status(&hdr
, 500, "Internal Server Error");
669 exit(0); /* we successfully reported a failure ;-) */
672 static int die_webcgi_recursing(void)
677 static char* getdir(void)
679 struct strbuf buf
= STRBUF_INIT
;
680 char *pathinfo
= getenv("PATH_INFO");
681 char *root
= getenv("GIT_PROJECT_ROOT");
682 char *path
= getenv("PATH_TRANSLATED");
685 if (!pathinfo
|| !*pathinfo
)
686 die("GIT_PROJECT_ROOT is set but PATH_INFO is not");
687 if (daemon_avoid_alias(pathinfo
))
688 die("'%s': aliased", pathinfo
);
689 end_url_with_slash(&buf
, root
);
690 if (pathinfo
[0] == '/')
692 strbuf_addstr(&buf
, pathinfo
);
693 return strbuf_detach(&buf
, NULL
);
694 } else if (path
&& *path
) {
695 return xstrdup(path
);
697 die("No GIT_PROJECT_ROOT or PATH_TRANSLATED from server");
701 static struct service_cmd
{
704 void (*imp
)(struct strbuf
*, char *);
706 {"GET", "/HEAD$", get_head
},
707 {"GET", "/info/refs$", get_info_refs
},
708 {"GET", "/objects/info/alternates$", get_text_file
},
709 {"GET", "/objects/info/http-alternates$", get_text_file
},
710 {"GET", "/objects/info/packs$", get_info_packs
},
711 {"GET", "/objects/[0-9a-f]{2}/[0-9a-f]{38}$", get_loose_object
},
712 {"GET", "/objects/pack/pack-[0-9a-f]{40}\\.pack$", get_pack_file
},
713 {"GET", "/objects/pack/pack-[0-9a-f]{40}\\.idx$", get_idx_file
},
715 {"POST", "/git-upload-pack$", service_rpc
},
716 {"POST", "/git-receive-pack$", service_rpc
}
719 static int bad_request(struct strbuf
*hdr
, const struct service_cmd
*c
)
721 const char *proto
= getenv("SERVER_PROTOCOL");
723 if (proto
&& !strcmp(proto
, "HTTP/1.1")) {
724 http_status(hdr
, 405, "Method Not Allowed");
725 hdr_str(hdr
, "Allow",
726 !strcmp(c
->method
, "GET") ? "GET, HEAD" : c
->method
);
728 http_status(hdr
, 400, "Bad Request");
734 int cmd_main(int argc
, const char **argv
)
736 char *method
= getenv("REQUEST_METHOD");
738 struct service_cmd
*cmd
= NULL
;
739 char *cmd_arg
= NULL
;
741 struct strbuf hdr
= STRBUF_INIT
;
743 set_die_routine(die_webcgi
);
744 set_die_is_recursing_routine(die_webcgi_recursing
);
747 die("No REQUEST_METHOD from server");
748 if (!strcmp(method
, "HEAD"))
752 for (i
= 0; i
< ARRAY_SIZE(services
); i
++) {
753 struct service_cmd
*c
= &services
[i
];
757 if (regcomp(&re
, c
->pattern
, REG_EXTENDED
))
758 die("Bogus regex in service table: %s", c
->pattern
);
759 if (!regexec(&re
, dir
, 1, out
, 0)) {
762 if (strcmp(method
, c
->method
))
763 return bad_request(&hdr
, c
);
766 n
= out
[0].rm_eo
- out
[0].rm_so
;
767 cmd_arg
= xmemdupz(dir
+ out
[0].rm_so
+ 1, n
- 1);
768 dir
[out
[0].rm_so
] = 0;
775 not_found(&hdr
, "Request not supported: '%s'", dir
);
778 if (!enter_repo(dir
, 0))
779 not_found(&hdr
, "Not a git repository: '%s'", dir
);
780 if (!getenv("GIT_HTTP_EXPORT_ALL") &&
781 access("git-daemon-export-ok", F_OK
) )
782 not_found(&hdr
, "Repository not exported: '%s'", dir
);
785 max_request_buffer
= git_env_ulong("GIT_HTTP_MAX_REQUEST_BUFFER",
788 cmd
->imp(&hdr
, cmd_arg
);