1 #define USE_THE_REPOSITORY_VARIABLE
3 #include "git-compat-util.h"
6 #include "environment.h"
11 #include "run-command.h"
14 #include "string-list.h"
17 #define initgroups(x, y) (0) /* nothing */
20 static enum log_destination
{
21 LOG_DESTINATION_UNSET
= -1,
22 LOG_DESTINATION_NONE
= 0,
23 LOG_DESTINATION_STDERR
= 1,
24 LOG_DESTINATION_SYSLOG
= 2,
25 } log_destination
= LOG_DESTINATION_UNSET
;
28 static int informative_errors
;
30 static const char daemon_usage
[] =
31 "git daemon [--verbose] [--syslog] [--export-all]\n"
32 " [--timeout=<n>] [--init-timeout=<n>] [--max-connections=<n>]\n"
33 " [--strict-paths] [--base-path=<path>] [--base-path-relaxed]\n"
34 " [--user-path | --user-path=<path>]\n"
35 " [--interpolated-path=<path>]\n"
36 " [--reuseaddr] [--pid-file=<file>]\n"
37 " [--(enable|disable|allow-override|forbid-override)=<service>]\n"
38 " [--access-hook=<path>]\n"
39 " [--inetd | [--listen=<host_or_ipaddr>] [--port=<n>]\n"
40 " [--detach] [--user=<user> [--group=<group>]]\n"
41 " [--log-destination=(stderr|syslog|none)]\n"
44 /* List of acceptable pathname prefixes */
45 static const char **ok_paths
;
46 static int strict_paths
;
48 /* If this is set, git-daemon-export-ok is not required */
49 static int export_all_trees
;
51 /* Take all paths relative to this one if non-NULL */
52 static const char *base_path
;
53 static const char *interpolated_path
;
54 static int base_path_relaxed
;
56 /* If defined, ~user notation is allowed and the string is inserted
57 * after ~user/. E.g. a request to git://host/~alice/frotz would
58 * go to /home/alice/pub_git/frotz with --user-path=pub_git.
60 static const char *user_path
;
62 /* Timeout, and initial timeout */
63 static unsigned int timeout
;
64 static unsigned int init_timeout
;
67 struct strbuf hostname
;
68 struct strbuf canon_hostname
;
69 struct strbuf ip_address
;
70 struct strbuf tcp_port
;
71 unsigned int hostname_lookup_done
:1;
72 unsigned int saw_extended_args
:1;
74 #define HOSTINFO_INIT { \
75 .hostname = STRBUF_INIT, \
76 .canon_hostname = STRBUF_INIT, \
77 .ip_address = STRBUF_INIT, \
78 .tcp_port = STRBUF_INIT, \
81 static void lookup_hostname(struct hostinfo
*hi
);
83 static const char *get_canon_hostname(struct hostinfo
*hi
)
86 return hi
->canon_hostname
.buf
;
89 static const char *get_ip_address(struct hostinfo
*hi
)
92 return hi
->ip_address
.buf
;
95 static void logreport(int priority
, const char *err
, va_list params
)
97 switch (log_destination
) {
98 case LOG_DESTINATION_SYSLOG
: {
100 vsnprintf(buf
, sizeof(buf
), err
, params
);
101 syslog(priority
, "%s", buf
);
104 case LOG_DESTINATION_STDERR
:
106 * Since stderr is set to buffered mode, the
107 * logging of different processes will not overlap
108 * unless they overflow the (rather big) buffers.
110 fprintf(stderr
, "[%"PRIuMAX
"] ", (uintmax_t)getpid());
111 vfprintf(stderr
, err
, params
);
115 case LOG_DESTINATION_NONE
:
117 case LOG_DESTINATION_UNSET
:
118 BUG("log destination not initialized correctly");
122 __attribute__((format (printf
, 1, 2)))
123 static void logerror(const char *err
, ...)
126 va_start(params
, err
);
127 logreport(LOG_ERR
, err
, params
);
131 __attribute__((format (printf
, 1, 2)))
132 static void loginfo(const char *err
, ...)
137 va_start(params
, err
);
138 logreport(LOG_INFO
, err
, params
);
142 static void NORETURN
daemon_die(const char *err
, va_list params
)
144 logreport(LOG_ERR
, err
, params
);
148 static const char *path_ok(const char *directory
, struct hostinfo
*hi
)
150 static char rpath
[PATH_MAX
];
151 static char interp_path
[PATH_MAX
];
155 unsigned enter_repo_flags
;
159 if (daemon_avoid_alias(dir
)) {
160 logerror("'%s': aliased", dir
);
166 logerror("'%s': User-path not allowed", dir
);
170 /* Got either "~alice" or "~alice/foo";
171 * rewrite them to "~alice/%s" or
174 int namlen
, restlen
= strlen(dir
);
175 const char *slash
= strchr(dir
, '/');
177 slash
= dir
+ restlen
;
178 namlen
= slash
- dir
;
180 loginfo("userpath <%s>, request <%s>, namlen %d, restlen %d, slash <%s>", user_path
, dir
, namlen
, restlen
, slash
);
181 rlen
= snprintf(rpath
, sizeof(rpath
), "%.*s/%s%.*s",
182 namlen
, dir
, user_path
, restlen
, slash
);
183 if (rlen
>= sizeof(rpath
)) {
184 logerror("user-path too large: %s", rpath
);
190 else if (interpolated_path
&& hi
->saw_extended_args
) {
191 struct strbuf expanded_path
= STRBUF_INIT
;
192 const char *format
= interpolated_path
;
195 /* Allow only absolute */
196 logerror("'%s': Non-absolute path denied (interpolated-path active)", dir
);
200 while (strbuf_expand_step(&expanded_path
, &format
)) {
201 if (skip_prefix(format
, "%", &format
))
202 strbuf_addch(&expanded_path
, '%');
203 else if (skip_prefix(format
, "H", &format
))
204 strbuf_addbuf(&expanded_path
, &hi
->hostname
);
205 else if (skip_prefix(format
, "CH", &format
))
206 strbuf_addstr(&expanded_path
,
207 get_canon_hostname(hi
));
208 else if (skip_prefix(format
, "IP", &format
))
209 strbuf_addstr(&expanded_path
,
211 else if (skip_prefix(format
, "P", &format
))
212 strbuf_addbuf(&expanded_path
, &hi
->tcp_port
);
213 else if (skip_prefix(format
, "D", &format
))
214 strbuf_addstr(&expanded_path
, directory
);
216 strbuf_addch(&expanded_path
, '%');
219 rlen
= strlcpy(interp_path
, expanded_path
.buf
,
220 sizeof(interp_path
));
221 strbuf_release(&expanded_path
);
222 if (rlen
>= sizeof(interp_path
)) {
223 logerror("interpolated path too large: %s",
228 loginfo("Interpolated dir '%s'", interp_path
);
232 else if (base_path
) {
234 /* Allow only absolute */
235 logerror("'%s': Non-absolute path denied (base-path active)", dir
);
238 rlen
= snprintf(rpath
, sizeof(rpath
), "%s%s", base_path
, dir
);
239 if (rlen
>= sizeof(rpath
)) {
240 logerror("base-path too large: %s", rpath
);
246 enter_repo_flags
= strict_paths
? ENTER_REPO_STRICT
: 0;
247 path
= enter_repo(dir
, enter_repo_flags
);
248 if (!path
&& base_path
&& base_path_relaxed
) {
250 * if we fail and base_path_relaxed is enabled, try without
251 * prefixing the base path
254 path
= enter_repo(dir
, enter_repo_flags
);
258 logerror("'%s' does not appear to be a git repository", dir
);
262 if ( ok_paths
&& *ok_paths
) {
264 int pathlen
= strlen(path
);
266 /* The validation is done on the paths after enter_repo
267 * appends optional {.git,.git/.git} and friends, but
268 * it does not use getcwd(). So if your /pub is
269 * a symlink to /mnt/pub, you can include /pub and
270 * do not have to say /mnt/pub.
273 for ( pp
= ok_paths
; *pp
; pp
++ ) {
274 int len
= strlen(*pp
);
275 if (len
<= pathlen
&&
276 !memcmp(*pp
, path
, len
) &&
277 (path
[len
] == '\0' ||
278 (!strict_paths
&& path
[len
] == '/')))
283 /* be backwards compatible */
288 logerror("'%s': not in directory list", path
);
289 return NULL
; /* Fallthrough. Deny by default */
292 typedef int (*daemon_service_fn
)(const struct strvec
*env
);
293 struct daemon_service
{
295 const char *config_name
;
296 daemon_service_fn fn
;
301 static int daemon_error(const char *dir
, const char *msg
)
303 if (!informative_errors
)
304 msg
= "access denied or repository not exported";
305 packet_write_fmt(1, "ERR %s: %s", msg
, dir
);
309 static const char *access_hook
;
311 static int run_access_hook(struct daemon_service
*service
, const char *dir
,
312 const char *path
, struct hostinfo
*hi
)
314 struct child_process child
= CHILD_PROCESS_INIT
;
315 struct strbuf buf
= STRBUF_INIT
;
319 strvec_push(&child
.args
, access_hook
);
320 strvec_push(&child
.args
, service
->name
);
321 strvec_push(&child
.args
, path
);
322 strvec_push(&child
.args
, hi
->hostname
.buf
);
323 strvec_push(&child
.args
, get_canon_hostname(hi
));
324 strvec_push(&child
.args
, get_ip_address(hi
));
325 strvec_push(&child
.args
, hi
->tcp_port
.buf
);
331 if (start_command(&child
)) {
332 logerror("daemon access hook '%s' failed to start",
336 if (strbuf_read(&buf
, child
.out
, 0) < 0) {
337 logerror("failed to read from pipe to daemon access hook '%s'",
342 if (close(child
.out
) < 0) {
343 logerror("failed to close pipe to daemon access hook '%s'",
347 if (finish_command(&child
))
351 strbuf_release(&buf
);
358 strbuf_addstr(&buf
, "service rejected");
359 eol
= strchr(buf
.buf
, '\n');
363 daemon_error(dir
, buf
.buf
);
364 strbuf_release(&buf
);
368 static int run_service(const char *dir
, struct daemon_service
*service
,
369 struct hostinfo
*hi
, const struct strvec
*env
)
372 int enabled
= service
->enabled
;
373 struct strbuf var
= STRBUF_INIT
;
375 loginfo("Request %s for '%s'", service
->name
, dir
);
377 if (!enabled
&& !service
->overridable
) {
378 logerror("'%s': service not enabled.", service
->name
);
380 return daemon_error(dir
, "service not enabled");
383 if (!(path
= path_ok(dir
, hi
)))
384 return daemon_error(dir
, "no such repository");
387 * Security on the cheap.
389 * We want a readable HEAD, usable "objects" directory, and
390 * a "git-daemon-export-ok" flag that says that the other side
391 * is ok with us doing this.
393 * path_ok() uses enter_repo() and checks for included directories.
394 * We only need to make sure the repository is exported.
397 if (!export_all_trees
&& access("git-daemon-export-ok", F_OK
)) {
398 logerror("'%s': repository not exported.", path
);
400 return daemon_error(dir
, "repository not exported");
403 if (service
->overridable
) {
404 strbuf_addf(&var
, "daemon.%s", service
->config_name
);
405 git_config_get_bool(var
.buf
, &enabled
);
406 strbuf_release(&var
);
409 logerror("'%s': service not enabled for '%s'",
410 service
->name
, path
);
412 return daemon_error(dir
, "service not enabled");
416 * Optionally, a hook can choose to deny access to the
417 * repository depending on the phase of the moon.
419 if (access_hook
&& run_access_hook(service
, dir
, path
, hi
))
423 * We'll ignore SIGTERM from now on, we have a
426 signal(SIGTERM
, SIG_IGN
);
428 return service
->fn(env
);
431 static void copy_to_log(int fd
)
433 struct strbuf line
= STRBUF_INIT
;
436 fp
= fdopen(fd
, "r");
438 logerror("fdopen of error channel failed");
443 while (strbuf_getline_lf(&line
, fp
) != EOF
) {
444 logerror("%s", line
.buf
);
445 strbuf_setlen(&line
, 0);
448 strbuf_release(&line
);
452 static int run_service_command(struct child_process
*cld
)
454 strvec_push(&cld
->args
, ".");
457 if (start_command(cld
))
463 copy_to_log(cld
->err
);
465 return finish_command(cld
);
468 static int upload_pack(const struct strvec
*env
)
470 struct child_process cld
= CHILD_PROCESS_INIT
;
471 strvec_pushl(&cld
.args
, "upload-pack", "--strict", NULL
);
472 strvec_pushf(&cld
.args
, "--timeout=%u", timeout
);
474 strvec_pushv(&cld
.env
, env
->v
);
476 return run_service_command(&cld
);
479 static int upload_archive(const struct strvec
*env
)
481 struct child_process cld
= CHILD_PROCESS_INIT
;
482 strvec_push(&cld
.args
, "upload-archive");
484 strvec_pushv(&cld
.env
, env
->v
);
486 return run_service_command(&cld
);
489 static int receive_pack(const struct strvec
*env
)
491 struct child_process cld
= CHILD_PROCESS_INIT
;
492 strvec_push(&cld
.args
, "receive-pack");
494 strvec_pushv(&cld
.env
, env
->v
);
496 return run_service_command(&cld
);
499 static struct daemon_service daemon_service
[] = {
500 { "upload-archive", "uploadarch", upload_archive
, 0, 1 },
501 { "upload-pack", "uploadpack", upload_pack
, 1, 1 },
502 { "receive-pack", "receivepack", receive_pack
, 0, 1 },
505 static void enable_service(const char *name
, int ena
)
507 for (size_t i
= 0; i
< ARRAY_SIZE(daemon_service
); i
++) {
508 if (!strcmp(daemon_service
[i
].name
, name
)) {
509 daemon_service
[i
].enabled
= ena
;
513 die("No such service %s", name
);
516 static void make_service_overridable(const char *name
, int ena
)
518 for (size_t i
= 0; i
< ARRAY_SIZE(daemon_service
); i
++) {
519 if (!strcmp(daemon_service
[i
].name
, name
)) {
520 daemon_service
[i
].overridable
= ena
;
524 die("No such service %s", name
);
527 static void parse_host_and_port(char *hostport
, char **host
,
530 if (*hostport
== '[') {
533 end
= strchr(hostport
, ']');
535 die("Invalid request ('[' without ']')");
537 *host
= hostport
+ 1;
540 else if (end
[1] == ':')
543 die("Garbage after end of host part");
546 *port
= strrchr(hostport
, ':');
555 * Sanitize a string from the client so that it's OK to be inserted into a
556 * filesystem path. Specifically, we disallow directory separators, runs
557 * of "..", and trailing and leading dots, which means that the client
558 * cannot escape our base path via ".." traversal.
560 static void sanitize_client(struct strbuf
*out
, const char *in
)
565 if (*in
== '.' && (!out
->len
|| out
->buf
[out
->len
- 1] == '.'))
567 strbuf_addch(out
, *in
);
570 while (out
->len
&& out
->buf
[out
->len
- 1] == '.')
571 strbuf_setlen(out
, out
->len
- 1);
575 * Like sanitize_client, but we also perform any canonicalization
576 * to make life easier on the admin.
578 static void canonicalize_client(struct strbuf
*out
, const char *in
)
580 sanitize_client(out
, in
);
585 * Read the host as supplied by the client connection.
587 * Returns a pointer to the character after the NUL byte terminating the host
588 * argument, or 'extra_args' if there is no host argument.
590 static char *parse_host_arg(struct hostinfo
*hi
, char *extra_args
, int buflen
)
594 char *end
= extra_args
+ buflen
;
596 if (extra_args
< end
&& *extra_args
) {
597 hi
->saw_extended_args
= 1;
598 if (strncasecmp("host=", extra_args
, 5) == 0) {
599 val
= extra_args
+ 5;
600 vallen
= strlen(val
) + 1;
601 loginfo("Extended attribute \"host\": %s", val
);
603 /* Split <host>:<port> at colon. */
606 parse_host_and_port(val
, &host
, &port
);
608 sanitize_client(&hi
->tcp_port
, port
);
609 canonicalize_client(&hi
->hostname
, host
);
610 hi
->hostname_lookup_done
= 0;
613 /* On to the next one */
614 extra_args
= val
+ vallen
;
616 if (extra_args
< end
&& *extra_args
)
617 die("Invalid request");
623 static void parse_extra_args(struct hostinfo
*hi
, struct strvec
*env
,
624 char *extra_args
, int buflen
)
626 const char *end
= extra_args
+ buflen
;
627 struct strbuf git_protocol
= STRBUF_INIT
;
629 /* First look for the host argument */
630 extra_args
= parse_host_arg(hi
, extra_args
, buflen
);
632 /* Look for additional arguments places after a second NUL byte */
633 for (; extra_args
< end
; extra_args
+= strlen(extra_args
) + 1) {
634 const char *arg
= extra_args
;
637 * Parse the extra arguments, adding most to 'git_protocol'
638 * which will be used to set the 'GIT_PROTOCOL' envvar in the
639 * service that will be run.
641 * If there ends up being a particular arg in the future that
642 * git-daemon needs to parse specifically (like the 'host' arg)
643 * then it can be parsed here and not added to 'git_protocol'.
646 if (git_protocol
.len
> 0)
647 strbuf_addch(&git_protocol
, ':');
648 strbuf_addstr(&git_protocol
, arg
);
652 if (git_protocol
.len
> 0) {
653 loginfo("Extended attribute \"protocol\": %s", git_protocol
.buf
);
654 strvec_pushf(env
, GIT_PROTOCOL_ENVIRONMENT
"=%s",
657 strbuf_release(&git_protocol
);
661 * Locate canonical hostname and its IP address.
663 static void lookup_hostname(struct hostinfo
*hi
)
665 if (!hi
->hostname_lookup_done
&& hi
->hostname
.len
) {
667 struct addrinfo hints
;
670 static char addrbuf
[HOST_NAME_MAX
+ 1];
672 memset(&hints
, 0, sizeof(hints
));
673 hints
.ai_flags
= AI_CANONNAME
;
675 gai
= getaddrinfo(hi
->hostname
.buf
, NULL
, &hints
, &ai
);
677 struct sockaddr_in
*sin_addr
= (void *)ai
->ai_addr
;
679 inet_ntop(AF_INET
, &sin_addr
->sin_addr
,
680 addrbuf
, sizeof(addrbuf
));
681 strbuf_addstr(&hi
->ip_address
, addrbuf
);
683 if (ai
->ai_canonname
)
684 sanitize_client(&hi
->canon_hostname
,
687 strbuf_addbuf(&hi
->canon_hostname
,
693 struct hostent
*hent
;
694 struct sockaddr_in sa
;
696 static char addrbuf
[HOST_NAME_MAX
+ 1];
698 hent
= gethostbyname(hi
->hostname
.buf
);
700 ap
= hent
->h_addr_list
;
701 memset(&sa
, 0, sizeof sa
);
702 sa
.sin_family
= hent
->h_addrtype
;
703 sa
.sin_port
= htons(0);
704 memcpy(&sa
.sin_addr
, *ap
, hent
->h_length
);
706 inet_ntop(hent
->h_addrtype
, &sa
.sin_addr
,
707 addrbuf
, sizeof(addrbuf
));
709 sanitize_client(&hi
->canon_hostname
, hent
->h_name
);
710 strbuf_addstr(&hi
->ip_address
, addrbuf
);
713 hi
->hostname_lookup_done
= 1;
717 static void hostinfo_clear(struct hostinfo
*hi
)
719 strbuf_release(&hi
->hostname
);
720 strbuf_release(&hi
->canon_hostname
);
721 strbuf_release(&hi
->ip_address
);
722 strbuf_release(&hi
->tcp_port
);
725 static void set_keep_alive(int sockfd
)
729 if (setsockopt(sockfd
, SOL_SOCKET
, SO_KEEPALIVE
, &ka
, sizeof(ka
)) < 0) {
730 if (errno
!= ENOTSOCK
)
731 logerror("unable to set SO_KEEPALIVE on socket: %s",
736 static int execute(void)
738 char *line
= packet_buffer
;
740 char *addr
= getenv("REMOTE_ADDR"), *port
= getenv("REMOTE_PORT");
741 struct hostinfo hi
= HOSTINFO_INIT
;
742 struct strvec env
= STRVEC_INIT
;
745 loginfo("Connection from %s:%s", addr
, port
);
748 alarm(init_timeout
? init_timeout
: timeout
);
749 pktlen
= packet_read(0, packet_buffer
, sizeof(packet_buffer
), 0);
753 if (len
&& line
[len
-1] == '\n')
756 /* parse additional args hidden behind a NUL byte */
758 parse_extra_args(&hi
, &env
, line
+ len
+ 1, pktlen
- len
- 1);
760 for (size_t i
= 0; i
< ARRAY_SIZE(daemon_service
); i
++) {
761 struct daemon_service
*s
= &(daemon_service
[i
]);
764 if (skip_prefix(line
, "git-", &arg
) &&
765 skip_prefix(arg
, s
->name
, &arg
) &&
768 * Note: The directory here is probably context sensitive,
769 * and might depend on the actual service being performed.
771 int rc
= run_service(arg
, s
, &hi
, &env
);
780 logerror("Protocol error: '%s'", line
);
784 static int addrcmp(const struct sockaddr_storage
*s1
,
785 const struct sockaddr_storage
*s2
)
787 const struct sockaddr
*sa1
= (const struct sockaddr
*) s1
;
788 const struct sockaddr
*sa2
= (const struct sockaddr
*) s2
;
790 if (sa1
->sa_family
!= sa2
->sa_family
)
791 return sa1
->sa_family
- sa2
->sa_family
;
792 if (sa1
->sa_family
== AF_INET
)
793 return memcmp(&((struct sockaddr_in
*)s1
)->sin_addr
,
794 &((struct sockaddr_in
*)s2
)->sin_addr
,
795 sizeof(struct in_addr
));
797 if (sa1
->sa_family
== AF_INET6
)
798 return memcmp(&((struct sockaddr_in6
*)s1
)->sin6_addr
,
799 &((struct sockaddr_in6
*)s2
)->sin6_addr
,
800 sizeof(struct in6_addr
));
805 static unsigned int max_connections
= 32;
806 static unsigned int live_children
;
808 static struct child
{
810 struct child_process cld
;
811 struct sockaddr_storage address
;
814 static void add_child(struct child_process
*cld
, struct sockaddr
*addr
, socklen_t addrlen
)
816 struct child
*newborn
, **cradle
;
818 CALLOC_ARRAY(newborn
, 1);
820 memcpy(&newborn
->cld
, cld
, sizeof(*cld
));
821 memcpy(&newborn
->address
, addr
, addrlen
);
822 for (cradle
= &firstborn
; *cradle
; cradle
= &(*cradle
)->next
)
823 if (!addrcmp(&(*cradle
)->address
, &newborn
->address
))
825 newborn
->next
= *cradle
;
830 * This gets called if the number of connections grows
831 * past "max_connections".
833 * We kill the newest connection from a duplicate IP.
835 static void kill_some_child(void)
837 const struct child
*blanket
, *next
;
839 if (!(blanket
= firstborn
))
842 for (; (next
= blanket
->next
); blanket
= next
)
843 if (!addrcmp(&blanket
->address
, &next
->address
)) {
844 kill(blanket
->cld
.pid
, SIGTERM
);
849 static void check_dead_children(void)
854 struct child
**cradle
, *blanket
;
855 for (cradle
= &firstborn
; (blanket
= *cradle
);)
856 if ((pid
= waitpid(blanket
->cld
.pid
, &status
, WNOHANG
)) > 1) {
857 const char *dead
= "";
859 dead
= " (with error)";
860 loginfo("[%"PRIuMAX
"] Disconnected%s", (uintmax_t)pid
, dead
);
862 /* remove the child */
863 *cradle
= blanket
->next
;
865 child_process_clear(&blanket
->cld
);
868 cradle
= &blanket
->next
;
871 static struct strvec cld_argv
= STRVEC_INIT
;
872 static void handle(int incoming
, struct sockaddr
*addr
, socklen_t addrlen
)
874 struct child_process cld
= CHILD_PROCESS_INIT
;
876 if (max_connections
&& live_children
>= max_connections
) {
878 sleep(1); /* give it some time to die */
879 check_dead_children();
880 if (live_children
>= max_connections
) {
882 logerror("Too many children, dropping connection");
887 if (addr
->sa_family
== AF_INET
) {
889 struct sockaddr_in
*sin_addr
= (void *) addr
;
890 inet_ntop(addr
->sa_family
, &sin_addr
->sin_addr
, buf
, sizeof(buf
));
891 strvec_pushf(&cld
.env
, "REMOTE_ADDR=%s", buf
);
892 strvec_pushf(&cld
.env
, "REMOTE_PORT=%d",
893 ntohs(sin_addr
->sin_port
));
895 } else if (addr
->sa_family
== AF_INET6
) {
897 struct sockaddr_in6
*sin6_addr
= (void *) addr
;
898 inet_ntop(AF_INET6
, &sin6_addr
->sin6_addr
, buf
, sizeof(buf
));
899 strvec_pushf(&cld
.env
, "REMOTE_ADDR=[%s]", buf
);
900 strvec_pushf(&cld
.env
, "REMOTE_PORT=%d",
901 ntohs(sin6_addr
->sin6_port
));
905 strvec_pushv(&cld
.args
, cld_argv
.v
);
907 cld
.out
= dup(incoming
);
909 if (start_command(&cld
))
910 logerror("unable to fork");
912 add_child(&cld
, addr
, addrlen
);
915 static void child_handler(int signo UNUSED
)
918 * Otherwise empty handler because systemcalls will get interrupted
919 * upon signal receipt
920 * SysV needs the handler to be rearmed
922 signal(SIGCHLD
, child_handler
);
925 static int set_reuse_addr(int sockfd
)
931 return setsockopt(sockfd
, SOL_SOCKET
, SO_REUSEADDR
,
941 static const char *ip2str(int family
, struct sockaddr
*sin
, socklen_t len
)
944 static char ip
[INET_ADDRSTRLEN
];
946 static char ip
[INET6_ADDRSTRLEN
];
952 inet_ntop(family
, &((struct sockaddr_in6
*)sin
)->sin6_addr
, ip
, len
);
956 inet_ntop(family
, &((struct sockaddr_in
*)sin
)->sin_addr
, ip
, len
);
959 xsnprintf(ip
, sizeof(ip
), "<unknown>");
966 static int setup_named_sock(char *listen_addr
, int listen_port
, struct socketlist
*socklist
)
969 char pbuf
[NI_MAXSERV
];
970 struct addrinfo hints
, *ai0
, *ai
;
974 xsnprintf(pbuf
, sizeof(pbuf
), "%d", listen_port
);
975 memset(&hints
, 0, sizeof(hints
));
976 hints
.ai_family
= AF_UNSPEC
;
977 hints
.ai_socktype
= SOCK_STREAM
;
978 hints
.ai_protocol
= IPPROTO_TCP
;
979 hints
.ai_flags
= AI_PASSIVE
;
981 gai
= getaddrinfo(listen_addr
, pbuf
, &hints
, &ai0
);
983 logerror("getaddrinfo() for %s failed: %s", listen_addr
, gai_strerror(gai
));
987 for (ai
= ai0
; ai
; ai
= ai
->ai_next
) {
990 sockfd
= socket(ai
->ai_family
, ai
->ai_socktype
, ai
->ai_protocol
);
993 if (sockfd
>= FD_SETSIZE
) {
994 logerror("Socket descriptor too large");
1000 if (ai
->ai_family
== AF_INET6
) {
1002 setsockopt(sockfd
, IPPROTO_IPV6
, IPV6_V6ONLY
,
1004 /* Note: error is not fatal */
1008 if (set_reuse_addr(sockfd
)) {
1009 logerror("Could not set SO_REUSEADDR: %s", strerror(errno
));
1014 set_keep_alive(sockfd
);
1016 if (bind(sockfd
, ai
->ai_addr
, ai
->ai_addrlen
) < 0) {
1017 logerror("Could not bind to %s: %s",
1018 ip2str(ai
->ai_family
, ai
->ai_addr
, ai
->ai_addrlen
),
1021 continue; /* not fatal */
1023 if (listen(sockfd
, 5) < 0) {
1024 logerror("Could not listen to %s: %s",
1025 ip2str(ai
->ai_family
, ai
->ai_addr
, ai
->ai_addrlen
),
1028 continue; /* not fatal */
1031 flags
= fcntl(sockfd
, F_GETFD
, 0);
1033 fcntl(sockfd
, F_SETFD
, flags
| FD_CLOEXEC
);
1035 ALLOC_GROW(socklist
->list
, socklist
->nr
+ 1, socklist
->alloc
);
1036 socklist
->list
[socklist
->nr
++] = sockfd
;
1047 static int setup_named_sock(char *listen_addr
, int listen_port
, struct socketlist
*socklist
)
1049 struct sockaddr_in sin
;
1053 memset(&sin
, 0, sizeof sin
);
1054 sin
.sin_family
= AF_INET
;
1055 sin
.sin_port
= htons(listen_port
);
1058 /* Well, host better be an IP address here. */
1059 if (inet_pton(AF_INET
, listen_addr
, &sin
.sin_addr
.s_addr
) <= 0)
1062 sin
.sin_addr
.s_addr
= htonl(INADDR_ANY
);
1065 sockfd
= socket(AF_INET
, SOCK_STREAM
, 0);
1069 if (set_reuse_addr(sockfd
)) {
1070 logerror("Could not set SO_REUSEADDR: %s", strerror(errno
));
1075 set_keep_alive(sockfd
);
1077 if ( bind(sockfd
, (struct sockaddr
*)&sin
, sizeof sin
) < 0 ) {
1078 logerror("Could not bind to %s: %s",
1079 ip2str(AF_INET
, (struct sockaddr
*)&sin
, sizeof(sin
)),
1085 if (listen(sockfd
, 5) < 0) {
1086 logerror("Could not listen to %s: %s",
1087 ip2str(AF_INET
, (struct sockaddr
*)&sin
, sizeof(sin
)),
1093 flags
= fcntl(sockfd
, F_GETFD
, 0);
1095 fcntl(sockfd
, F_SETFD
, flags
| FD_CLOEXEC
);
1097 ALLOC_GROW(socklist
->list
, socklist
->nr
+ 1, socklist
->alloc
);
1098 socklist
->list
[socklist
->nr
++] = sockfd
;
1104 static void socksetup(struct string_list
*listen_addr
, int listen_port
, struct socketlist
*socklist
)
1106 if (!listen_addr
->nr
)
1107 setup_named_sock(NULL
, listen_port
, socklist
);
1110 for (size_t i
= 0; i
< listen_addr
->nr
; i
++) {
1111 socknum
= setup_named_sock(listen_addr
->items
[i
].string
,
1112 listen_port
, socklist
);
1115 logerror("unable to allocate any listen sockets for host %s on port %u",
1116 listen_addr
->items
[i
].string
, listen_port
);
1121 static int service_loop(struct socketlist
*socklist
)
1125 CALLOC_ARRAY(pfd
, socklist
->nr
);
1127 for (size_t i
= 0; i
< socklist
->nr
; i
++) {
1128 pfd
[i
].fd
= socklist
->list
[i
];
1129 pfd
[i
].events
= POLLIN
;
1132 signal(SIGCHLD
, child_handler
);
1135 check_dead_children();
1137 if (poll(pfd
, socklist
->nr
, -1) < 0) {
1138 if (errno
!= EINTR
) {
1139 logerror("Poll failed, resuming: %s",
1146 for (size_t i
= 0; i
< socklist
->nr
; i
++) {
1147 if (pfd
[i
].revents
& POLLIN
) {
1150 struct sockaddr_in sai
;
1152 struct sockaddr_in6 sai6
;
1155 socklen_t sslen
= sizeof(ss
);
1156 int incoming
= accept(pfd
[i
].fd
, &ss
.sa
, &sslen
);
1164 die_errno("accept returned");
1167 handle(incoming
, &ss
.sa
, sslen
);
1173 #ifdef NO_POSIX_GOODIES
1177 static void drop_privileges(struct credentials
*cred UNUSED
)
1182 static struct credentials
*prepare_credentials(const char *user_name UNUSED
,
1183 const char *group_name UNUSED
)
1185 die("--user not supported on this platform");
1190 struct credentials
{
1191 struct passwd
*pass
;
1195 static void drop_privileges(struct credentials
*cred
)
1197 if (cred
&& (initgroups(cred
->pass
->pw_name
, cred
->gid
) ||
1198 setgid (cred
->gid
) || setuid(cred
->pass
->pw_uid
)))
1199 die("cannot drop privileges");
1202 static struct credentials
*prepare_credentials(const char *user_name
,
1203 const char *group_name
)
1205 static struct credentials c
;
1207 c
.pass
= getpwnam(user_name
);
1209 die("user not found - %s", user_name
);
1212 c
.gid
= c
.pass
->pw_gid
;
1214 struct group
*group
= getgrnam(group_name
);
1216 die("group not found - %s", group_name
);
1218 c
.gid
= group
->gr_gid
;
1225 static int serve(struct string_list
*listen_addr
, int listen_port
,
1226 struct credentials
*cred
)
1228 struct socketlist socklist
= { NULL
, 0, 0 };
1230 socksetup(listen_addr
, listen_port
, &socklist
);
1231 if (socklist
.nr
== 0)
1232 die("unable to allocate any listen sockets on port %u",
1235 drop_privileges(cred
);
1237 loginfo("Ready to rumble");
1239 return service_loop(&socklist
);
1242 int cmd_main(int argc
, const char **argv
)
1244 int listen_port
= 0;
1245 struct string_list listen_addr
= STRING_LIST_INIT_DUP
;
1246 int serve_mode
= 0, inetd_mode
= 0;
1247 const char *pid_file
= NULL
, *user_name
= NULL
, *group_name
= NULL
;
1249 struct credentials
*cred
= NULL
;
1253 for (i
= 1; i
< argc
; i
++) {
1254 const char *arg
= argv
[i
];
1257 if (skip_prefix(arg
, "--listen=", &v
)) {
1258 string_list_append_nodup(&listen_addr
, xstrdup_tolower(v
));
1261 if (skip_prefix(arg
, "--port=", &v
)) {
1264 n
= strtoul(v
, &end
, 0);
1270 if (!strcmp(arg
, "--serve")) {
1274 if (!strcmp(arg
, "--inetd")) {
1278 if (!strcmp(arg
, "--verbose")) {
1282 if (!strcmp(arg
, "--syslog")) {
1283 log_destination
= LOG_DESTINATION_SYSLOG
;
1286 if (skip_prefix(arg
, "--log-destination=", &v
)) {
1287 if (!strcmp(v
, "syslog")) {
1288 log_destination
= LOG_DESTINATION_SYSLOG
;
1290 } else if (!strcmp(v
, "stderr")) {
1291 log_destination
= LOG_DESTINATION_STDERR
;
1293 } else if (!strcmp(v
, "none")) {
1294 log_destination
= LOG_DESTINATION_NONE
;
1297 die("unknown log destination '%s'", v
);
1299 if (!strcmp(arg
, "--export-all")) {
1300 export_all_trees
= 1;
1303 if (skip_prefix(arg
, "--access-hook=", &v
)) {
1307 if (skip_prefix(arg
, "--timeout=", &v
)) {
1308 if (strtoul_ui(v
, 10, &timeout
))
1309 die(_("invalid timeout '%s', expecting a non-negative integer"), v
);
1312 if (skip_prefix(arg
, "--init-timeout=", &v
)) {
1313 if (strtoul_ui(v
, 10, &init_timeout
))
1314 die(_("invalid init-timeout '%s', expecting a non-negative integer"), v
);
1317 if (skip_prefix(arg
, "--max-connections=", &v
)) {
1319 if (strtol_i(v
, 10, &parsed_value
))
1320 die(_("invalid max-connections '%s', expecting an integer"), v
);
1321 /* A negative value indicates unlimited children. */
1322 max_connections
= parsed_value
< 0 ? 0 : parsed_value
;
1325 if (!strcmp(arg
, "--strict-paths")) {
1329 if (skip_prefix(arg
, "--base-path=", &v
)) {
1333 if (!strcmp(arg
, "--base-path-relaxed")) {
1334 base_path_relaxed
= 1;
1337 if (skip_prefix(arg
, "--interpolated-path=", &v
)) {
1338 interpolated_path
= v
;
1341 if (!strcmp(arg
, "--reuseaddr")) {
1345 if (!strcmp(arg
, "--user-path")) {
1349 if (skip_prefix(arg
, "--user-path=", &v
)) {
1353 if (skip_prefix(arg
, "--pid-file=", &v
)) {
1357 if (!strcmp(arg
, "--detach")) {
1361 if (skip_prefix(arg
, "--user=", &v
)) {
1365 if (skip_prefix(arg
, "--group=", &v
)) {
1369 if (skip_prefix(arg
, "--enable=", &v
)) {
1370 enable_service(v
, 1);
1373 if (skip_prefix(arg
, "--disable=", &v
)) {
1374 enable_service(v
, 0);
1377 if (skip_prefix(arg
, "--allow-override=", &v
)) {
1378 make_service_overridable(v
, 1);
1381 if (skip_prefix(arg
, "--forbid-override=", &v
)) {
1382 make_service_overridable(v
, 0);
1385 if (!strcmp(arg
, "--informative-errors")) {
1386 informative_errors
= 1;
1389 if (!strcmp(arg
, "--no-informative-errors")) {
1390 informative_errors
= 0;
1393 if (!strcmp(arg
, "--")) {
1394 ok_paths
= &argv
[i
+1];
1396 } else if (arg
[0] != '-') {
1397 ok_paths
= &argv
[i
];
1401 usage(daemon_usage
);
1404 if (log_destination
== LOG_DESTINATION_UNSET
) {
1405 if (inetd_mode
|| detach
)
1406 log_destination
= LOG_DESTINATION_SYSLOG
;
1408 log_destination
= LOG_DESTINATION_STDERR
;
1411 if (log_destination
== LOG_DESTINATION_SYSLOG
) {
1412 openlog("git-daemon", LOG_PID
, LOG_DAEMON
);
1413 set_die_routine(daemon_die
);
1415 /* avoid splitting a message in the middle */
1416 setvbuf(stderr
, NULL
, _IOFBF
, 4096);
1418 if (inetd_mode
&& (detach
|| group_name
|| user_name
))
1419 die("--detach, --user and --group are incompatible with --inetd");
1421 if (inetd_mode
&& (listen_port
|| (listen_addr
.nr
> 0)))
1422 die("--listen= and --port= are incompatible with --inetd");
1423 else if (listen_port
== 0)
1424 listen_port
= DEFAULT_GIT_PORT
;
1426 if (group_name
&& !user_name
)
1427 die("--group supplied without --user");
1430 cred
= prepare_credentials(user_name
, group_name
);
1432 if (strict_paths
&& (!ok_paths
|| !*ok_paths
))
1433 die("option --strict-paths requires '<directory>' arguments");
1435 if (base_path
&& !is_directory(base_path
))
1436 die("base-path '%s' does not exist or is not a directory",
1439 if (log_destination
!= LOG_DESTINATION_STDERR
) {
1440 if (!freopen("/dev/null", "w", stderr
))
1441 die_errno("failed to redirect stderr to /dev/null");
1444 if (inetd_mode
|| serve_mode
) {
1449 die("--detach not supported on this platform");
1453 write_file(pid_file
, "%"PRIuMAX
, (uintmax_t) getpid());
1455 /* prepare argv for serving-processes */
1456 strvec_push(&cld_argv
, argv
[0]); /* git-daemon */
1457 strvec_push(&cld_argv
, "--serve");
1458 for (i
= 1; i
< argc
; ++i
)
1459 strvec_push(&cld_argv
, argv
[i
]);
1461 ret
= serve(&listen_addr
, listen_port
, cred
);
1464 string_list_clear(&listen_addr
, 0);