undef/git-commit-vandalism
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

git wrapper: basic fixes.

Browse Source 
Updates to fix the nits found during the list discussion.

 - Lose PATH_TO_MAN; just rely on execlp() to find whereever the
   "man" command is installed.

 - Do not randomly chdir(), but concatenate to the current
   working directory only if the given path is not absolute.

 - Lose use of glob(); read from exec_path and do sorting
   ourselves -- it is not that much more work.

Signed-off-by: Junio C Hamano <junkio@cox.net>
This commit is contained in:
Junio C Hamano 2005-11-15 23:13:30 -08:00
parent ad4f4daae8
commit 7dbc2c0402
1 changed files with 97 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

152
git.c
View File

@ -1,11 +1,13 @@
#include <stdio.h> #include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <dirent.h>
#include <unistd.h> #include <unistd.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <errno.h> #include <errno.h>
#include <limits.h> #include <limits.h>
#include <stdarg.h> #include <stdarg.h>
#include <glob.h>
#ifndef PATH_MAX #ifndef PATH_MAX
# define PATH_MAX 4096 # define PATH_MAX 4096
@ -14,12 +16,6 @@
static const char git_usage[] = static const char git_usage[] =
"Usage: git [--version] [--exec-path[=GIT_EXEC_PATH]] [--help] COMMAND [ ARGS ]"; "Usage: git [--version] [--exec-path[=GIT_EXEC_PATH]] [--help] COMMAND [ ARGS ]";
struct string_list {
size_t len;
char *str;
struct string_list *next;
};
/* most gui terms set COLUMNS (although some don't export it) */ /* most gui terms set COLUMNS (although some don't export it) */
static int term_columns(void) static int term_columns(void)
{ {
@ -32,30 +28,69 @@ static int term_columns(void)
return 80; return 80;
} }
static void oom(void)
{
fprintf(stderr, "git: out of memory\n");
exit(1);
}
static inline void mput_char(char c, unsigned int num) static inline void mput_char(char c, unsigned int num)
{ {
while(num--) while(num--)
putchar(c); putchar(c);
} }
static void pretty_print_string_list(struct string_list *list, int longest) static struct cmdname {
size_t len;
char name[1];
} **cmdname;
static int cmdname_alloc, cmdname_cnt;
static void add_cmdname(const char *name, int len)
{
struct cmdname *ent;
if (cmdname_alloc <= cmdname_cnt) {
cmdname_alloc = cmdname_alloc + 200;
cmdname = realloc(cmdname, cmdname_alloc * sizeof(*cmdname));
if (!cmdname)
oom();
}
ent = malloc(sizeof(*ent) + len);
if (!ent)
oom();
ent->len = len;
memcpy(ent->name, name, len+1);
cmdname[cmdname_cnt++] = ent;
}
static int cmdname_compare(const void *a_, const void *b_)
{
struct cmdname *a = *(struct cmdname **)a_;
struct cmdname *b = *(struct cmdname **)b_;
return strcmp(a->name, b->name);
}
static void pretty_print_string_list(struct cmdname **cmdname, int longest)
{ {
int cols = 1; int cols = 1;
int space = longest + 1; /* min 1 SP between words */ int space = longest + 1; /* min 1 SP between words */
int max_cols = term_columns() - 1; /* don't print *on* the edge */ int max_cols = term_columns() - 1; /* don't print *on* the edge */
int i;
if (space < max_cols) if (space < max_cols)
cols = max_cols / space; cols = max_cols / space;
while (list) { qsort(cmdname, cmdname_cnt, sizeof(*cmdname), cmdname_compare);
for (i = 0; i < cmdname_cnt; ) {
int c; int c;
printf(" "); printf(" ");
for (c = cols; c && list; list = list->next) { for (c = cols; c && i < cmdname_cnt; i++) {
printf("%s", list->str); printf("%s", cmdname[i]->name);
if (--c) if (--c)
mput_char(' ', space - list->len); mput_char(' ', space - cmdname[i]->len);
} }
putchar('\n'); putchar('\n');
} }
@ -63,54 +98,53 @@ static void pretty_print_string_list(struct string_list *list, int longest)
static void list_commands(const char *exec_path, const char *pattern) static void list_commands(const char *exec_path, const char *pattern)
{ {
struct string_list *list = NULL, *tail = NULL; unsigned int longest = 0;
unsigned int longest = 0, i; char path[PATH_MAX];
glob_t gl; int dirlen;
DIR *dir = opendir(exec_path);
struct dirent *de;
if (chdir(exec_path) < 0) { if (!dir) {
printf("git: '%s': %s\n", exec_path, strerror(errno)); fprintf(stderr, "git: '%s': %s\n", exec_path, strerror(errno));
exit(1); exit(1);
} }
i = glob(pattern, 0, NULL, &gl); dirlen = strlen(exec_path);
switch(i) { if (PATH_MAX - 20 < dirlen) {
case GLOB_NOSPACE: fprintf(stderr, "git: insanely long exec-path '%s'\n",
puts("Out of memory when running glob()"); exec_path);
exit(2);
case GLOB_ABORTED:
printf("'%s': Read error: %s\n", exec_path, strerror(errno));
exit(2);
case GLOB_NOMATCH:
printf("No git commands available in '%s'.\n", exec_path);
printf("Do you need to specify --exec-path or set GIT_EXEC_PATH?\n");
exit(1); exit(1);
} }
for (i = 0; i < gl.gl_pathc; i++) { memcpy(path, exec_path, dirlen);
int len = strlen(gl.gl_pathv[i] + 4); path[dirlen++] = '/';
if (access(gl.gl_pathv[i], X_OK)) while ((de = readdir(dir)) != NULL) {
struct stat st;
int entlen;
if (strncmp(de->d_name, "git-", 4))
continue;
strcpy(path+dirlen, de->d_name);
if (stat(path, &st) || /* stat, not lstat */
!S_ISREG(st.st_mode) ||
!(st.st_mode & S_IXUSR))
continue; continue;
if (longest < len) entlen = strlen(de->d_name);
longest = len;
if (!tail) if (longest < entlen)
tail = list = malloc(sizeof(struct string_list)); longest = entlen;
else {
tail->next = malloc(sizeof(struct string_list)); add_cmdname(de->d_name + 4, entlen-4);
tail = tail->next;
}
tail->len = len;
tail->str = gl.gl_pathv[i] + 4;
tail->next = NULL;
} }
closedir(dir);
printf("git commands available in '%s'\n", exec_path); printf("git commands available in '%s'\n", exec_path);
printf("----------------------------"); printf("----------------------------");
mput_char('-', strlen(exec_path)); mput_char('-', strlen(exec_path));
putchar('\n'); putchar('\n');
pretty_print_string_list(list, longest); pretty_print_string_list(cmdname, longest - 4);
putchar('\n'); putchar('\n');
} }
@ -146,7 +180,7 @@ static void prepend_to_path(const char *dir, int len)
int path_len = len; int path_len = len;
if (!old_path) if (!old_path)
old_path = "/bin:/usr/bin:."; old_path = "/usr/local/bin:/usr/bin:/bin";
path_len = len + strlen(old_path) + 1; path_len = len + strlen(old_path) + 1;
@ -160,8 +194,6 @@ static void prepend_to_path(const char *dir, int len)
setenv("PATH", path, 1); setenv("PATH", path, 1);
} }
/* has anyone seen 'man' installed anywhere else than in /usr/bin? */
#define PATH_TO_MAN "/usr/bin/man"
static void show_man_page(char *git_cmd) static void show_man_page(char *git_cmd)
{ {
char *page; char *page;
@ -177,7 +209,7 @@ static void show_man_page(char *git_cmd)
page[page_len] = 0; page[page_len] = 0;
} }
execlp(PATH_TO_MAN, "man", page, NULL); execlp("man", "man", page, NULL);
} }
int main(int argc, char **argv, char **envp) int main(int argc, char **argv, char **envp)
@ -226,15 +258,25 @@ int main(int argc, char **argv, char **envp)
show_man_page(argv[i]); show_man_page(argv[i]);
} }
/* allow relative paths, but run with exact */ if (*exec_path != '/') {
if (chdir(exec_path)) { if (!getcwd(git_command, sizeof(git_command))) {
printf("git: '%s': %s\n", exec_path, strerror(errno)); fprintf(stderr,
exit (1); "git: cannot determine current directory");
exit(1);
}
len = strlen(git_command);
/* Trivial cleanup */
while (!strncmp(exec_path, "./", 2)) {
exec_path += 2;
while (*exec_path == '/')
*exec_path++;
}
snprintf(git_command + len, sizeof(git_command) - len,
"/%s", exec_path);
} }
else
getcwd(git_command, sizeof(git_command)); strcpy(git_command, exec_path);
chdir(wd);
len = strlen(git_command); len = strlen(git_command);
prepend_to_path(git_command, len); prepend_to_path(git_command, len);