git/http-backend.c

#define USE_THE_REPOSITORY_VARIABLE

#include "git-compat-util.h"
#include "config.h"
#include "environment.h"
#include "git-zlib.h"
#include "hex.h"
#include "path.h"
#include "repository.h"
#include "refs.h"
#include "pkt-line.h"
#include "object.h"
#include "tag.h"
#include "exec-cmd.h"
#include "run-command.h"
#include "string-list.h"
#include "url.h"
#include "strvec.h"
#include "packfile.h"
#include "object-store-ll.h"
#include "protocol.h"
#include "date.h"
#include "write-or-die.h"

static const char content_type[] = …;
static const char content_length[] = …;
static const char last_modified[] = …;
static int getanyfile = …;
static unsigned long max_request_buffer = …;

static struct string_list *query_params;

struct rpc_service { … };

static struct rpc_service rpc_service[] = …;

static struct string_list *get_parameters(void)
{ … }

static const char *get_parameter(const char *name)
{ … }

__attribute__((format (printf, 2, 3)))
static void format_write(int fd, const char *fmt, ...)
{ … }

static void http_status(struct strbuf *hdr, unsigned code, const char *msg)
{ … }

static void hdr_str(struct strbuf *hdr, const char *name, const char *value)
{ … }

static void hdr_int(struct strbuf *hdr, const char *name, uintmax_t value)
{ … }

static void hdr_date(struct strbuf *hdr, const char *name, timestamp_t when)
{ … }

static void hdr_nocache(struct strbuf *hdr)
{ … }

static void hdr_cache_forever(struct strbuf *hdr)
{ … }

static void end_headers(struct strbuf *hdr)
{ … }

__attribute__((format (printf, 2, 3)))
static NORETURN void not_found(struct strbuf *hdr, const char *err, ...)
{ … }

__attribute__((format (printf, 2, 3)))
static NORETURN void forbidden(struct strbuf *hdr, const char *err, ...)
{ … }

static void select_getanyfile(struct strbuf *hdr)
{ … }

static void send_strbuf(struct strbuf *hdr,
			const char *type, struct strbuf *buf)
{ … }

static void send_local_file(struct strbuf *hdr, const char *the_type,
				const char *name)
{ … }

static void get_text_file(struct strbuf *hdr, char *name)
{ … }

static void get_loose_object(struct strbuf *hdr, char *name)
{ … }

static void get_pack_file(struct strbuf *hdr, char *name)
{ … }

static void get_idx_file(struct strbuf *hdr, char *name)
{ … }

static void http_config(void)
{ … }

static struct rpc_service *select_service(struct strbuf *hdr, const char *name)
{ … }

static void write_to_child(int out, const unsigned char *buf, ssize_t len, const char *prog_name)
{ … }

/*
 * This is basically strbuf_read(), except that if we
 * hit max_request_buffer we die (we'd rather reject a
 * maliciously large request than chew up infinite memory).
 */
static ssize_t read_request_eof(int fd, unsigned char **out)
{ … }

static ssize_t read_request_fixed_len(int fd, ssize_t req_len, unsigned char **out)
{ … }

static ssize_t get_content_length(void)
{ … }

static ssize_t read_request(int fd, unsigned char **out, ssize_t req_len)
{ … }

static void inflate_request(const char *prog_name, int out, int buffer_input, ssize_t req_len)
{ … }

static void copy_request(const char *prog_name, int out, ssize_t req_len)
{ … }

static void pipe_fixed_length(const char *prog_name, int out, size_t req_len)
{ … }

static void run_service(const char **argv, int buffer_input)
{ … }

static int show_text_ref(const char *name, const char *referent UNUSED, const struct object_id *oid,
			 int flag UNUSED, void *cb_data)
{ … }

static void get_info_refs(struct strbuf *hdr, char *arg UNUSED)
{ … }

static int show_head_ref(const char *refname, const char *referent UNUSED, const struct object_id *oid,
			 int flag, void *cb_data)
{ … }

static void get_head(struct strbuf *hdr, char *arg UNUSED)
{ … }

static void get_info_packs(struct strbuf *hdr, char *arg UNUSED)
{ … }

static void check_content_type(struct strbuf *hdr, const char *accepted_type)
{ … }

static void service_rpc(struct strbuf *hdr, char *service_name)
{ … }

static int dead;
static NORETURN void die_webcgi(const char *err, va_list params)
{ … }

static int die_webcgi_recursing(void)
{ … }

static char* getdir(void)
{ … }

static struct service_cmd { … } services[] = …;

static int bad_request(struct strbuf *hdr, const struct service_cmd *c)
{ … }

int cmd_main(int argc UNUSED, const char **argv UNUSED)
{ … }