Bonjour,

J'ai actuellement un serveur sur lequel je fais tourner un serveur git dans un chroot (avec un utilisateur git qui est dans le chroot).

Malheureusement impossible pour moi d'effectuer un git clone dans le chroot (en dehors ça marche parfaitement) :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
bash-4.2$ git clone ../langc
Cloning into 'langc'...
error: cannot run git-upload-pack '/home/git/test/../langc': No such file or directory
fatal: unable to fork
Je suis donc allé faire un tour du côté des sources de git et j'ai trouvé ces lignes :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
                if (cmd->git_cmd) {
                        execv_git_cmd(cmd->argv);
                } else if (cmd->use_shell) {
                        execv_shell_cmd(cmd->argv);
                } else {
                        sane_execvp(cmd->argv[0], (char *const*) cmd->argv);
                }


                if (errno == ENOENT) {
                        if (!cmd->silent_exec_failure)
                                error("cannot run %s: %s", cmd->argv[0],
                                        strerror(ENOENT));
                        exit(127);
                }

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
int sane_execvp(const char *file, char * const argv[])
{
        if (!execvp(file, argv))
                return 0; /* cannot happen ;-) */

        /*
         * When a command can't be found because one of the directories
         * listed in $PATH is unsearchable, execvp reports EACCES, but
         * careful usability testing (read: analysis of occasional bug
         * reports) reveals that "No such file or directory" is more
         * intuitive.
         *
         * We avoid commands with "/", because execvp will not do $PATH
         * lookups in that case.
         *
         * The reassignment of EACCES to errno looks like a no-op below,
         * but we need to protect against exists_in_PATH overwriting errno.
         */
        if (errno == EACCES && !strchr(file, '/'))
                errno = exists_in_PATH(file) ? EACCES : ENOENT;
        else if (errno == ENOTDIR && !strchr(file, '/'))
                errno = ENOENT;
        return -1;
}
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
static int exists_in_PATH(const char *file)
{
        char *r = locate_in_PATH(file);
        free(r);
        return r != NULL;
}
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
static char *locate_in_PATH(const char *file)
{
        const char *p = getenv("PATH");
        struct strbuf buf = STRBUF_INIT;
 
        if (!p || !*p)
                return NULL;
 
        while (1) {
                const char *end = strchrnul(p, ':');
 
                strbuf_reset(&buf);
 
                /* POSIX specifies an empty entry as the current directory. */
                if (end != p) {
                        strbuf_add(&buf, p, end - p);
                        strbuf_addch(&buf, '/');
                }
                strbuf_addstr(&buf, file);
 
                if (!access(buf.buf, F_OK))
                        return strbuf_detach(&buf, NULL);
 
                if (!*end)
                        break;
                p = end + 1;
        }
        strbuf_release(&buf);
        return NULL;
}
J'ai donc la légère impression que le problème vient du PATH.
J'ai donc copié /usr/bin/env dans mon chroot.
J'ai ensuite fait :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
PATH="/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin"
export PATH
Path ayant ici la même valeur que le path d'en dehors de mon chroot.
Malheureusement, rien ne change.

Auriez-vous une idée ? Là je commence à sécher