git
/
http-backend.c
821 строка · 19.7 Кб
1#define USE_THE_REPOSITORY_VARIABLE2
3#include "git-compat-util.h"4#include "config.h"5#include "environment.h"6#include "git-zlib.h"7#include "hex.h"8#include "path.h"9#include "repository.h"10#include "refs.h"11#include "pkt-line.h"12#include "object.h"13#include "tag.h"14#include "exec-cmd.h"15#include "run-command.h"16#include "string-list.h"17#include "url.h"18#include "strvec.h"19#include "packfile.h"20#include "object-store-ll.h"21#include "protocol.h"22#include "date.h"23#include "write-or-die.h"24
25static const char content_type[] = "Content-Type";26static const char content_length[] = "Content-Length";27static const char last_modified[] = "Last-Modified";28static int getanyfile = 1;29static unsigned long max_request_buffer = 10 * 1024 * 1024;30
31static struct string_list *query_params;32
33struct rpc_service {34const char *name;35const char *config_name;36unsigned buffer_input : 1;37signed enabled : 2;38};39
40static struct rpc_service rpc_service[] = {41{ "upload-pack", "uploadpack", 1, 1 },42{ "receive-pack", "receivepack", 0, -1 },43{ "upload-archive", "uploadarchive", 0, -1 },44};45
46static struct string_list *get_parameters(void)47{
48if (!query_params) {49const char *query = getenv("QUERY_STRING");50
51CALLOC_ARRAY(query_params, 1);52while (query && *query) {53char *name = url_decode_parameter_name(&query);54char *value = url_decode_parameter_value(&query);55struct string_list_item *i;56
57i = string_list_lookup(query_params, name);58if (!i)59i = string_list_insert(query_params, name);60else61free(i->util);62i->util = value;63}64}65return query_params;66}
67
68static const char *get_parameter(const char *name)69{
70struct string_list_item *i;71i = string_list_lookup(get_parameters(), name);72return i ? i->util : NULL;73}
74
75__attribute__((format (printf, 2, 3)))76static void format_write(int fd, const char *fmt, ...)77{
78static char buffer[1024];79
80va_list args;81unsigned n;82
83va_start(args, fmt);84n = vsnprintf(buffer, sizeof(buffer), fmt, args);85va_end(args);86if (n >= sizeof(buffer))87die("protocol error: impossibly long line");88
89write_or_die(fd, buffer, n);90}
91
92static void http_status(struct strbuf *hdr, unsigned code, const char *msg)93{
94strbuf_addf(hdr, "Status: %u %s\r\n", code, msg);95}
96
97static void hdr_str(struct strbuf *hdr, const char *name, const char *value)98{
99strbuf_addf(hdr, "%s: %s\r\n", name, value);100}
101
102static void hdr_int(struct strbuf *hdr, const char *name, uintmax_t value)103{
104strbuf_addf(hdr, "%s: %" PRIuMAX "\r\n", name, value);105}
106
107static void hdr_date(struct strbuf *hdr, const char *name, timestamp_t when)108{
109const char *value = show_date(when, 0, DATE_MODE(RFC2822));110hdr_str(hdr, name, value);111}
112
113static void hdr_nocache(struct strbuf *hdr)114{
115hdr_str(hdr, "Expires", "Fri, 01 Jan 1980 00:00:00 GMT");116hdr_str(hdr, "Pragma", "no-cache");117hdr_str(hdr, "Cache-Control", "no-cache, max-age=0, must-revalidate");118}
119
120static void hdr_cache_forever(struct strbuf *hdr)121{
122timestamp_t now = time(NULL);123hdr_date(hdr, "Date", now);124hdr_date(hdr, "Expires", now + 31536000);125hdr_str(hdr, "Cache-Control", "public, max-age=31536000");126}
127
128static void end_headers(struct strbuf *hdr)129{
130strbuf_add(hdr, "\r\n", 2);131write_or_die(1, hdr->buf, hdr->len);132strbuf_release(hdr);133}
134
135__attribute__((format (printf, 2, 3)))136static NORETURN void not_found(struct strbuf *hdr, const char *err, ...)137{
138va_list params;139
140http_status(hdr, 404, "Not Found");141hdr_nocache(hdr);142end_headers(hdr);143
144va_start(params, err);145if (err && *err)146vfprintf(stderr, err, params);147va_end(params);148exit(0);149}
150
151__attribute__((format (printf, 2, 3)))152static NORETURN void forbidden(struct strbuf *hdr, const char *err, ...)153{
154va_list params;155
156http_status(hdr, 403, "Forbidden");157hdr_nocache(hdr);158end_headers(hdr);159
160va_start(params, err);161if (err && *err)162vfprintf(stderr, err, params);163va_end(params);164exit(0);165}
166
167static void select_getanyfile(struct strbuf *hdr)168{
169if (!getanyfile)170forbidden(hdr, "Unsupported service: getanyfile");171}
172
173static void send_strbuf(struct strbuf *hdr,174const char *type, struct strbuf *buf)175{
176hdr_int(hdr, content_length, buf->len);177hdr_str(hdr, content_type, type);178end_headers(hdr);179write_or_die(1, buf->buf, buf->len);180}
181
182static void send_local_file(struct strbuf *hdr, const char *the_type,183const char *name)184{
185char *p = git_pathdup("%s", name);186size_t buf_alloc = 8192;187char *buf = xmalloc(buf_alloc);188int fd;189struct stat sb;190
191fd = open(p, O_RDONLY);192if (fd < 0)193not_found(hdr, "Cannot open '%s': %s", p, strerror(errno));194if (fstat(fd, &sb) < 0)195die_errno("Cannot stat '%s'", p);196
197hdr_int(hdr, content_length, sb.st_size);198hdr_str(hdr, content_type, the_type);199hdr_date(hdr, last_modified, sb.st_mtime);200end_headers(hdr);201
202for (;;) {203ssize_t n = xread(fd, buf, buf_alloc);204if (n < 0)205die_errno("Cannot read '%s'", p);206if (!n)207break;208write_or_die(1, buf, n);209}210close(fd);211free(buf);212free(p);213}
214
215static void get_text_file(struct strbuf *hdr, char *name)216{
217select_getanyfile(hdr);218hdr_nocache(hdr);219send_local_file(hdr, "text/plain", name);220}
221
222static void get_loose_object(struct strbuf *hdr, char *name)223{
224select_getanyfile(hdr);225hdr_cache_forever(hdr);226send_local_file(hdr, "application/x-git-loose-object", name);227}
228
229static void get_pack_file(struct strbuf *hdr, char *name)230{
231select_getanyfile(hdr);232hdr_cache_forever(hdr);233send_local_file(hdr, "application/x-git-packed-objects", name);234}
235
236static void get_idx_file(struct strbuf *hdr, char *name)237{
238select_getanyfile(hdr);239hdr_cache_forever(hdr);240send_local_file(hdr, "application/x-git-packed-objects-toc", name);241}
242
243static void http_config(void)244{
245int i, value = 0;246struct strbuf var = STRBUF_INIT;247
248git_config_get_bool("http.getanyfile", &getanyfile);249git_config_get_ulong("http.maxrequestbuffer", &max_request_buffer);250
251for (i = 0; i < ARRAY_SIZE(rpc_service); i++) {252struct rpc_service *svc = &rpc_service[i];253strbuf_addf(&var, "http.%s", svc->config_name);254if (!git_config_get_bool(var.buf, &value))255svc->enabled = value;256strbuf_reset(&var);257}258
259strbuf_release(&var);260}
261
262static struct rpc_service *select_service(struct strbuf *hdr, const char *name)263{
264const char *svc_name;265struct rpc_service *svc = NULL;266int i;267
268if (!skip_prefix(name, "git-", &svc_name))269forbidden(hdr, "Unsupported service: '%s'", name);270
271for (i = 0; i < ARRAY_SIZE(rpc_service); i++) {272struct rpc_service *s = &rpc_service[i];273if (!strcmp(s->name, svc_name)) {274svc = s;275break;276}277}278
279if (!svc)280forbidden(hdr, "Unsupported service: '%s'", name);281
282if (svc->enabled < 0) {283const char *user = getenv("REMOTE_USER");284svc->enabled = (user && *user) ? 1 : 0;285}286if (!svc->enabled)287forbidden(hdr, "Service not enabled: '%s'", svc->name);288return svc;289}
290
291static void write_to_child(int out, const unsigned char *buf, ssize_t len, const char *prog_name)292{
293if (write_in_full(out, buf, len) < 0)294die("unable to write to '%s'", prog_name);295}
296
297/*
298* This is basically strbuf_read(), except that if we
299* hit max_request_buffer we die (we'd rather reject a
300* maliciously large request than chew up infinite memory).
301*/
302static ssize_t read_request_eof(int fd, unsigned char **out)303{
304size_t len = 0, alloc = 8192;305unsigned char *buf = xmalloc(alloc);306
307if (max_request_buffer < alloc)308max_request_buffer = alloc;309
310while (1) {311ssize_t cnt;312
313cnt = read_in_full(fd, buf + len, alloc - len);314if (cnt < 0) {315free(buf);316return -1;317}318
319/* partial read from read_in_full means we hit EOF */320len += cnt;321if (len < alloc) {322*out = buf;323return len;324}325
326/* otherwise, grow and try again (if we can) */327if (alloc == max_request_buffer)328die("request was larger than our maximum size (%lu);"329" try setting GIT_HTTP_MAX_REQUEST_BUFFER",330max_request_buffer);331
332alloc = alloc_nr(alloc);333if (alloc > max_request_buffer)334alloc = max_request_buffer;335REALLOC_ARRAY(buf, alloc);336}337}
338
339static ssize_t read_request_fixed_len(int fd, ssize_t req_len, unsigned char **out)340{
341unsigned char *buf = NULL;342ssize_t cnt = 0;343
344if (max_request_buffer < req_len) {345die("request was larger than our maximum size (%lu): "346"%" PRIuMAX "; try setting GIT_HTTP_MAX_REQUEST_BUFFER",347max_request_buffer, (uintmax_t)req_len);348}349
350buf = xmalloc(req_len);351cnt = read_in_full(fd, buf, req_len);352if (cnt < 0) {353free(buf);354return -1;355}356*out = buf;357return cnt;358}
359
360static ssize_t get_content_length(void)361{
362ssize_t val = -1;363const char *str = getenv("CONTENT_LENGTH");364
365if (str && *str && !git_parse_ssize_t(str, &val))366die("failed to parse CONTENT_LENGTH: %s", str);367return val;368}
369
370static ssize_t read_request(int fd, unsigned char **out, ssize_t req_len)371{
372if (req_len < 0)373return read_request_eof(fd, out);374else375return read_request_fixed_len(fd, req_len, out);376}
377
378static void inflate_request(const char *prog_name, int out, int buffer_input, ssize_t req_len)379{
380git_zstream stream;381unsigned char *full_request = NULL;382unsigned char in_buf[8192];383unsigned char out_buf[8192];384unsigned long cnt = 0;385int req_len_defined = req_len >= 0;386size_t req_remaining_len = req_len;387
388memset(&stream, 0, sizeof(stream));389git_inflate_init_gzip_only(&stream);390
391while (1) {392ssize_t n;393
394if (buffer_input) {395if (full_request)396n = 0; /* nothing left to read */397else398n = read_request(0, &full_request, req_len);399stream.next_in = full_request;400} else {401ssize_t buffer_len;402if (req_len_defined && req_remaining_len <= sizeof(in_buf))403buffer_len = req_remaining_len;404else405buffer_len = sizeof(in_buf);406n = xread(0, in_buf, buffer_len);407stream.next_in = in_buf;408if (req_len_defined && n > 0)409req_remaining_len -= n;410}411
412if (n <= 0)413die("request ended in the middle of the gzip stream");414stream.avail_in = n;415
416while (0 < stream.avail_in) {417int ret;418
419stream.next_out = out_buf;420stream.avail_out = sizeof(out_buf);421
422ret = git_inflate(&stream, Z_NO_FLUSH);423if (ret != Z_OK && ret != Z_STREAM_END)424die("zlib error inflating request, result %d", ret);425
426n = stream.total_out - cnt;427write_to_child(out, out_buf, stream.total_out - cnt, prog_name);428cnt = stream.total_out;429
430if (ret == Z_STREAM_END)431goto done;432}433}434
435done:436git_inflate_end(&stream);437close(out);438free(full_request);439}
440
441static void copy_request(const char *prog_name, int out, ssize_t req_len)442{
443unsigned char *buf;444ssize_t n = read_request(0, &buf, req_len);445if (n < 0)446die_errno("error reading request body");447write_to_child(out, buf, n, prog_name);448close(out);449free(buf);450}
451
452static void pipe_fixed_length(const char *prog_name, int out, size_t req_len)453{
454unsigned char buf[8192];455size_t remaining_len = req_len;456
457while (remaining_len > 0) {458size_t chunk_length = remaining_len > sizeof(buf) ? sizeof(buf) : remaining_len;459ssize_t n = xread(0, buf, chunk_length);460if (n < 0)461die_errno("Reading request failed");462write_to_child(out, buf, n, prog_name);463remaining_len -= n;464}465
466close(out);467}
468
469static void run_service(const char **argv, int buffer_input)470{
471const char *encoding = getenv("HTTP_CONTENT_ENCODING");472const char *user = getenv("REMOTE_USER");473const char *host = getenv("REMOTE_ADDR");474int gzipped_request = 0;475struct child_process cld = CHILD_PROCESS_INIT;476ssize_t req_len = get_content_length();477
478if (encoding && (!strcmp(encoding, "gzip") || !strcmp(encoding, "x-gzip")))479gzipped_request = 1;480
481if (!user || !*user)482user = "anonymous";483if (!host || !*host)484host = "(none)";485
486if (!getenv("GIT_COMMITTER_NAME"))487strvec_pushf(&cld.env, "GIT_COMMITTER_NAME=%s", user);488if (!getenv("GIT_COMMITTER_EMAIL"))489strvec_pushf(&cld.env,490"GIT_COMMITTER_EMAIL=%s@http.%s", user, host);491
492strvec_pushv(&cld.args, argv);493if (buffer_input || gzipped_request || req_len >= 0)494cld.in = -1;495cld.git_cmd = 1;496cld.clean_on_exit = 1;497cld.wait_after_clean = 1;498if (start_command(&cld))499exit(1);500
501close(1);502if (gzipped_request)503inflate_request(argv[0], cld.in, buffer_input, req_len);504else if (buffer_input)505copy_request(argv[0], cld.in, req_len);506else if (req_len >= 0)507pipe_fixed_length(argv[0], cld.in, req_len);508else509close(0);510
511if (finish_command(&cld))512exit(1);513}
514
515static int show_text_ref(const char *name, const char *referent UNUSED, const struct object_id *oid,516int flag UNUSED, void *cb_data)517{
518const char *name_nons = strip_namespace(name);519struct strbuf *buf = cb_data;520struct object *o = parse_object(the_repository, oid);521if (!o)522return 0;523
524strbuf_addf(buf, "%s\t%s\n", oid_to_hex(oid), name_nons);525if (o->type == OBJ_TAG) {526o = deref_tag(the_repository, o, name, 0);527if (!o)528return 0;529strbuf_addf(buf, "%s\t%s^{}\n", oid_to_hex(&o->oid),530name_nons);531}532return 0;533}
534
535static void get_info_refs(struct strbuf *hdr, char *arg UNUSED)536{
537const char *service_name = get_parameter("service");538struct strbuf buf = STRBUF_INIT;539
540hdr_nocache(hdr);541
542if (service_name) {543const char *argv[] = {NULL /* service name */,544"--http-backend-info-refs",545".", NULL};546struct rpc_service *svc = select_service(hdr, service_name);547
548strbuf_addf(&buf, "application/x-git-%s-advertisement",549svc->name);550hdr_str(hdr, content_type, buf.buf);551end_headers(hdr);552
553
554if (determine_protocol_version_server() != protocol_v2) {555packet_write_fmt(1, "# service=git-%s\n", svc->name);556packet_flush(1);557}558
559argv[0] = svc->name;560run_service(argv, 0);561
562} else {563select_getanyfile(hdr);564refs_for_each_namespaced_ref(get_main_ref_store(the_repository),565NULL, show_text_ref, &buf);566send_strbuf(hdr, "text/plain", &buf);567}568strbuf_release(&buf);569}
570
571static int show_head_ref(const char *refname, const char *referent UNUSED, const struct object_id *oid,572int flag, void *cb_data)573{
574struct strbuf *buf = cb_data;575
576if (flag & REF_ISSYMREF) {577const char *target = refs_resolve_ref_unsafe(get_main_ref_store(the_repository),578refname,579RESOLVE_REF_READING,580NULL, NULL);581
582if (target)583strbuf_addf(buf, "ref: %s\n", strip_namespace(target));584} else {585strbuf_addf(buf, "%s\n", oid_to_hex(oid));586}587
588return 0;589}
590
591static void get_head(struct strbuf *hdr, char *arg UNUSED)592{
593struct strbuf buf = STRBUF_INIT;594
595select_getanyfile(hdr);596refs_head_ref_namespaced(get_main_ref_store(the_repository),597show_head_ref, &buf);598send_strbuf(hdr, "text/plain", &buf);599strbuf_release(&buf);600}
601
602static void get_info_packs(struct strbuf *hdr, char *arg UNUSED)603{
604size_t objdirlen = strlen(get_object_directory());605struct strbuf buf = STRBUF_INIT;606struct packed_git *p;607size_t cnt = 0;608
609select_getanyfile(hdr);610for (p = get_all_packs(the_repository); p; p = p->next) {611if (p->pack_local)612cnt++;613}614
615strbuf_grow(&buf, cnt * 53 + 2);616for (p = get_all_packs(the_repository); p; p = p->next) {617if (p->pack_local)618strbuf_addf(&buf, "P %s\n", p->pack_name + objdirlen + 6);619}620strbuf_addch(&buf, '\n');621
622hdr_nocache(hdr);623send_strbuf(hdr, "text/plain; charset=utf-8", &buf);624strbuf_release(&buf);625}
626
627static void check_content_type(struct strbuf *hdr, const char *accepted_type)628{
629const char *actual_type = getenv("CONTENT_TYPE");630
631if (!actual_type)632actual_type = "";633
634if (strcmp(actual_type, accepted_type)) {635http_status(hdr, 415, "Unsupported Media Type");636hdr_nocache(hdr);637end_headers(hdr);638format_write(1,639"Expected POST with Content-Type '%s',"640" but received '%s' instead.\n",641accepted_type, actual_type);642exit(0);643}644}
645
646static void service_rpc(struct strbuf *hdr, char *service_name)647{
648struct strvec argv = STRVEC_INIT;649struct rpc_service *svc = select_service(hdr, service_name);650struct strbuf buf = STRBUF_INIT;651
652strvec_push(&argv, svc->name);653if (strcmp(service_name, "git-upload-archive"))654strvec_push(&argv, "--stateless-rpc");655strvec_push(&argv, ".");656
657strbuf_reset(&buf);658strbuf_addf(&buf, "application/x-git-%s-request", svc->name);659check_content_type(hdr, buf.buf);660
661hdr_nocache(hdr);662
663strbuf_reset(&buf);664strbuf_addf(&buf, "application/x-git-%s-result", svc->name);665hdr_str(hdr, content_type, buf.buf);666
667end_headers(hdr);668
669run_service(argv.v, svc->buffer_input);670strbuf_release(&buf);671strvec_clear(&argv);672}
673
674static int dead;675static NORETURN void die_webcgi(const char *err, va_list params)676{
677if (dead <= 1) {678struct strbuf hdr = STRBUF_INIT;679report_fn die_message_fn = get_die_message_routine();680
681die_message_fn(err, params);682
683http_status(&hdr, 500, "Internal Server Error");684hdr_nocache(&hdr);685end_headers(&hdr);686}687exit(0); /* we successfully reported a failure ;-) */688}
689
690static int die_webcgi_recursing(void)691{
692return dead++ > 1;693}
694
695static char* getdir(void)696{
697struct strbuf buf = STRBUF_INIT;698char *pathinfo = getenv("PATH_INFO");699char *root = getenv("GIT_PROJECT_ROOT");700char *path = getenv("PATH_TRANSLATED");701
702if (root && *root) {703if (!pathinfo || !*pathinfo)704die("GIT_PROJECT_ROOT is set but PATH_INFO is not");705if (daemon_avoid_alias(pathinfo))706die("'%s': aliased", pathinfo);707end_url_with_slash(&buf, root);708if (pathinfo[0] == '/')709pathinfo++;710strbuf_addstr(&buf, pathinfo);711return strbuf_detach(&buf, NULL);712} else if (path && *path) {713return xstrdup(path);714} else715die("No GIT_PROJECT_ROOT or PATH_TRANSLATED from server");716return NULL;717}
718
719static struct service_cmd {720const char *method;721const char *pattern;722void (*imp)(struct strbuf *, char *);723} services[] = {724{"GET", "/HEAD$", get_head},725{"GET", "/info/refs$", get_info_refs},726{"GET", "/objects/info/alternates$", get_text_file},727{"GET", "/objects/info/http-alternates$", get_text_file},728{"GET", "/objects/info/packs$", get_info_packs},729{"GET", "/objects/[0-9a-f]{2}/[0-9a-f]{38}$", get_loose_object},730{"GET", "/objects/[0-9a-f]{2}/[0-9a-f]{62}$", get_loose_object},731{"GET", "/objects/pack/pack-[0-9a-f]{40}\\.pack$", get_pack_file},732{"GET", "/objects/pack/pack-[0-9a-f]{64}\\.pack$", get_pack_file},733{"GET", "/objects/pack/pack-[0-9a-f]{40}\\.idx$", get_idx_file},734{"GET", "/objects/pack/pack-[0-9a-f]{64}\\.idx$", get_idx_file},735
736{"POST", "/git-upload-pack$", service_rpc},737{"POST", "/git-upload-archive$", service_rpc},738{"POST", "/git-receive-pack$", service_rpc}739};740
741static int bad_request(struct strbuf *hdr, const struct service_cmd *c)742{
743const char *proto = getenv("SERVER_PROTOCOL");744
745if (proto && !strcmp(proto, "HTTP/1.1")) {746http_status(hdr, 405, "Method Not Allowed");747hdr_str(hdr, "Allow",748!strcmp(c->method, "GET") ? "GET, HEAD" : c->method);749} else750http_status(hdr, 400, "Bad Request");751hdr_nocache(hdr);752end_headers(hdr);753return 0;754}
755
756int cmd_main(int argc UNUSED, const char **argv UNUSED)757{
758const char *method = getenv("REQUEST_METHOD");759const char *proto_header;760char *dir;761struct service_cmd *cmd = NULL;762char *cmd_arg = NULL;763int i;764struct strbuf hdr = STRBUF_INIT;765
766set_die_routine(die_webcgi);767set_die_is_recursing_routine(die_webcgi_recursing);768
769if (!method)770die("No REQUEST_METHOD from server");771if (!strcmp(method, "HEAD"))772method = "GET";773dir = getdir();774
775for (i = 0; i < ARRAY_SIZE(services); i++) {776struct service_cmd *c = &services[i];777regex_t re;778regmatch_t out[1];779int ret;780
781if (regcomp(&re, c->pattern, REG_EXTENDED))782die("Bogus regex in service table: %s", c->pattern);783ret = regexec(&re, dir, 1, out, 0);784regfree(&re);785
786if (!ret) {787size_t n;788
789if (strcmp(method, c->method))790return bad_request(&hdr, c);791
792cmd = c;793n = out[0].rm_eo - out[0].rm_so;794cmd_arg = xmemdupz(dir + out[0].rm_so + 1, n - 1);795dir[out[0].rm_so] = 0;796break;797}798}799
800if (!cmd)801not_found(&hdr, "Request not supported: '%s'", dir);802
803setup_path();804if (!enter_repo(dir, 0))805not_found(&hdr, "Not a git repository: '%s'", dir);806if (!getenv("GIT_HTTP_EXPORT_ALL") &&807access("git-daemon-export-ok", F_OK) )808not_found(&hdr, "Repository not exported: '%s'", dir);809free(dir);810
811http_config();812max_request_buffer = git_env_ulong("GIT_HTTP_MAX_REQUEST_BUFFER",813max_request_buffer);814proto_header = getenv("HTTP_GIT_PROTOCOL");815if (proto_header)816setenv(GIT_PROTOCOL_ENVIRONMENT, proto_header, 0);817
818cmd->imp(&hdr, cmd_arg);819free(cmd_arg);820return 0;821}
822