ext/gitdll/gitdll.c

   1 // TortoiseGit - a Windows shell extension for easy version control
   2
   3 // Copyright (C) 2008-2016 - TortoiseGit
   4
   5 // This program is free software; you can redistribute it and/or
   6 // modify it under the terms of the GNU General Public License
   7 // as published by the Free Software Foundation; either version 2
   8 // of the License, or (at your option) any later version.
   9
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software Foundation,
  17 // 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 //
  19 // gitdll.cpp : Defines the exported functions for the DLL application.
  20 //
  21
  22 #include "stdafx.h"
  23 #include "../build/libgit-defines.h"
  24 #pragma warning(push)
  25 #pragma warning(disable: 4100 4018 4127 4244 4267)
  26 #include "git-compat-util.h"
  27 #include "gitdll.h"
  28 #include "cache.h"
  29 #include "commit.h"
  30 #include "diff.h"
  31 #include "revision.h"
  32 #include "diffcore.h"
  33 #include "dir.h"
  34 #include "builtin.h"
  35 #include "exec_cmd.h"
  36 #include "cache.h"
  37 #include "quote.h"
  38 #include "run-command.h"
  39 #include "mailmap.h"
  40 #pragma warning(pop)
  41
  42 extern char g_last_error[];
  43 const char * g_prefix;
  44
  45 extern void die_dll(const char *err, va_list params);
  46 extern void handle_error(const char* err, va_list params);
  47 extern void handle_warning(const char* warn, va_list params);
  48 extern int die_is_recursing_dll(void);
  49
  50 extern void free_all_pack();
  51 extern void reset_git_env();
  52 extern void drop_attr_stack();
  53 extern void git_atexit_dispatch();
  54 extern void git_atexit_clear();
  55 extern void invalidate_ref_cache(const char* submodule);
  56 extern void cmd_log_init(int argc, const char** argv, const char* prefix, struct rev_info* rev, struct setup_revision_opt* opt);
  57 extern int estimate_commit_count(struct rev_info* rev, struct commit_list* list);
  58 extern int log_tree_commit(struct rev_info*, struct commit*);
  59 extern int write_entry(struct cache_entry* ce, char* path, const struct checkout* state, int to_tempfile);
  60 extern struct object* deref_tag(struct object* o, const char* warn, int warnlen);
  61 extern void diff_flush_stat(struct diff_filepair* p, struct diff_options* o, struct diffstat_t* diffstat);
  62 extern void free_diffstat_info(struct diffstat_t* diffstat);
  63 extern int for_each_reflog_ent(const char* refname, each_reflog_ent_fn fn, void* cb_data);
  64 extern int for_each_ref_in(const char* prefix, each_ref_fn fn, void* cb_data);
  65
  66 void dll_entry()
  67 {
  68         set_die_routine(die_dll);
  69         set_error_routine(handle_error);
  70         set_warn_routine(handle_warning);
  71         set_die_is_recursing_routine(die_is_recursing_dll);
  72 }
  73
  74 int git_get_sha1(const char *name, GIT_HASH sha1)
  75 {
  76         return get_sha1(name,sha1);
  77 }
  78
  79 static int convert_slash(char * path)
  80 {
  81         while(*path)
  82         {
  83                 if(*path == '\\' )
  84                         *path = '/';
  85                 path++;
  86         }
  87         return 0;
  88 }
  89
  90 int git_init()
  91 {
  92         char path[MAX_PATH+1];
  93
  94         _fmode = _O_BINARY;
  95         _setmode(_fileno(stdin), _O_BINARY);
  96         _setmode(_fileno(stdout), _O_BINARY);
  97         _setmode(_fileno(stderr), _O_BINARY);
  98
  99         GetModuleFileName(NULL, path, MAX_PATH);
 100         convert_slash(path);
 101
 102         git_extract_argv0_path(path);
 103         reset_git_env();
 104         // set HOME if not set already
 105         gitsetenv("HOME", get_windows_home_directory(), 0);
 106         drop_attr_stack();
 107         g_prefix = setup_git_directory();
 108         git_config(git_default_config, NULL);
 109
 110         return 0;
 111 }
 112
 113 static int git_parse_commit_author(struct GIT_COMMIT_AUTHOR* author, const char* pbuff)
 114 {
 115         const char* end;
 116
 117         author->Name=pbuff;
 118         end=strchr(pbuff,'<');
 119         if( end == 0)
 120         {
 121                 return -1;
 122         }
 123         author->NameSize = (int)(end - pbuff - 1);
 124
 125         pbuff = end +1;
 126         end = strchr(pbuff, '>');
 127         if( end == 0)
 128                 return -1;
 129
 130         author->Email = pbuff ;
 131         author->EmailSize = (int)(end - pbuff);
 132
 133         pbuff = end + 2;
 134
 135         author->Date = atol(pbuff);
 136         end =  strchr(pbuff, ' ');
 137         if( end == 0 )
 138                 return -1;
 139
 140         pbuff=end;
 141         author->TimeZone = atol(pbuff);
 142
 143         return 0;
 144 }
 145
 146 int git_parse_commit(GIT_COMMIT *commit)
 147 {
 148         int ret = 0;
 149         const char* pbuf;
 150         const char* end;
 151         struct commit *p;
 152
 153         p= (struct commit *)commit->m_pGitCommit;
 154
 155         memcpy(commit->m_hash, p->object.oid.hash, GIT_HASH_SIZE);
 156
 157         commit->m_Encode = NULL;
 158         commit->m_EncodeSize = 0;
 159
 160         commit->buffer = detach_commit_buffer(commit->m_pGitCommit, NULL);
 161
 162         pbuf = commit->buffer;
 163         while(pbuf)
 164         {
 165                 if (strncmp(pbuf, "author", 6) == 0)
 166                 {
 167                         ret = git_parse_commit_author(&commit->m_Author,pbuf + 7);
 168                         if(ret)
 169                                 return -4;
 170                 }
 171                 else if (strncmp(pbuf, "committer", 9) == 0)
 172                 {
 173                         ret =  git_parse_commit_author(&commit->m_Committer,pbuf + 10);
 174                         if(ret)
 175                                 return -5;
 176
 177                         pbuf = strchr(pbuf,'\n');
 178                         if(pbuf == NULL)
 179                                 return -6;
 180                 }
 181                 else if (strncmp(pbuf, "encoding", 8) == 0)
 182                 {
 183                         pbuf += 9;
 184                         commit->m_Encode=pbuf;
 185                         end = strchr(pbuf,'\n');
 186                         commit->m_EncodeSize= (int)(end -pbuf);
 187                 }
 188
 189                 // the headers end after the first empty line
 190                 else if (*pbuf == '\n')
 191                 {
 192                         pbuf++;
 193
 194                         commit->m_Subject=pbuf;
 195                         end = strchr(pbuf,'\n');
 196                         if( end == 0)
 197                                 commit->m_SubjectSize = (int)strlen(pbuf);
 198                         else
 199                         {
 200                                 commit->m_SubjectSize = (int)(end - pbuf);
 201                                 pbuf = end +1;
 202                                 commit->m_Body = pbuf;
 203                                 commit->m_BodySize = (int)strlen(pbuf);
 204                                 return 0;
 205                         }
 206                 }
 207
 208                 pbuf = strchr(pbuf,'\n');
 209                 if(pbuf)
 210                         pbuf ++;
 211         }
 212         return 0;
 213 }
 214
 215 int git_get_commit_from_hash(GIT_COMMIT* commit, const GIT_HASH hash)
 216 {
 217         int ret = 0;
 218
 219         struct commit *p;
 220
 221         if (commit == NULL)
 222                 return -1;
 223
 224         memset(commit,0,sizeof(GIT_COMMIT));
 225
 226         commit->m_pGitCommit = p = lookup_commit(hash);
 227
 228         if(p == NULL)
 229                 return -1;
 230
 231         ret = parse_commit(p);
 232         if( ret )
 233                 return ret;
 234
 235         return git_parse_commit(commit);
 236 }
 237
 238 int git_get_commit_first_parent(GIT_COMMIT *commit,GIT_COMMIT_LIST *list)
 239 {
 240         struct commit *p = commit->m_pGitCommit;
 241
 242         if(list == NULL)
 243                 return -1;
 244
 245         *list = (GIT_COMMIT_LIST*)p->parents;
 246         return 0;
 247 }
 248 int git_get_commit_next_parent(GIT_COMMIT_LIST *list, GIT_HASH hash)
 249 {
 250         struct commit_list *l;
 251         if (list == NULL)
 252                 return -1;
 253
 254         l = *(struct commit_list **)list;
 255         if (l == NULL)
 256                 return -1;
 257
 258         if(hash)
 259                 memcpy(hash, l->item->object.oid.hash, GIT_HASH_SIZE);
 260
 261         *list = (GIT_COMMIT_LIST *)l->next;
 262         return 0;
 263
 264 }
 265
 266
 267 int git_free_commit(GIT_COMMIT *commit)
 268 {
 269         struct commit *p = commit->m_pGitCommit;
 270
 271         if( p->parents)
 272                 free_commit_list(p->parents);
 273
 274         if (p->tree)
 275                 free_tree_buffer(p->tree);
 276
 277 #pragma warning(push)
 278 #pragma warning(disable: 4090)
 279         if (commit->buffer)
 280                 free(commit->buffer);
 281 #pragma warning(pop)
 282
 283         p->object.parsed = 0;
 284         p->parents = 0;
 285         p->tree = 0;
 286
 287         memset(commit,0,sizeof(GIT_COMMIT));
 288         return 0;
 289 }
 290
 291 char **strtoargv(char *arg, int *size)
 292 {
 293         int count=0;
 294         char *p=arg;
 295         char **argv;
 296
 297         int i=0;
 298         while(*p)
 299         {
 300                 if(*p == '\\')
 301                         *p='/';
 302                 p++;
 303         }
 304         p=arg;
 305
 306         while(*p)
 307         {
 308                 if(*p == ' ')
 309                         count ++;
 310                 p++;
 311         }
 312
 313         argv=malloc(strlen(arg)+1 + (count +2)*sizeof(void*));
 314         p=(char*)(argv+count+2);
 315
 316         while(*arg)
 317         {
 318                 if(*arg != ' ')
 319                 {
 320                         char space=' ';
 321                         argv[i]=p;
 322
 323                         while(*arg)
 324                         {
 325                                 if(*arg == '"')
 326                                 {
 327                                         arg++;
 328                                         if(space == ' ')
 329                                                 space = '"';
 330                                         else
 331                                                 space = ' ';
 332                                 }
 333                                 if((*arg == space) || (*arg == 0))
 334                                         break;
 335
 336                                 *p++ = *arg++;
 337                         }
 338                         i++;
 339                         *p++=0;
 340                 }
 341                 if(*arg == 0)
 342                         break;
 343                 arg++;
 344         }
 345         argv[i]=NULL;
 346         *size = i;
 347         return argv;
 348 }
 349 int git_open_log(GIT_LOG * handle, char * arg)
 350 {
 351         struct rev_info *p_Rev;
 352         char ** argv=0;
 353         int argc=0;
 354         unsigned int i=0;
 355         struct setup_revision_opt opt;
 356
 357         /* clear flags */
 358         unsigned int obj_size = get_max_object_index();
 359         for(i =0; i<obj_size; i++)
 360         {
 361                 struct object *ob= get_indexed_object(i);
 362                 if(ob)
 363                 {
 364                         ob->flags=0;
 365                         if (ob->parsed && ob->type == OBJ_COMMIT)
 366                         {
 367                                 struct commit* commit = (struct commit*)ob;
 368                                 free_commit_list(commit->parents);
 369                                 commit->parents = NULL;
 370                                 if (commit->tree)
 371                                         free_tree_buffer(commit->tree);
 372                                 commit->tree = NULL;
 373                                 ob->parsed = 0;
 374                         }
 375                 }
 376         }
 377
 378         if(arg != NULL)
 379                 argv = strtoargv(arg,&argc);
 380
 381         if (!argv)
 382                 return -1;
 383
 384         p_Rev = malloc(sizeof(struct rev_info));
 385         if (p_Rev == NULL)
 386         {
 387                 free(argv);
 388                 return -1;
 389         }
 390
 391         memset(p_Rev,0,sizeof(struct rev_info));
 392
 393         invalidate_ref_cache(NULL);
 394
 395         init_revisions(p_Rev, g_prefix);
 396         p_Rev->diff = 1;
 397
 398         memset(&opt, 0, sizeof(opt));
 399         opt.def = "HEAD";
 400
 401         cmd_log_init(argc, argv, g_prefix,p_Rev,&opt);
 402
 403         p_Rev->pPrivate = argv;
 404         *handle = p_Rev;
 405         return 0;
 406
 407 }
 408 int git_get_log_firstcommit(GIT_LOG handle)
 409 {
 410         return prepare_revision_walk(handle);
 411 }
 412
 413 int git_get_log_estimate_commit_count(GIT_LOG handle)
 414 {
 415         struct rev_info *p_Rev;
 416         p_Rev=(struct rev_info *)handle;
 417
 418         return estimate_commit_count(p_Rev, p_Rev->commits);
 419 }
 420
 421 int git_get_log_nextcommit(GIT_LOG handle, GIT_COMMIT *commit, int follow)
 422 {
 423         int ret =0;
 424
 425         if(commit == NULL)
 426                 return -1;
 427
 428         memset(commit, 0, sizeof(GIT_COMMIT));
 429
 430         commit->m_pGitCommit = get_revision(handle);
 431         if( commit->m_pGitCommit == NULL)
 432                 return -2;
 433
 434         if (follow && !log_tree_commit(handle, commit->m_pGitCommit))
 435         {
 436                 commit->m_ignore = 1;
 437                 return 0;
 438         }
 439         commit->m_ignore = 0;
 440
 441         ret=git_parse_commit(commit);
 442         if(ret)
 443                 return ret;
 444
 445         return 0;
 446 }
 447
 448 struct notes_tree **display_notes_trees;
 449 int git_close_log(GIT_LOG handle)
 450 {
 451         if(handle)
 452         {
 453                 struct rev_info *p_Rev;
 454                 p_Rev=(struct rev_info *)handle;
 455                 if(p_Rev->pPrivate)
 456                         free(p_Rev->pPrivate);
 457                 free(handle);
 458         }
 459         free_all_pack();
 460
 461         if (display_notes_trees)
 462                 free_notes(*display_notes_trees);
 463         display_notes_trees = 0;
 464         return 0;
 465 }
 466
 467 int git_open_diff(GIT_DIFF *diff, char * arg)
 468 {
 469         struct rev_info *p_Rev;
 470         char ** argv=0;
 471         int argc=0;
 472
 473         if(arg != NULL)
 474                 argv = strtoargv(arg,&argc);
 475
 476         p_Rev = malloc(sizeof(struct rev_info));
 477         memset(p_Rev,0,sizeof(struct rev_info));
 478
 479         p_Rev->pPrivate = argv;
 480         *diff = (GIT_DIFF)p_Rev;
 481
 482         init_revisions(p_Rev, g_prefix);
 483         git_config(git_diff_basic_config, NULL); /* no "diff" UI options */
 484         p_Rev->abbrev = 0;
 485         p_Rev->diff = 1;
 486         argc = setup_revisions(argc, argv, p_Rev, NULL);
 487
 488         return 0;
 489 }
 490 int git_close_diff(GIT_DIFF handle)
 491 {
 492         git_diff_flush(handle);
 493         if(handle)
 494         {
 495                 struct rev_info *p_Rev;
 496                 p_Rev=(struct rev_info *)handle;
 497                 if(p_Rev->pPrivate)
 498                         free(p_Rev->pPrivate);
 499                 free(handle);
 500         }
 501         return 0;
 502 }
 503 int git_diff_flush(GIT_DIFF diff)
 504 {
 505         struct diff_queue_struct *q = &diff_queued_diff;
 506         struct rev_info *p_Rev;
 507         int i;
 508         p_Rev = (struct rev_info *)diff;
 509
 510         if(q->nr == 0)
 511                 return 0;
 512
 513         for (i = 0; i < q->nr; i++)
 514                 diff_free_filepair(q->queue[i]);
 515
 516         if(q->queue)
 517         {
 518                 free(q->queue);
 519                 q->queue = NULL;
 520                 q->nr = q->alloc = 0;
 521         }
 522
 523         if (p_Rev->diffopt.close_file)
 524                 fclose(p_Rev->diffopt.file);
 525
 526         free_diffstat_info(&p_Rev->diffstat);
 527         return 0;
 528 }
 529
 530 int git_root_diff(GIT_DIFF diff, GIT_HASH hash,GIT_FILE *file, int *count, int isstat)
 531 {
 532         int ret;
 533         struct rev_info *p_Rev;
 534         int i;
 535         struct diff_queue_struct *q = &diff_queued_diff;
 536
 537         p_Rev = (struct rev_info *)diff;
 538
 539         ret=diff_root_tree_sha1(hash, "", &p_Rev->diffopt);
 540
 541         if(ret)
 542                 return ret;
 543
 544         if(isstat)
 545         {
 546                 diffcore_std(&p_Rev->diffopt);
 547
 548                 memset(&p_Rev->diffstat, 0, sizeof(struct diffstat_t));
 549                 for (i = 0; i < q->nr; i++) {
 550                         struct diff_filepair *p = q->queue[i];
 551                         //if (check_pair_status(p))
 552                         diff_flush_stat(p, &p_Rev->diffopt, &p_Rev->diffstat);
 553                 }
 554
 555                 if(file)
 556                         *file = q;
 557                 if(count)
 558                         *count = q->nr;
 559         }
 560         return 0;
 561 }
 562
 563 int git_do_diff(GIT_DIFF diff, GIT_HASH hash1, GIT_HASH hash2, GIT_FILE * file, int *count,int isstat)
 564 {
 565         struct rev_info *p_Rev;
 566         int ret;
 567         int i;
 568         struct diff_queue_struct *q = &diff_queued_diff;
 569
 570         p_Rev = (struct rev_info *)diff;
 571
 572         ret = diff_tree_sha1(hash1,hash2,"",&p_Rev->diffopt);
 573         if( ret )
 574         {
 575                 free_all_pack();
 576                 return ret;
 577         }
 578
 579         if(isstat)
 580         {
 581                 diffcore_std(&p_Rev->diffopt);
 582                 memset(&p_Rev->diffstat, 0, sizeof(struct diffstat_t));
 583                 for (i = 0; i < q->nr; i++) {
 584                         struct diff_filepair *p = q->queue[i];
 585                         //if (check_pair_status(p))
 586                         diff_flush_stat(p, &p_Rev->diffopt, &p_Rev->diffstat);
 587                 }
 588         }
 589         free_all_pack();
 590         if(file)
 591                 *file = q;
 592         if(count)
 593                 *count = q->nr;
 594         return 0;
 595 }
 596
 597 int git_get_diff_file(GIT_DIFF diff,GIT_FILE file,int i, char **newname, char ** oldname,  int *status, int *IsBin, int *inc, int *dec)
 598 {
 599         struct diff_queue_struct *q = &diff_queued_diff;
 600         struct rev_info *p_Rev;
 601         p_Rev = (struct rev_info *)diff;
 602
 603         q = (struct diff_queue_struct *)file;
 604         if(file == 0)
 605                 return -1;
 606         if(i>=q->nr)
 607                 return -1;
 608
 609         assert(newname && oldname && status);
 610
 611         *newname = q->queue[i]->two->path;
 612         *oldname = q->queue[i]->one->path;
 613         *status = q->queue[i]->status;
 614
 615         if(p_Rev->diffstat.files)
 616         {
 617                 int j;
 618                 for(j=0;j<p_Rev->diffstat.nr;j++)
 619                 {
 620                         if(strcmp(*newname,p_Rev->diffstat.files[j]->name)==0)
 621                                 break;
 622                 }
 623                 if( j== p_Rev->diffstat.nr)
 624                 {
 625                         *IsBin=1;
 626                         *inc=0;
 627                         *dec=0;
 628                         return 0;
 629                 }
 630                 if(IsBin)
 631                         *IsBin = p_Rev->diffstat.files[j]->is_binary;
 632                 if(inc)
 633                         *inc = (int)p_Rev->diffstat.files[j]->added;
 634                 if(dec)
 635                         *dec = (int)p_Rev->diffstat.files[j]->deleted;
 636         }else
 637         {
 638                 *IsBin=1;
 639                 *inc=0;
 640                 *dec=0;
 641         }
 642
 643         return 0;
 644 }
 645
 646 int git_read_tree(GIT_HASH hash,read_tree_fn_t fn, void *context)
 647 {
 648         struct tree * root;
 649         int ret;
 650         reprepare_packed_git();
 651         root = parse_tree_indirect(hash);
 652
 653         if (!root)
 654         {
 655                 free_all_pack();
 656                 return -1;
 657         }
 658         ret = read_tree_recursive(root, NULL, 0, 0, NULL, fn, context);
 659         free_all_pack();
 660         return ret;
 661 }
 662
 663 int git_add_exclude(const char *string, const char *base,
 664                                         int baselen, struct exclude_list *which, int lineno)
 665 {
 666         add_exclude(string, base, baselen, which, lineno);
 667         return 0;
 668 }
 669
 670 int git_create_exclude_list(EXCLUDE_LIST *which)
 671 {
 672         *which = malloc(sizeof(struct exclude_list));
 673         memset(*which,0,sizeof(struct exclude_list));
 674         return 0;
 675 }
 676
 677 int git_free_exclude_list(EXCLUDE_LIST which)
 678 {
 679         int i=0;
 680         struct exclude_list *p = (struct exclude_list *) which;
 681
 682         for(i=0; i<p->nr;i++)
 683         {
 684                 free(p->excludes[i]);
 685         }
 686         free(p->excludes);
 687         free(p);
 688         return 0;
 689 }
 690
 691 int git_check_excluded_1(const char *pathname,
 692                                                         int pathlen, const char *basename, int *dtype,
 693                                                         EXCLUDE_LIST el)
 694 {
 695         return is_excluded_from_list(pathname, pathlen, basename, dtype, el);
 696 }
 697
 698 int git_get_notes(GIT_HASH hash, char **p_note)
 699 {
 700         struct strbuf sb;
 701         size_t size;
 702         strbuf_init(&sb,0);
 703         format_display_notes(hash, &sb, "utf-8", 1);
 704         *p_note = strbuf_detach(&sb,&size);
 705
 706         return 0;
 707 }
 708
 709 struct cmd_struct {
 710         const char *cmd;
 711         int (*fn)(int, const char **, const char *);
 712         int option;
 713 };
 714
 715 #define RUN_SETUP       (1<<0)
 716
 717 static struct cmd_struct commands[] = {
 718                 { "notes", cmd_notes, RUN_SETUP },
 719                 { "update-index", cmd_update_index, RUN_SETUP },
 720         };
 721
 722 int git_run_cmd(char *cmd, char *arg)
 723 {
 724
 725         int i=0;
 726         char ** argv=0;
 727         int argc=0;
 728
 729         git_init();
 730
 731         for(i=0;i<      sizeof(commands) / sizeof(struct cmd_struct);i++)
 732         {
 733                 if(strcmp(cmd,commands[i].cmd)==0)
 734                 {
 735                         int ret;
 736                         if(arg != NULL)
 737                                 argv = strtoargv(arg,&argc);
 738
 739                         ret = commands[i].fn(argc, argv, NULL);
 740
 741                         if(argv)
 742                                 free(argv);
 743
 744                         discard_cache();
 745                         free_all_pack();
 746
 747                         return ret;
 748
 749
 750                 }
 751         }
 752         return -1;
 753 }
 754
 755 void git_exit_cleanup(void)
 756 {
 757         git_atexit_dispatch();
 758         git_atexit_clear();
 759 }
 760
 761 int git_for_each_reflog_ent(const char *ref, each_reflog_ent_fn fn, void *cb_data)
 762 {
 763         return for_each_reflog_ent(ref,fn,cb_data);
 764 }
 765
 766 static int update_some(const unsigned char* sha1, struct strbuf* base,
 767                 const char *pathname, unsigned mode, int stage, void *context)
 768 {
 769         struct cache_entry *ce;
 770         UNREFERENCED_PARAMETER(stage);
 771
 772         ce = (struct cache_entry *)context;
 773
 774         if (S_ISDIR(mode))
 775                 return READ_TREE_RECURSIVE;
 776
 777         hashcpy(ce->sha1, sha1);
 778         memcpy(ce->name, base->buf, base->len);
 779         memcpy(ce->name + base->len, pathname, strlen(pathname));
 780         ce->ce_flags = create_ce_flags((unsigned int)(strlen(pathname) + base->len));
 781         ce->ce_mode = create_ce_mode(mode);
 782
 783         return 0;
 784 }
 785
 786 int git_checkout_file(const char* ref, const char* path, char* outputpath)
 787 {
 788         struct cache_entry *ce;
 789         int ret;
 790         GIT_HASH sha1;
 791         struct tree * root;
 792         struct checkout state;
 793         struct pathspec pathspec;
 794         const char *matchbuf[1];
 795         ret = get_sha1(ref, sha1);
 796         if(ret)
 797                 return ret;
 798
 799         reprepare_packed_git();
 800         root = parse_tree_indirect(sha1);
 801
 802         if(!root)
 803         {
 804                 free_all_pack();
 805                 return -1;
 806         }
 807
 808         ce = xcalloc(1, cache_entry_size(strlen(path)));
 809
 810         matchbuf[0] = NULL;
 811         parse_pathspec(&pathspec, PATHSPEC_ALL_MAGIC, PATHSPEC_PREFER_CWD, path, matchbuf);
 812         pathspec.items[0].nowildcard_len = pathspec.items[0].len;
 813         ret = read_tree_recursive(root, "", 0, 0, &pathspec, update_some, ce);
 814         free_pathspec(&pathspec);
 815
 816         if(ret)
 817         {
 818                 free_all_pack();
 819                 free(ce);
 820                 return ret;
 821         }
 822         memset(&state, 0, sizeof(state));
 823         state.force = 1;
 824         state.refresh_cache = 0;
 825
 826         ret = write_entry(ce, outputpath, &state, 0);
 827         free_all_pack();
 828         free(ce);
 829         return ret;
 830 }
 831 struct config_buf
 832 {
 833         char *buf;
 834         const char *key;
 835         size_t size;
 836         int seen;
 837 };
 838
 839 static int get_config(const char *key_, const char *value_, void *cb)
 840 {
 841         struct config_buf *buf;
 842         buf=(struct config_buf*)cb;
 843         if(strcmp(key_, buf->key))
 844                 return 0;
 845
 846         if (value_)
 847                 strncpy(buf->buf,value_,buf->size);
 848         else
 849         {
 850                 buf->buf[0] = 't';
 851                 buf->buf[1] = 'r';
 852                 buf->buf[2] = 'u';
 853                 buf->buf[3] = 'e';
 854                 buf->buf[4] = 0;
 855         }
 856         buf->seen = 1;
 857         return 0;
 858
 859 }
 860
 861 // wchar_t wrapper for program_data_config()
 862 const wchar_t* wget_program_data_config(void)
 863 {
 864         static const wchar_t *programdata_git_config = NULL;
 865         wchar_t wpointer[MAX_PATH];
 866
 867         if (programdata_git_config)
 868                 return programdata_git_config;
 869
 870         if (xutftowcs_path(wpointer, program_data_config()) < 0)
 871                 return NULL;
 872
 873         programdata_git_config = _wcsdup(wpointer);
 874
 875         return programdata_git_config;
 876 }
 877
 878 // wchar_t wrapper for git_etc_gitconfig()
 879 const wchar_t *wget_msysgit_etc(void)
 880 {
 881         static const wchar_t *etc_gitconfig = NULL;
 882         wchar_t wpointer[MAX_PATH];
 883
 884         if (etc_gitconfig)
 885                 return etc_gitconfig;
 886
 887         if (xutftowcs_path(wpointer, git_etc_gitconfig()) < 0)
 888                 return NULL;
 889
 890         etc_gitconfig = _wcsdup(wpointer);
 891
 892         return etc_gitconfig;
 893 }
 894
 895 int git_get_config(const char *key, char *buffer, int size)
 896 {
 897         char *local, *global, *globalxdg;
 898         const char *home, *system, *programdata;
 899         struct config_buf buf;
 900         struct git_config_source config_source = { 0 };
 901
 902         buf.buf=buffer;
 903         buf.size=size;
 904         buf.seen = 0;
 905         buf.key = key;
 906
 907         home = get_windows_home_directory();
 908         if (home)
 909         {
 910                 global = xstrdup(mkpath("%s/.gitconfig", home));
 911                 globalxdg = xstrdup(mkpath("%s/.config/git/config", home));
 912         }
 913         else
 914         {
 915                 global = NULL;
 916                 globalxdg = NULL;
 917         }
 918
 919         system = git_etc_gitconfig();
 920         programdata = git_program_data_config();
 921
 922         local = git_pathdup("config");
 923
 924         if (!buf.seen)
 925         {
 926                 config_source.file = local;
 927                 git_config_with_options(get_config, &buf, &config_source, 1);
 928         }
 929         if (!buf.seen && global)
 930         {
 931                 config_source.file = global;
 932                 git_config_with_options(get_config, &buf, &config_source, 1);
 933         }
 934         if (!buf.seen && globalxdg)
 935         {
 936                 config_source.file = globalxdg;
 937                 git_config_with_options(get_config, &buf, &config_source, 1);
 938         }
 939         if (!buf.seen && system)
 940         {
 941                 config_source.file = system;
 942                 git_config_with_options(get_config, &buf, &config_source, 1);
 943         }
 944         if (!buf.seen && programdata)
 945         {
 946                 config_source.file = programdata;
 947                 git_config_with_options(get_config, &buf, &config_source, 1);
 948         }
 949
 950         if(local)
 951                 free(local);
 952         if(global)
 953                 free(global);
 954         if (globalxdg)
 955                 free(globalxdg);
 956
 957         return !buf.seen;
 958 }
 959
 960 // taken from msysgit: compat/mingw.c
 961 const char *get_windows_home_directory(void)
 962 {
 963         static const char *home_directory = NULL;
 964         struct strbuf buf = STRBUF_INIT;
 965
 966         if (home_directory)
 967                 return home_directory;
 968
 969         home_directory = getenv("HOME");
 970         if (home_directory && *home_directory)
 971                 return home_directory;
 972
 973         strbuf_addf(&buf, "%s%s", getenv("HOMEDRIVE"), getenv("HOMEPATH"));
 974         home_directory = strbuf_detach(&buf, NULL);
 975
 976         return home_directory;
 977 }
 978
 979 // wchar_t wrapper for get_windows_home_directory()
 980 const wchar_t *wget_windows_home_directory(void)
 981 {
 982         static const wchar_t *home_directory = NULL;
 983         wchar_t wpointer[MAX_PATH];
 984
 985         if (home_directory)
 986                 return home_directory;
 987
 988         if (xutftowcs_path(wpointer, get_windows_home_directory()) < 0)
 989                 return NULL;
 990
 991         home_directory = _wcsdup(wpointer);
 992
 993         return home_directory;
 994 }
 995
 996 int get_set_config(const char *key, const char *value, CONFIG_TYPE type)
 997 {
 998         char * config_exclusive_filename = NULL;
 999         int ret;
1000
1001         switch(type)
1002         {
1003         case CONFIG_LOCAL:
1004                 config_exclusive_filename  = git_pathdup("config");
1005                 break;
1006         case CONFIG_GLOBAL:
1007         case CONFIG_XDGGLOBAL:
1008                 {
1009                         const char *home = get_windows_home_directory();
1010                         if (home)
1011                         {
1012                                 if (type == CONFIG_GLOBAL)
1013                                         config_exclusive_filename = xstrdup(mkpath("%s/.gitconfig", home));
1014                                 else
1015                                         config_exclusive_filename = xstrdup(mkpath("%s/.config/git/config", home));
1016                         }
1017                 }
1018                 break;
1019         }
1020
1021         if(!config_exclusive_filename)
1022                 return -1;
1023
1024         ret = git_config_set_multivar_in_file_gently(config_exclusive_filename, key, value, NULL, 0);
1025         free(config_exclusive_filename);
1026         return ret;
1027 }
1028
1029 struct mailmap_info {
1030         char *name;
1031         char *email;
1032 };
1033
1034 struct mailmap_entry {
1035         /* name and email for the simple mail-only case */
1036         char *name;
1037         char *email;
1038
1039         /* name and email for the complex mail and name matching case */
1040         struct string_list namemap;
1041 };
1042
1043 int git_read_mailmap(GIT_MAILMAP *mailmap)
1044 {
1045         struct string_list *map;
1046         int result;
1047
1048         if (!mailmap)
1049                 return -1;
1050
1051         *mailmap = NULL;
1052         if ((map = (struct string_list *)calloc(1, sizeof(struct string_list))) == NULL)
1053                 return -1;
1054
1055         if ((result = read_mailmap(map, NULL)) != 0)
1056                 return result;
1057
1058         *mailmap = map;
1059         return 0;
1060 }
1061
1062 const char * git_get_mailmap_author(GIT_MAILMAP mailmap, const char *email2, void *payload, const char *(*author2_cb)(void *))
1063 {
1064         struct string_list *map;
1065         int imax, imin = 0;
1066
1067         if (!mailmap)
1068                 return NULL;
1069
1070         map = (struct string_list *)mailmap;
1071         imax = map->nr - 1;
1072         while (imax >= imin)
1073         {
1074                 int i = imin + ((imax - imin) / 2);
1075                 struct string_list_item *si = (struct string_list_item *)&map->items[i];
1076                 struct mailmap_entry *me = (struct mailmap_entry *)si->util;
1077                 int comp = strcmp(si->string, email2);
1078
1079                 if (!comp)
1080                 {
1081                         if (me->namemap.nr)
1082                         {
1083                                 const char *author2 = author2_cb(payload);
1084                                 unsigned int j;
1085                                 for (j = 0; j < me->namemap.nr; ++j)
1086                                 {
1087                                         struct string_list_item *sj = (struct string_list_item *)&me->namemap.items[j];
1088                                         struct mailmap_info *mi = (struct mailmap_info *)sj->util;
1089
1090                                         if (!strcmp(sj->string, author2))
1091                                                 return mi->name;
1092                                 }
1093                         }
1094
1095                         return me->name;
1096                 }
1097                 else if (comp < 0)
1098                         imin = i + 1;
1099                 else
1100                         imax = i - 1;
1101         }
1102
1103         return NULL;
1104 }
1105
1106 void git_free_mailmap(GIT_MAILMAP mailmap)
1107 {
1108         if (!mailmap)
1109                 return;
1110
1111         clear_mailmap((struct string_list *)mailmap);
1112         free(mailmap);
1113 }
1114