src/libgit2/signature.c

   1 /*
   2  * Copyright (C) the libgit2 contributors. All rights reserved.
   3  *
   4  * This file is part of libgit2, distributed under the GNU GPL v2 with
   5  * a Linking Exception. For full terms see the included COPYING file.
   6  */
   7
   8 #include "signature.h"
   9
  10 #include "repository.h"
  11 #include "git2/common.h"
  12 #include "posix.h"
  13
  14 void git_signature_free(git_signature *sig)
  15 {
  16         if (sig == NULL)
  17                 return;
  18
  19         git__free(sig->name);
  20         sig->name = NULL;
  21         git__free(sig->email);
  22         sig->email = NULL;
  23         git__free(sig);
  24 }
  25
  26 static int signature_parse_error(const char *msg)
  27 {
  28         git_error_set(GIT_ERROR_INVALID, "failed to parse signature - %s", msg);
  29         return GIT_EINVALID;
  30 }
  31
  32 static int signature_error(const char *msg)
  33 {
  34         git_error_set(GIT_ERROR_INVALID, "failed to parse signature - %s", msg);
  35         return -1;
  36 }
  37
  38 static bool contains_angle_brackets(const char *input)
  39 {
  40         return strchr(input, '<') != NULL || strchr(input, '>') != NULL;
  41 }
  42
  43 static bool is_crud(unsigned char c)
  44 {
  45         return  c <= 32  ||
  46                 c == '.' ||
  47                 c == ',' ||
  48                 c == ':' ||
  49                 c == ';' ||
  50                 c == '<' ||
  51                 c == '>' ||
  52                 c == '"' ||
  53                 c == '\\' ||
  54                 c == '\'';
  55 }
  56
  57 static char *extract_trimmed(const char *ptr, size_t len)
  58 {
  59         while (len && is_crud((unsigned char)ptr[0])) {
  60                 ptr++; len--;
  61         }
  62
  63         while (len && is_crud((unsigned char)ptr[len - 1])) {
  64                 len--;
  65         }
  66
  67         return git__substrdup(ptr, len);
  68 }
  69
  70 int git_signature_new(git_signature **sig_out, const char *name, const char *email, git_time_t time, int offset)
  71 {
  72         git_signature *p = NULL;
  73
  74         GIT_ASSERT_ARG(name);
  75         GIT_ASSERT_ARG(email);
  76
  77         *sig_out = NULL;
  78
  79         if (contains_angle_brackets(name) ||
  80                 contains_angle_brackets(email)) {
  81                 return signature_error(
  82                         "Neither `name` nor `email` should contain angle brackets chars.");
  83         }
  84
  85         p = git__calloc(1, sizeof(git_signature));
  86         GIT_ERROR_CHECK_ALLOC(p);
  87
  88         p->name = extract_trimmed(name, strlen(name));
  89         GIT_ERROR_CHECK_ALLOC(p->name);
  90         p->email = extract_trimmed(email, strlen(email));
  91         GIT_ERROR_CHECK_ALLOC(p->email);
  92
  93         if (p->name[0] == '\0' || p->email[0] == '\0') {
  94                 git_signature_free(p);
  95                 return signature_error("Signature cannot have an empty name or email");
  96         }
  97
  98         p->when.time = time;
  99         p->when.offset = offset;
 100         p->when.sign = (offset < 0) ? '-' : '+';
 101
 102         *sig_out = p;
 103         return 0;
 104 }
 105
 106 int git_signature_dup(git_signature **dest, const git_signature *source)
 107 {
 108         git_signature *signature;
 109
 110         if (source == NULL)
 111                 return 0;
 112
 113         signature = git__calloc(1, sizeof(git_signature));
 114         GIT_ERROR_CHECK_ALLOC(signature);
 115
 116         signature->name = git__strdup(source->name);
 117         GIT_ERROR_CHECK_ALLOC(signature->name);
 118
 119         signature->email = git__strdup(source->email);
 120         GIT_ERROR_CHECK_ALLOC(signature->email);
 121
 122         signature->when.time = source->when.time;
 123         signature->when.offset = source->when.offset;
 124         signature->when.sign = source->when.sign;
 125
 126         *dest = signature;
 127
 128         return 0;
 129 }
 130
 131 int git_signature__pdup(git_signature **dest, const git_signature *source, git_pool *pool)
 132 {
 133         git_signature *signature;
 134
 135         if (source == NULL)
 136                 return 0;
 137
 138         signature = git_pool_mallocz(pool, sizeof(git_signature));
 139         GIT_ERROR_CHECK_ALLOC(signature);
 140
 141         signature->name = git_pool_strdup(pool, source->name);
 142         GIT_ERROR_CHECK_ALLOC(signature->name);
 143
 144         signature->email = git_pool_strdup(pool, source->email);
 145         GIT_ERROR_CHECK_ALLOC(signature->email);
 146
 147         signature->when.time = source->when.time;
 148         signature->when.offset = source->when.offset;
 149         signature->when.sign = source->when.sign;
 150
 151         *dest = signature;
 152
 153         return 0;
 154 }
 155
 156 int git_signature_now(git_signature **sig_out, const char *name, const char *email)
 157 {
 158         time_t now;
 159         time_t offset;
 160         struct tm *utc_tm;
 161         git_signature *sig;
 162         struct tm _utc;
 163
 164         *sig_out = NULL;
 165
 166         /*
 167          * Get the current time as seconds since the epoch and
 168          * transform that into a tm struct containing the time at
 169          * UTC. Give that to mktime which considers it a local time
 170          * (tm_isdst = -1 asks it to take DST into account) and gives
 171          * us that time as seconds since the epoch. The difference
 172          * between its return value and 'now' is our offset to UTC.
 173          */
 174         time(&now);
 175         utc_tm = p_gmtime_r(&now, &_utc);
 176         utc_tm->tm_isdst = -1;
 177         offset = (time_t)difftime(now, mktime(utc_tm));
 178         offset /= 60;
 179
 180         if (git_signature_new(&sig, name, email, now, (int)offset) < 0)
 181                 return -1;
 182
 183         *sig_out = sig;
 184
 185         return 0;
 186 }
 187
 188 int git_signature_default(git_signature **out, git_repository *repo)
 189 {
 190         int error;
 191         git_config *cfg;
 192         const char *user_name, *user_email;
 193
 194         if ((error = git_repository_config_snapshot(&cfg, repo)) < 0)
 195                 return error;
 196
 197         if (!(error = git_config_get_string(&user_name, cfg, "user.name")) &&
 198                 !(error = git_config_get_string(&user_email, cfg, "user.email")))
 199                 error = git_signature_now(out, user_name, user_email);
 200
 201         git_config_free(cfg);
 202         return error;
 203 }
 204
 205 int git_signature__parse(git_signature *sig, const char **buffer_out,
 206                 const char *buffer_end, const char *header, char ender)
 207 {
 208         const char *buffer = *buffer_out;
 209         const char *email_start, *email_end;
 210
 211         memset(sig, 0, sizeof(git_signature));
 212
 213         if (ender &&
 214                 (buffer_end = memchr(buffer, ender, buffer_end - buffer)) == NULL)
 215                 return signature_parse_error("no newline given");
 216
 217         if (header) {
 218                 const size_t header_len = strlen(header);
 219
 220                 if (buffer + header_len >= buffer_end || memcmp(buffer, header, header_len) != 0)
 221                         return signature_parse_error("expected prefix doesn't match actual");
 222
 223                 buffer += header_len;
 224         }
 225
 226         email_start = git__memrchr(buffer, '<', buffer_end - buffer);
 227         email_end = git__memrchr(buffer, '>', buffer_end - buffer);
 228
 229         if (!email_start || !email_end || email_end <= email_start)
 230                 return signature_parse_error("malformed e-mail");
 231
 232         email_start += 1;
 233         sig->name = extract_trimmed(buffer, email_start - buffer - 1);
 234         sig->email = extract_trimmed(email_start, email_end - email_start);
 235
 236         /* Do we even have a time at the end of the signature? */
 237         if (email_end + 2 < buffer_end) {
 238                 const char *time_start = email_end + 2;
 239                 const char *time_end;
 240
 241                 if (git__strntol64(&sig->when.time, time_start,
 242                                    buffer_end - time_start, &time_end, 10) < 0) {
 243                         git__free(sig->name);
 244                         git__free(sig->email);
 245                         sig->name = sig->email = NULL;
 246                         return signature_parse_error("invalid Unix timestamp");
 247                 }
 248
 249                 /* do we have a timezone? */
 250                 if (time_end + 1 < buffer_end) {
 251                         int offset, hours, mins;
 252                         const char *tz_start, *tz_end;
 253
 254                         tz_start = time_end + 1;
 255
 256                         if ((tz_start[0] != '-' && tz_start[0] != '+') ||
 257                             git__strntol32(&offset, tz_start + 1,
 258                                            buffer_end - tz_start - 1, &tz_end, 10) < 0) {
 259                                 /* malformed timezone, just assume it's zero */
 260                                 offset = 0;
 261                         }
 262
 263                         hours = offset / 100;
 264                         mins = offset % 100;
 265
 266                         /*
 267                          * only store timezone if it's not overflowing;
 268                          * see http://www.worldtimezone.com/faq.html
 269                          */
 270                         if (hours <= 14 && mins <= 59) {
 271                                 sig->when.offset = (hours * 60) + mins;
 272                                 sig->when.sign = tz_start[0];
 273                                 if (tz_start[0] == '-')
 274                                         sig->when.offset = -sig->when.offset;
 275                         }
 276                 }
 277         }
 278
 279         *buffer_out = buffer_end + 1;
 280         return 0;
 281 }
 282
 283 int git_signature_from_buffer(git_signature **out, const char *buf)
 284 {
 285         git_signature *sig;
 286         const char *buf_end;
 287         int error;
 288
 289         GIT_ASSERT_ARG(out);
 290         GIT_ASSERT_ARG(buf);
 291
 292         *out = NULL;
 293
 294         sig = git__calloc(1, sizeof(git_signature));
 295         GIT_ERROR_CHECK_ALLOC(sig);
 296
 297         buf_end = buf + strlen(buf);
 298         error = git_signature__parse(sig, &buf, buf_end, NULL, '\0');
 299
 300         if (error)
 301                 git__free(sig);
 302         else
 303                 *out = sig;
 304
 305         return error;
 306 }
 307
 308 void git_signature__writebuf(git_str *buf, const char *header, const git_signature *sig)
 309 {
 310         int offset, hours, mins;
 311         char sign;
 312
 313         offset = sig->when.offset;
 314         sign = (sig->when.offset < 0 || sig->when.sign == '-') ? '-' : '+';
 315
 316         if (offset < 0)
 317                 offset = -offset;
 318
 319         hours = offset / 60;
 320         mins = offset % 60;
 321
 322         git_str_printf(buf, "%s%s <%s> %u %c%02d%02d\n",
 323                         header ? header : "", sig->name, sig->email,
 324                         (unsigned)sig->when.time, sign, hours, mins);
 325 }
 326
 327 bool git_signature__equal(const git_signature *one, const git_signature *two)
 328 {
 329         GIT_ASSERT_ARG(one);
 330         GIT_ASSERT_ARG(two);
 331
 332         return
 333                 git__strcmp(one->name, two->name) == 0 &&
 334                 git__strcmp(one->email, two->email) == 0 &&
 335                 one->when.time == two->when.time &&
 336                 one->when.offset == two->when.offset &&
 337                 one->when.sign == two->when.sign;
 338 }
 339