git.c

   1 #include <stdio.h>
   2 #include <sys/types.h>
   3 #include <sys/stat.h>
   4 #include <dirent.h>
   5 #include <unistd.h>
   6 #include <stdlib.h>
   7 #include <string.h>
   8 #include <errno.h>
   9 #include <limits.h>
  10 #include <stdarg.h>
  11 #include <sys/ioctl.h>
  12 #include "git-compat-util.h"
  13 #include "exec_cmd.h"
  14
  15 #include "cache.h"
  16 #include "commit.h"
  17 #include "revision.h"
  18
  19 #ifndef PATH_MAX
  20 # define PATH_MAX 4096
  21 #endif
  22
  23 static const char git_usage[] =
  24         "Usage: git [--version] [--exec-path[=GIT_EXEC_PATH]] [--help] COMMAND [ ARGS ]";
  25
  26 /* most gui terms set COLUMNS (although some don't export it) */
  27 static int term_columns(void)
  28 {
  29         char *col_string = getenv("COLUMNS");
  30         int n_cols = 0;
  31
  32         if (col_string && (n_cols = atoi(col_string)) > 0)
  33                 return n_cols;
  34
  35 #ifdef TIOCGWINSZ
  36         {
  37                 struct winsize ws;
  38                 if (!ioctl(1, TIOCGWINSZ, &ws)) {
  39                         if (ws.ws_col)
  40                                 return ws.ws_col;
  41                 }
  42         }
  43 #endif
  44
  45         return 80;
  46 }
  47
  48 static void oom(void)
  49 {
  50         fprintf(stderr, "git: out of memory\n");
  51         exit(1);
  52 }
  53
  54 static inline void mput_char(char c, unsigned int num)
  55 {
  56         while(num--)
  57                 putchar(c);
  58 }
  59
  60 static struct cmdname {
  61         size_t len;
  62         char name[1];
  63 } **cmdname;
  64 static int cmdname_alloc, cmdname_cnt;
  65
  66 static void add_cmdname(const char *name, int len)
  67 {
  68         struct cmdname *ent;
  69         if (cmdname_alloc <= cmdname_cnt) {
  70                 cmdname_alloc = cmdname_alloc + 200;
  71                 cmdname = realloc(cmdname, cmdname_alloc * sizeof(*cmdname));
  72                 if (!cmdname)
  73                         oom();
  74         }
  75         ent = malloc(sizeof(*ent) + len);
  76         if (!ent)
  77                 oom();
  78         ent->len = len;
  79         memcpy(ent->name, name, len);
  80         ent->name[len] = 0;
  81         cmdname[cmdname_cnt++] = ent;
  82 }
  83
  84 static int cmdname_compare(const void *a_, const void *b_)
  85 {
  86         struct cmdname *a = *(struct cmdname **)a_;
  87         struct cmdname *b = *(struct cmdname **)b_;
  88         return strcmp(a->name, b->name);
  89 }
  90
  91 static void pretty_print_string_list(struct cmdname **cmdname, int longest)
  92 {
  93         int cols = 1, rows;
  94         int space = longest + 1; /* min 1 SP between words */
  95         int max_cols = term_columns() - 1; /* don't print *on* the edge */
  96         int i, j;
  97
  98         if (space < max_cols)
  99                 cols = max_cols / space;
 100         rows = (cmdname_cnt + cols - 1) / cols;
 101
 102         qsort(cmdname, cmdname_cnt, sizeof(*cmdname), cmdname_compare);
 103
 104         for (i = 0; i < rows; i++) {
 105                 printf("  ");
 106
 107                 for (j = 0; j < cols; j++) {
 108                         int n = j * rows + i;
 109                         int size = space;
 110                         if (n >= cmdname_cnt)
 111                                 break;
 112                         if (j == cols-1 || n + rows >= cmdname_cnt)
 113                                 size = 1;
 114                         printf("%-*s", size, cmdname[n]->name);
 115                 }
 116                 putchar('\n');
 117         }
 118 }
 119
 120 static void list_commands(const char *exec_path, const char *pattern)
 121 {
 122         unsigned int longest = 0;
 123         char path[PATH_MAX];
 124         int dirlen;
 125         DIR *dir = opendir(exec_path);
 126         struct dirent *de;
 127
 128         if (!dir) {
 129                 fprintf(stderr, "git: '%s': %s\n", exec_path, strerror(errno));
 130                 exit(1);
 131         }
 132
 133         dirlen = strlen(exec_path);
 134         if (PATH_MAX - 20 < dirlen) {
 135                 fprintf(stderr, "git: insanely long exec-path '%s'\n",
 136                         exec_path);
 137                 exit(1);
 138         }
 139
 140         memcpy(path, exec_path, dirlen);
 141         path[dirlen++] = '/';
 142
 143         while ((de = readdir(dir)) != NULL) {
 144                 struct stat st;
 145                 int entlen;
 146
 147                 if (strncmp(de->d_name, "git-", 4))
 148                         continue;
 149                 strcpy(path+dirlen, de->d_name);
 150                 if (stat(path, &st) || /* stat, not lstat */
 151                     !S_ISREG(st.st_mode) ||
 152                     !(st.st_mode & S_IXUSR))
 153                         continue;
 154
 155                 entlen = strlen(de->d_name);
 156                 if (4 < entlen && !strcmp(de->d_name + entlen - 4, ".exe"))
 157                         entlen -= 4;
 158
 159                 if (longest < entlen)
 160                         longest = entlen;
 161
 162                 add_cmdname(de->d_name + 4, entlen-4);
 163         }
 164         closedir(dir);
 165
 166         printf("git commands available in '%s'\n", exec_path);
 167         printf("----------------------------");
 168         mput_char('-', strlen(exec_path));
 169         putchar('\n');
 170         pretty_print_string_list(cmdname, longest - 4);
 171         putchar('\n');
 172 }
 173
 174 #ifdef __GNUC__
 175 static void cmd_usage(const char *exec_path, const char *fmt, ...)
 176         __attribute__((__format__(__printf__, 2, 3), __noreturn__));
 177 #endif
 178 static void cmd_usage(const char *exec_path, const char *fmt, ...)
 179 {
 180         if (fmt) {
 181                 va_list ap;
 182
 183                 va_start(ap, fmt);
 184                 printf("git: ");
 185                 vprintf(fmt, ap);
 186                 va_end(ap);
 187                 putchar('\n');
 188         }
 189         else
 190                 puts(git_usage);
 191
 192         putchar('\n');
 193
 194         if(exec_path)
 195                 list_commands(exec_path, "git-*");
 196
 197         exit(1);
 198 }
 199
 200 static void prepend_to_path(const char *dir, int len)
 201 {
 202         char *path, *old_path = getenv("PATH");
 203         int path_len = len;
 204
 205         if (!old_path)
 206                 old_path = "/usr/local/bin:/usr/bin:/bin";
 207
 208         path_len = len + strlen(old_path) + 1;
 209
 210         path = malloc(path_len + 1);
 211
 212         memcpy(path, dir, len);
 213         path[len] = ':';
 214         memcpy(path + len + 1, old_path, path_len - len);
 215
 216         setenv("PATH", path, 1);
 217 }
 218
 219 static void show_man_page(char *git_cmd)
 220 {
 221         char *page;
 222
 223         if (!strncmp(git_cmd, "git", 3))
 224                 page = git_cmd;
 225         else {
 226                 int page_len = strlen(git_cmd) + 4;
 227
 228                 page = malloc(page_len + 1);
 229                 strcpy(page, "git-");
 230                 strcpy(page + 4, git_cmd);
 231                 page[page_len] = 0;
 232         }
 233
 234         execlp("man", "man", page, NULL);
 235 }
 236
 237 static int cmd_version(int argc, char **argv, char **envp)
 238 {
 239         printf("git version %s\n", GIT_VERSION);
 240         return 0;
 241 }
 242
 243 static int cmd_help(int argc, char **argv, char **envp)
 244 {
 245         char *help_cmd = argv[1];
 246         if (!help_cmd)
 247                 cmd_usage(git_exec_path(), NULL);
 248         show_man_page(help_cmd);
 249         return 0;
 250 }
 251
 252 #define LOGSIZE (65536)
 253
 254 static int cmd_log(int argc, char **argv, char **envp)
 255 {
 256         struct rev_info rev;
 257         struct commit *commit;
 258         char *buf = xmalloc(LOGSIZE);
 259         static enum cmit_fmt commit_format = CMIT_FMT_DEFAULT;
 260         int abbrev = DEFAULT_ABBREV;
 261         int show_parents = 0;
 262         const char *commit_prefix = "commit ";
 263
 264         argc = setup_revisions(argc, argv, &rev, "HEAD");
 265         while (1 < argc) {
 266                 char *arg = argv[1];
 267                 /* accept -<digit>, like traditilnal "head" */
 268                 if ((*arg == '-') && isdigit(arg[1])) {
 269                         rev.max_count = atoi(arg + 1);
 270                 }
 271                 else if (!strcmp(arg, "-n")) {
 272                         if (argc < 2)
 273                                 die("-n requires an argument");
 274                         rev.max_count = atoi(argv[2]);
 275                         argc--; argv++;
 276                 }
 277                 else if (!strncmp(arg,"-n",2)) {
 278                         rev.max_count = atoi(arg + 2);
 279                 }
 280                 else if (!strncmp(arg, "--pretty", 8)) {
 281                         commit_format = get_commit_format(arg + 8);
 282                         if (commit_format == CMIT_FMT_ONELINE)
 283                                 commit_prefix = "";
 284                 }
 285                 else if (!strcmp(arg, "--parents")) {
 286                         show_parents = 1;
 287                 }
 288                 else if (!strcmp(arg, "--no-abbrev")) {
 289                         abbrev = 0;
 290                 }
 291                 else if (!strncmp(arg, "--abbrev=", 9)) {
 292                         abbrev = strtoul(arg + 9, NULL, 10);
 293                         if (abbrev && abbrev < MINIMUM_ABBREV)
 294                                 abbrev = MINIMUM_ABBREV;
 295                         else if (40 < abbrev)
 296                                 abbrev = 40;
 297                 }
 298                 else
 299                         die("unrecognized argument: %s", arg);
 300                 argc--; argv++;
 301         }
 302
 303         prepare_revision_walk(&rev);
 304         setup_pager();
 305         while ((commit = get_revision(&rev)) != NULL) {
 306                 printf("%s%s", commit_prefix,
 307                        sha1_to_hex(commit->object.sha1));
 308                 if (show_parents) {
 309                         struct commit_list *parents = commit->parents;
 310                         while (parents) {
 311                                 struct object *o = &(parents->item->object);
 312                                 parents = parents->next;
 313                                 if (o->flags & TMP_MARK)
 314                                         continue;
 315                                 printf(" %s", sha1_to_hex(o->sha1));
 316                                 o->flags |= TMP_MARK;
 317                         }
 318                         /* TMP_MARK is a general purpose flag that can
 319                          * be used locally, but the user should clean
 320                          * things up after it is done with them.
 321                          */
 322                         for (parents = commit->parents;
 323                              parents;
 324                              parents = parents->next)
 325                                 parents->item->object.flags &= ~TMP_MARK;
 326                 }
 327                 if (commit_format == CMIT_FMT_ONELINE)
 328                         putchar(' ');
 329                 else
 330                         putchar('\n');
 331                 pretty_print_commit(commit_format, commit, ~0, buf,
 332                                     LOGSIZE, abbrev);
 333                 printf("%s\n", buf);
 334         }
 335         free(buf);
 336         return 0;
 337 }
 338
 339 #define ARRAY_SIZE(x) (sizeof(x)/sizeof(x[0]))
 340
 341 static void handle_internal_command(int argc, char **argv, char **envp)
 342 {
 343         const char *cmd = argv[0];
 344         static struct cmd_struct {
 345                 const char *cmd;
 346                 int (*fn)(int, char **, char **);
 347         } commands[] = {
 348                 { "version", cmd_version },
 349                 { "help", cmd_help },
 350                 { "log", cmd_log },
 351         };
 352         int i;
 353
 354         for (i = 0; i < ARRAY_SIZE(commands); i++) {
 355                 struct cmd_struct *p = commands+i;
 356                 if (strcmp(p->cmd, cmd))
 357                         continue;
 358                 exit(p->fn(argc, argv, envp));
 359         }
 360 }
 361
 362 int main(int argc, char **argv, char **envp)
 363 {
 364         char *cmd = argv[0];
 365         char *slash = strrchr(cmd, '/');
 366         char git_command[PATH_MAX + 1];
 367         const char *exec_path = NULL;
 368
 369         /*
 370          * Take the basename of argv[0] as the command
 371          * name, and the dirname as the default exec_path
 372          * if it's an absolute path and we don't have
 373          * anything better.
 374          */
 375         if (slash) {
 376                 *slash++ = 0;
 377                 if (*cmd == '/')
 378                         exec_path = cmd;
 379                 cmd = slash;
 380         }
 381
 382         /*
 383          * "git-xxxx" is the same as "git xxxx", but we obviously:
 384          *
 385          *  - cannot take flags in between the "git" and the "xxxx".
 386          *  - cannot execute it externally (since it would just do
 387          *    the same thing over again)
 388          *
 389          * So we just directly call the internal command handler, and
 390          * die if that one cannot handle it.
 391          */
 392         if (!strncmp(cmd, "git-", 4)) {
 393                 cmd += 4;
 394                 argv[0] = cmd;
 395                 handle_internal_command(argc, argv, envp);
 396                 die("cannot handle %s internally", cmd);
 397         }
 398
 399         /* Default command: "help" */
 400         cmd = "help";
 401
 402         /* Look for flags.. */
 403         while (argc > 1) {
 404                 cmd = *++argv;
 405                 argc--;
 406
 407                 if (strncmp(cmd, "--", 2))
 408                         break;
 409
 410                 cmd += 2;
 411
 412                 /*
 413                  * For legacy reasons, the "version" and "help"
 414                  * commands can be written with "--" prepended
 415                  * to make them look like flags.
 416                  */
 417                 if (!strcmp(cmd, "help"))
 418                         break;
 419                 if (!strcmp(cmd, "version"))
 420                         break;
 421
 422                 /*
 423                  * Check remaining flags (which by now must be
 424                  * "--exec-path", but maybe we will accept
 425                  * other arguments some day)
 426                  */
 427                 if (!strncmp(cmd, "exec-path", 9)) {
 428                         cmd += 9;
 429                         if (*cmd == '=') {
 430                                 git_set_exec_path(cmd + 1);
 431                                 continue;
 432                         }
 433                         puts(git_exec_path());
 434                         exit(0);
 435                 }
 436                 cmd_usage(NULL, NULL);
 437         }
 438         argv[0] = cmd;
 439
 440         /*
 441          * We search for git commands in the following order:
 442          *  - git_exec_path()
 443          *  - the path of the "git" command if we could find it
 444          *    in $0
 445          *  - the regular PATH.
 446          */
 447         if (exec_path)
 448                 prepend_to_path(exec_path, strlen(exec_path));
 449         exec_path = git_exec_path();
 450         prepend_to_path(exec_path, strlen(exec_path));
 451
 452         /* See if it's an internal command */
 453         handle_internal_command(argc, argv, envp);
 454
 455         /* .. then try the external ones */
 456         execv_git_cmd(argv);
 457
 458         if (errno == ENOENT)
 459                 cmd_usage(exec_path, "'%s' is not a git-command", cmd);
 460
 461         fprintf(stderr, "Failed to run command '%s': %s\n",
 462                 git_command, strerror(errno));
 463
 464         return 1;
 465 }