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
&& !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;
377 memset(&stream
, 0, sizeof(stream
));
378 git_inflate_init_gzip_only(&stream
);
385 n
= 0; /* nothing left to read */
387 n
= read_request(0, &full_request
, req_len
);
388 stream
.next_in
= full_request
;
390 n
= xread(0, in_buf
, sizeof(in_buf
));
391 stream
.next_in
= in_buf
;
395 die("request ended in the middle of the gzip stream");
398 while (0 < stream
.avail_in
) {
401 stream
.next_out
= out_buf
;
402 stream
.avail_out
= sizeof(out_buf
);
404 ret
= git_inflate(&stream
, Z_NO_FLUSH
);
405 if (ret
!= Z_OK
&& ret
!= Z_STREAM_END
)
406 die("zlib error inflating request, result %d", ret
);
408 n
= stream
.total_out
- cnt
;
409 write_to_child(out
, out_buf
, stream
.total_out
- cnt
, prog_name
);
410 cnt
= stream
.total_out
;
412 if (ret
== Z_STREAM_END
)
418 git_inflate_end(&stream
);
423 static void copy_request(const char *prog_name
, int out
, ssize_t req_len
)
426 ssize_t n
= read_request(0, &buf
, req_len
);
428 die_errno("error reading request body");
429 write_to_child(out
, buf
, n
, prog_name
);
434 static void run_service(const char **argv
, int buffer_input
)
436 const char *encoding
= getenv("HTTP_CONTENT_ENCODING");
437 const char *user
= getenv("REMOTE_USER");
438 const char *host
= getenv("REMOTE_ADDR");
439 int gzipped_request
= 0;
440 struct child_process cld
= CHILD_PROCESS_INIT
;
441 ssize_t req_len
= get_content_length();
443 if (encoding
&& !strcmp(encoding
, "gzip"))
445 else if (encoding
&& !strcmp(encoding
, "x-gzip"))
453 if (!getenv("GIT_COMMITTER_NAME"))
454 argv_array_pushf(&cld
.env_array
, "GIT_COMMITTER_NAME=%s", user
);
455 if (!getenv("GIT_COMMITTER_EMAIL"))
456 argv_array_pushf(&cld
.env_array
,
457 "GIT_COMMITTER_EMAIL=%s@http.%s", user
, host
);
460 if (buffer_input
|| gzipped_request
)
463 if (start_command(&cld
))
468 inflate_request(argv
[0], cld
.in
, buffer_input
, req_len
);
469 else if (buffer_input
)
470 copy_request(argv
[0], cld
.in
, req_len
);
474 if (finish_command(&cld
))
478 static int show_text_ref(const char *name
, const struct object_id
*oid
,
479 int flag
, void *cb_data
)
481 const char *name_nons
= strip_namespace(name
);
482 struct strbuf
*buf
= cb_data
;
483 struct object
*o
= parse_object(oid
);
487 strbuf_addf(buf
, "%s\t%s\n", oid_to_hex(oid
), name_nons
);
488 if (o
->type
== OBJ_TAG
) {
489 o
= deref_tag(o
, name
, 0);
492 strbuf_addf(buf
, "%s\t%s^{}\n", oid_to_hex(&o
->oid
),
498 static void get_info_refs(struct strbuf
*hdr
, char *arg
)
500 const char *service_name
= get_parameter("service");
501 struct strbuf buf
= STRBUF_INIT
;
506 const char *argv
[] = {NULL
/* service name */,
507 "--stateless-rpc", "--advertise-refs",
509 struct rpc_service
*svc
= select_service(hdr
, service_name
);
511 strbuf_addf(&buf
, "application/x-git-%s-advertisement",
513 hdr_str(hdr
, content_type
, buf
.buf
);
517 if (determine_protocol_version_server() != protocol_v2
) {
518 packet_write_fmt(1, "# service=git-%s\n", svc
->name
);
523 run_service(argv
, 0);
526 select_getanyfile(hdr
);
527 for_each_namespaced_ref(show_text_ref
, &buf
);
528 send_strbuf(hdr
, "text/plain", &buf
);
530 strbuf_release(&buf
);
533 static int show_head_ref(const char *refname
, const struct object_id
*oid
,
534 int flag
, void *cb_data
)
536 struct strbuf
*buf
= cb_data
;
538 if (flag
& REF_ISSYMREF
) {
539 const char *target
= resolve_ref_unsafe(refname
,
544 strbuf_addf(buf
, "ref: %s\n", strip_namespace(target
));
546 strbuf_addf(buf
, "%s\n", oid_to_hex(oid
));
552 static void get_head(struct strbuf
*hdr
, char *arg
)
554 struct strbuf buf
= STRBUF_INIT
;
556 select_getanyfile(hdr
);
557 head_ref_namespaced(show_head_ref
, &buf
);
558 send_strbuf(hdr
, "text/plain", &buf
);
559 strbuf_release(&buf
);
562 static void get_info_packs(struct strbuf
*hdr
, char *arg
)
564 size_t objdirlen
= strlen(get_object_directory());
565 struct strbuf buf
= STRBUF_INIT
;
566 struct packed_git
*p
;
569 select_getanyfile(hdr
);
570 for (p
= get_packed_git(the_repository
); p
; p
= p
->next
) {
575 strbuf_grow(&buf
, cnt
* 53 + 2);
576 for (p
= get_packed_git(the_repository
); p
; p
= p
->next
) {
578 strbuf_addf(&buf
, "P %s\n", p
->pack_name
+ objdirlen
+ 6);
580 strbuf_addch(&buf
, '\n');
583 send_strbuf(hdr
, "text/plain; charset=utf-8", &buf
);
584 strbuf_release(&buf
);
587 static void check_content_type(struct strbuf
*hdr
, const char *accepted_type
)
589 const char *actual_type
= getenv("CONTENT_TYPE");
594 if (strcmp(actual_type
, accepted_type
)) {
595 http_status(hdr
, 415, "Unsupported Media Type");
599 "Expected POST with Content-Type '%s',"
600 " but received '%s' instead.\n",
601 accepted_type
, actual_type
);
606 static void service_rpc(struct strbuf
*hdr
, char *service_name
)
608 const char *argv
[] = {NULL
, "--stateless-rpc", ".", NULL
};
609 struct rpc_service
*svc
= select_service(hdr
, service_name
);
610 struct strbuf buf
= STRBUF_INIT
;
613 strbuf_addf(&buf
, "application/x-git-%s-request", svc
->name
);
614 check_content_type(hdr
, buf
.buf
);
619 strbuf_addf(&buf
, "application/x-git-%s-result", svc
->name
);
620 hdr_str(hdr
, content_type
, buf
.buf
);
625 run_service(argv
, svc
->buffer_input
);
626 strbuf_release(&buf
);
630 static NORETURN
void die_webcgi(const char *err
, va_list params
)
633 struct strbuf hdr
= STRBUF_INIT
;
635 vreportf("fatal: ", err
, params
);
637 http_status(&hdr
, 500, "Internal Server Error");
641 exit(0); /* we successfully reported a failure ;-) */
644 static int die_webcgi_recursing(void)
649 static char* getdir(void)
651 struct strbuf buf
= STRBUF_INIT
;
652 char *pathinfo
= getenv("PATH_INFO");
653 char *root
= getenv("GIT_PROJECT_ROOT");
654 char *path
= getenv("PATH_TRANSLATED");
657 if (!pathinfo
|| !*pathinfo
)
658 die("GIT_PROJECT_ROOT is set but PATH_INFO is not");
659 if (daemon_avoid_alias(pathinfo
))
660 die("'%s': aliased", pathinfo
);
661 end_url_with_slash(&buf
, root
);
662 if (pathinfo
[0] == '/')
664 strbuf_addstr(&buf
, pathinfo
);
665 return strbuf_detach(&buf
, NULL
);
666 } else if (path
&& *path
) {
667 return xstrdup(path
);
669 die("No GIT_PROJECT_ROOT or PATH_TRANSLATED from server");
673 static struct service_cmd
{
676 void (*imp
)(struct strbuf
*, char *);
678 {"GET", "/HEAD$", get_head
},
679 {"GET", "/info/refs$", get_info_refs
},
680 {"GET", "/objects/info/alternates$", get_text_file
},
681 {"GET", "/objects/info/http-alternates$", get_text_file
},
682 {"GET", "/objects/info/packs$", get_info_packs
},
683 {"GET", "/objects/[0-9a-f]{2}/[0-9a-f]{38}$", get_loose_object
},
684 {"GET", "/objects/pack/pack-[0-9a-f]{40}\\.pack$", get_pack_file
},
685 {"GET", "/objects/pack/pack-[0-9a-f]{40}\\.idx$", get_idx_file
},
687 {"POST", "/git-upload-pack$", service_rpc
},
688 {"POST", "/git-receive-pack$", service_rpc
}
691 static int bad_request(struct strbuf
*hdr
, const struct service_cmd
*c
)
693 const char *proto
= getenv("SERVER_PROTOCOL");
695 if (proto
&& !strcmp(proto
, "HTTP/1.1")) {
696 http_status(hdr
, 405, "Method Not Allowed");
697 hdr_str(hdr
, "Allow",
698 !strcmp(c
->method
, "GET") ? "GET, HEAD" : c
->method
);
700 http_status(hdr
, 400, "Bad Request");
706 int cmd_main(int argc
, const char **argv
)
708 char *method
= getenv("REQUEST_METHOD");
710 struct service_cmd
*cmd
= NULL
;
711 char *cmd_arg
= NULL
;
713 struct strbuf hdr
= STRBUF_INIT
;
715 set_die_routine(die_webcgi
);
716 set_die_is_recursing_routine(die_webcgi_recursing
);
719 die("No REQUEST_METHOD from server");
720 if (!strcmp(method
, "HEAD"))
724 for (i
= 0; i
< ARRAY_SIZE(services
); i
++) {
725 struct service_cmd
*c
= &services
[i
];
729 if (regcomp(&re
, c
->pattern
, REG_EXTENDED
))
730 die("Bogus regex in service table: %s", c
->pattern
);
731 if (!regexec(&re
, dir
, 1, out
, 0)) {
734 if (strcmp(method
, c
->method
))
735 return bad_request(&hdr
, c
);
738 n
= out
[0].rm_eo
- out
[0].rm_so
;
739 cmd_arg
= xmemdupz(dir
+ out
[0].rm_so
+ 1, n
- 1);
740 dir
[out
[0].rm_so
] = 0;
747 not_found(&hdr
, "Request not supported: '%s'", dir
);
750 if (!enter_repo(dir
, 0))
751 not_found(&hdr
, "Not a git repository: '%s'", dir
);
752 if (!getenv("GIT_HTTP_EXPORT_ALL") &&
753 access("git-daemon-export-ok", F_OK
) )
754 not_found(&hdr
, "Repository not exported: '%s'", dir
);
757 max_request_buffer
= git_env_ulong("GIT_HTTP_MAX_REQUEST_BUFFER",
760 cmd
->imp(&hdr
, cmd_arg
);