libgit-thin/ltcommit.c

   1 /**
   2  * @file
   3  *
   4  * Commit handling functions.
   5  *
   6  * The functions implemented in this file retrieve all kinds of
   7  * information from commits.
   8  *
   9  * Luiz Fernando N. Capitulino
  10  * <lcapitulino@gmail.com>
  11  */
  12 #include <stdio.h>
  13 #include <string.h>
  14 #include <stdlib.h>
  15 #include <time.h>
  16
  17 #include <cache.h>
  18 #include <commit.h>
  19
  20 #include "ltcommit.h"
  21
  22 /**< Commit structure */
  23 struct git_commit {
  24         struct commit *commit;
  25         char *author_name;
  26         size_t author_name_len;
  27         char *author_email;
  28         size_t author_email_len;
  29         int author_date;
  30         int author_tz;
  31         time_t author_time;
  32         char *committer_name;
  33         size_t committer_name_len;
  34         char *committer_email;
  35         int committer_date;
  36         int committer_tz;
  37         time_t committer_time;
  38         char *message;
  39         int tree_id;
  40         unsigned char tree_sha1[20];
  41 };
  42
  43 static char *commit_info_alloc(const char *src, size_t len)
  44 {
  45         char *p;
  46
  47         p = malloc(len + 1);
  48         if (!p)
  49                 return NULL;
  50
  51         memcpy(p, src, len);
  52         p[len] = '\0';
  53
  54         return p;
  55 }
  56
  57 static char *commit_strstr(const struct git_commit *commit,
  58                            const char *needle)
  59 {
  60         char *p, *endp;
  61
  62         if (!commit->commit)
  63                 return NULL;
  64
  65         p = strstr(commit->commit->buffer, needle);
  66         if (!p)
  67                 return NULL;
  68
  69         endp = strstr(commit->commit->buffer, "\n\n");
  70         if (!endp)
  71                 endp = commit->commit->buffer + strlen(commit->commit->buffer);
  72
  73         return (p < endp) ? p : NULL;
  74 }
  75
  76 static char *email_line_strchr(char *p, int c)
  77 {
  78         while (*p && *p != c && *p != '\n')
  79                 p++;
  80
  81         return (*p != c) ? NULL : p;
  82 }
  83
  84 static inline char *email_line_start(char *p)
  85 {
  86         return email_line_strchr(p, '<');
  87 }
  88
  89 static inline char *email_line_end(char *p)
  90 {
  91         return email_line_strchr(p, '>');
  92 }
  93
  94 static inline char *tz_start(char *p)
  95 {
  96         return email_line_strchr(p, ' ');
  97 }
  98
  99 static inline int check_strtoul_ret(unsigned long ret)
 100 {
 101         if ((!ret || ret == ULONG_MAX) && errno != 0)
 102                 return -1;
 103         return 0;
 104 }
 105
 106 static inline int check_strtol_ret(long ret)
 107 {
 108         if ((ret == LONG_MIN || ret == LONG_MAX) && errno != 0)
 109                 return -1;
 110         return 0;
 111 }
 112
 113 /**
 114  * Get the commit's message.
 115  *
 116  * \param commit git_commit structure to get the message from
 117  *
 118  * \return A pointer to the commit's message on success,
 119  *  NULL otherwise.
 120  */
 121 const char *git_commit_message(struct git_commit *commit)
 122 {
 123         if (!commit)
 124                 goto out_err;
 125
 126         if (!commit->message) {
 127                 char *p;
 128
 129                 if (!commit->commit)
 130                         goto out_err;
 131
 132                 p = strstr(commit->commit->buffer, "\n\n");
 133                 if (!p) {
 134                         /* empty message (probably) */
 135                         errno = 0;
 136                         return NULL;
 137                 }
 138
 139                 p += 2;
 140                 if (!p)
 141                         goto out_err;
 142
 143                 commit->message = commit_info_alloc(p, strlen(p));
 144         }
 145
 146         return commit->message;
 147
 148 out_err:
 149         errno = EINVAL;
 150         return NULL;
 151 }
 152
 153 /**
 154  * Get the commit's committer email.
 155  *
 156  * \param commit git_commit structure to get the committer's email
 157  *               from
 158  *
 159  * \return A pointer to the commit's committer email on success,
 160  * NULL otherwise.
 161  */
 162 const char *git_commit_committer_email(struct git_commit *commit)
 163 {
 164         if (!commit)
 165                 goto out_err;
 166
 167         if (!commit->committer_email) {
 168                 char *p, *endp;
 169
 170                 p = commit_strstr(commit, "committer ");
 171                 if (!p)
 172                         goto out_err;
 173
 174                 p = email_line_start(p);
 175                 if (!p)
 176                         goto out_err;
 177
 178                 endp = email_line_end(p);
 179                 if (!endp)
 180                         goto out_err;
 181
 182                 ++p;
 183                 commit->committer_email = commit_info_alloc(p, endp - p);
 184         }
 185
 186         return commit->committer_email;
 187
 188 out_err:
 189         errno = EINVAL;
 190         return NULL;
 191 }
 192
 193 /**
 194  * Get the commit's committer name.
 195  *
 196  * \param commit git_commit structure to get the committer's name
 197  *               from
 198  * \param ret pointer to return the committer's name into
 199  * \param len committer's name length
 200  *
 201  * \return 0 on success, NULL otherwise
 202  */
 203 int git_commit_committer_name(struct git_commit *commit,
 204                               const char **ret, size_t *len)
 205 {
 206         if (!commit || !ret)
 207                 goto out_err;
 208
 209         if (!commit->committer_name) {
 210                 char *p, *endp;
 211
 212                 p = commit_strstr(commit, "committer ");
 213                 if (!p)
 214                         goto out_err;
 215
 216                 endp = email_line_start(p);
 217                 if (!endp)
 218                         goto out_err;
 219
 220                 --endp;
 221                 if (*endp != ' ')
 222                         goto out_err;
 223
 224                 p += 10;
 225                 commit->committer_name = p;
 226                 commit->committer_name_len = endp - p;
 227         }
 228
 229         *ret = commit->committer_name;
 230         if (len)
 231                 *len = commit->committer_name_len;
 232
 233         return 0;
 234
 235 out_err:
 236         errno = EINVAL;
 237         return -1;
 238 }
 239
 240 /**
 241  * Get the commit's (committer) date
 242  *
 243  * \param commit git_commit structure to get the (committer's) date from
 244  * \param com_time return the date timestamp as seconds since the
 245  *        epoch, UTC (might be NULL)
 246  * \param com_tz return the timezone information as the number of
 247  *               hours and minutes offset from UTC (might be NULL)
 248  *
 249  * \return 0 on succes, -1 otherwise
 250  */
 251 int git_commit_committer_date(struct git_commit *commit,
 252                               time_t *com_time, int *com_tz)
 253 {
 254         if (!commit)
 255                 goto out_err;
 256
 257         if (!com_time && !com_tz)
 258                 goto out_err;
 259
 260         if (!commit->committer_date) {
 261                 int err;
 262                 char *p;
 263
 264                 p = commit_strstr(commit, "committer ");
 265                 if (!p)
 266                         goto out_err;
 267
 268                 p = email_line_end(p);
 269                 if (!p)
 270                         goto out_err;
 271
 272                 ++p;
 273                 if (*p != ' ')
 274                         goto out_err;
 275
 276                 errno = 0;
 277                 commit->committer_time = (time_t) strtoul(++p, NULL, 10);
 278                 err = check_strtoul_ret(commit->committer_time);
 279                 if (err)
 280                         return -1;
 281
 282                 p = tz_start(p);
 283                 if (!p)
 284                         goto out_err;
 285
 286                 errno = 0;
 287                 commit->committer_tz = strtol(++p, NULL, 10);
 288                 err = check_strtol_ret(commit->committer_tz);
 289                 if (err)
 290                         return -1;
 291
 292                 commit->committer_date = 1;
 293         }
 294
 295         if (com_time)
 296                 *com_time = commit->committer_time;
 297
 298         if (com_tz)
 299                 *com_tz = commit->committer_tz;
 300
 301         return 0;
 302
 303 out_err:
 304         errno = EINVAL;
 305         return -1;
 306 }
 307
 308 /**
 309  * Get the commit's author email.
 310  *
 311  * \param commit git_commit structure to get the author's email
 312  *               from
 313  *
 314  * \return A pointer to the commit's author's email on success,
 315  *  NULL otherwise.
 316  */
 317 int git_commit_author_email(struct git_commit *commit,
 318                             const char **ret, size_t *len)
 319 {
 320         if (!commit)
 321                 goto out_err;
 322
 323         if (!commit->author_email) {
 324                 char *p, *endp;
 325
 326                 p = commit_strstr(commit, "author ");
 327                 if (!p)
 328                         goto out_err;
 329
 330                 p = email_line_start(p);
 331                 if (!p)
 332                         goto out_err;
 333
 334                 endp = email_line_end(p);
 335                 if (!endp)
 336                         goto out_err;
 337
 338                 commit->author_email = ++p;
 339                 commit->author_email_len = endp - p;
 340         }
 341
 342         *ret = commit->author_email;
 343         if (len)
 344                 *len = commit->author_email_len;
 345
 346         return 0;
 347
 348 out_err:
 349         errno = EINVAL;
 350         return -1;
 351 }
 352
 353 /**
 354  * Get the commit's (author) date
 355  *
 356  * \param commit git_commit structure to get the (author's) date from
 357  * \param com_time return the date timestamp as seconds since the
 358  *        epoch, UTC (might be NULL)
 359  * \param com_tz return the timezone information as the number of
 360  *               hours and minutes offset from UTC (might be NULL)
 361  *
 362  * \return 0 on succes, -1 otherwise
 363  */
 364 int git_commit_author_date(struct git_commit *commit,
 365                            time_t *com_time, int *com_tz)
 366 {
 367         if (!commit)
 368                 goto out_err;
 369
 370         if (!com_time && !com_tz)
 371                 goto out_err;
 372
 373         if (!commit->author_date) {
 374                 int err;
 375                 char *p;
 376
 377                 p = commit_strstr(commit, "author ");
 378                 if (!p)
 379                         goto out_err;
 380
 381                 p = email_line_end(p);
 382                 if (!p)
 383                         goto out_err;
 384
 385                 ++p;
 386                 if (*p != ' ')
 387                         goto out_err;
 388
 389                 errno = 0;
 390                 commit->author_time = (time_t) strtoul(++p, NULL, 10);
 391                 err = check_strtoul_ret(commit->author_time);
 392                 if (err)
 393                         return -1;
 394
 395                 p = tz_start(p);
 396                 if (!p)
 397                         goto out_err;
 398
 399                 errno = 0;
 400                 commit->author_tz = strtol(++p, NULL, 10);
 401                 err = check_strtol_ret(commit->author_tz);
 402                 if (err)
 403                         return -1;
 404
 405                 commit->author_date = 1;
 406         }
 407
 408         if (com_time)
 409                 *com_time = commit->author_time;
 410
 411         if (com_tz)
 412                 *com_tz = commit->author_tz;
 413
 414         return 0;
 415
 416 out_err:
 417         errno = EINVAL;
 418         return -1;
 419 }
 420
 421 /**
 422  * Get the commit's author name.
 423  *
 424  * \param commit git_commit structure to get the author's name
 425  *               from
 426  * \param ret pointer to return the author's name into
 427  * \param len author's name length
 428  *
 429  * \return 0 on success, NULL otherwise
 430  */
 431 int git_commit_author_name(struct git_commit *commit,
 432                            const char **ret, size_t *len)
 433 {
 434         if (!commit || !ret)
 435                 goto out_err;
 436
 437         if (!commit->author_name) {
 438                 char *p, *endp;
 439
 440                 p = commit_strstr(commit, "author ");
 441                 if (!p)
 442                         goto out_err;
 443
 444                 endp = email_line_start(p);
 445                 if (!endp)
 446                         goto out_err;
 447
 448                 --endp;
 449                 if (*endp != ' ')
 450                         goto out_err;
 451
 452                 p += 7;
 453                 commit->author_name = p;
 454                 commit->author_name_len = endp - p;
 455         }
 456
 457         *ret = commit->author_name;
 458         if (len)
 459                 *len = commit->author_name_len;
 460
 461         return 0;
 462
 463 out_err:
 464         errno = EINVAL;
 465         return -1;
 466 }
 467
 468 /**
 469  * Get the commit's SHA1.
 470  *
 471  * \param commit git_commit structure to get the commit's SHA1 from
 472  * \param sha1 pointer to an 20-byte array to return the SHA1 into
 473  *
 474  * \return 0 on success, -1 otherwise
 475  */
 476 int git_commit_id(struct git_commit *commit, unsigned char *sha1)
 477 {
 478         if (!commit || !commit->commit || !sha1) {
 479                 errno = EINVAL;
 480                 return -1;
 481         }
 482
 483         memcpy(sha1, commit->commit->object.sha1, 20);
 484         return 0;
 485 }
 486
 487 /**
 488  * Get the commit's tree SHA1.
 489  *
 490  * \param commit git_commit structure to get the tree SHA1 from
 491  * \param sha1 pointer to an 20-byte array to return the SHA1 into
 492  *
 493  * \return 0 on success, -1 otherwise
 494  */
 495 int git_commit_tree(struct git_commit *commit, unsigned char *sha1)
 496 {
 497         if (!commit || !sha1)
 498                 goto out_err;
 499
 500         if (!commit->tree_id) {
 501                 char *p;
 502                 int err;
 503
 504                 p = commit_strstr(commit, "tree ");
 505                 if (!p)
 506                         goto out_err;
 507
 508                 p += 5;
 509                 if (!p)
 510                         goto out_err;
 511
 512                 err = get_sha1_hex(p, commit->tree_sha1);
 513                 if (err)
 514                         return -1;
 515
 516                 commit->tree_id = 1;
 517         }
 518
 519         memcpy(sha1, commit->tree_sha1, 20);
 520         return 0;
 521
 522 out_err:
 523         errno = EINVAL;
 524         return -1;
 525 }
 526
 527 /**
 528  * Get the commit's buffer raw data.
 529  *
 530  * \param commit git_commit structure to get the raw buffer
 531  *               from
 532  *
 533  * \return A pointer to the commit's raw buffer (if any).
 534  */
 535 const char *git_commit_raw(struct git_commit *commit)
 536 {
 537         if (!commit || !commit->commit) {
 538                 errno = EINVAL;
 539                 return NULL;
 540         }
 541
 542         return commit->commit->buffer;
 543 }
 544
 545 /**
 546  * Free all the memory allocated by the git_commit structure's
 547  * members.
 548  *
 549  * This is a low-level function, only use it if you know
 550  * what you're doing.
 551  *
 552  * \param commit git_commit structure to have the contents
 553  * freed
 554  */
 555 void __git_commit_free(struct git_commit *commit)
 556 {
 557         if (!commit->commit)
 558                 return;
 559
 560         free(commit->commit->buffer);
 561         commit->commit->buffer = NULL;
 562
 563         free(commit->committer_email);
 564         free(commit->message);
 565 }
 566
 567 /**
 568  * Free all the memory allocated by a git_commit structure.
 569  *
 570  * \param commit git_commit structure to be freed.
 571  */
 572 void git_commit_free(struct git_commit *commit)
 573 {
 574         if (commit) {
 575                 __git_commit_free(commit);
 576                 free(commit);
 577         }
 578 }
 579
 580 /**
 581  * Initialize a git_commit structure.
 582  *
 583  * This is a low-level function, only use it if you know
 584  * what you're doing.
 585  *
 586  * \param commit git_commit structure to be initialized
 587  */
 588 void __git_commit_init(struct git_commit *commit)
 589 {
 590         commit->commit = NULL;
 591         commit->author_name = NULL;
 592         commit->author_email = NULL;
 593         commit->author_date = 0;
 594         commit->committer_name = NULL;
 595         commit->committer_email = NULL;
 596         commit->committer_date = 0;
 597         commit->message = NULL;
 598         commit->tree_id = 0;
 599 }
 600
 601 /**
 602  * Allocate and initialize a git_commit structure.
 603  *
 604  * Should be called before using git_revlist_next().
 605  *
 606  * \return A pointer to an allocated git_commit structure
 607  * on success, NULL otherwise.
 608  */
 609 struct git_commit *git_commit_init(void)
 610 {
 611         struct git_commit *commit;
 612
 613         commit = malloc(sizeof(*commit));
 614         if (!commit)
 615                 return NULL;
 616
 617         __git_commit_init(commit);
 618         return commit;
 619 }
 620
 621 /**
 622  * Compare two commits.
 623  *
 624  * \param a git_commit structure to compare with
 625  * \param b git_commit structure to compare with
 626  *
 627  * \return 1 if commits are equal, 0 if they don't and -1 on
 628  * error.
 629  */
 630 int git_commit_equal(const struct git_commit *a,const struct git_commit *b)
 631 {
 632         if (!a || !b) {
 633                 errno = EINVAL;
 634                 return -1;
 635         }
 636
 637         return (a->commit == b->commit);
 638 }
 639
 640 /**
 641  * Get the raw GIT commit object from a git_commit
 642  * structure.
 643  *
 644  * This is a low-level function, only use it if you know
 645  * what you're doing.
 646  *
 647  * \param commit git_commit structure to get the commit object
 648  *               from
 649  *
 650  * \return A pointer to the raw GIT commit object if any,
 651  * NULL otherwise.
 652  */
 653 struct commit *__git_commit_obj(struct git_commit *commit)
 654 {
 655         return commit->commit;
 656 }
 657
 658 /**
 659  * Set the git_commit structure's (raw) GIT commit object
 660  * contents.
 661  *
 662  * This is a low-level function, only use it if you know
 663  * what you're doing.
 664  *
 665  * \param commit git_commit structure to set the raw GIT
 666  *               commit object
 667  * \param new The raw GIT commit object to set into the git_commit
 668  *            structure
 669  */
 670 void __git_commit_obj_set(struct git_commit *commit, struct commit *new)
 671 {
 672         commit->commit = new;
 673 }
 674
 675 /**
 676  * Return a filled git_commit structure from a given commit's SHA1
 677  *
 678  * \param sha1 commit's SHA1 to be read
 679  *
 680  * \returns git_commit structure on success, NULL otherwise.
 681  */
 682 struct git_commit *git_commit_lookup(const unsigned char *sha1)
 683 {
 684         struct git_commit *commit;
 685
 686         if (!sha1) {
 687                 errno = EINVAL;
 688                 return NULL;
 689         }
 690
 691         commit = git_commit_init();
 692         if (!commit)
 693                 return NULL;
 694
 695         commit->commit = lookup_commit_reference_gently(sha1, 1);
 696         if (!commit->commit) {
 697                 git_commit_free(commit);
 698                 return NULL;
 699         }
 700
 701         return commit;
 702 }