Line Flow Count Block(s) Source
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 "config.h"
9 -
10 - #include "git2/config.h"
11 - #include "git2/sys/config.h"
12 -
13 - #include "array.h"
14 - #include "buffer.h"
15 - #include "config_backend.h"
16 - #include "config_entries.h"
17 - #include "config_parse.h"
18 - #include "filebuf.h"
19 - #include "regexp.h"
20 - #include "sysdir.h"
21 - #include "wildmatch.h"
22 -
23 - /* Max depth for [include] directives */
24 - #define MAX_INCLUDE_DEPTH 10
25 -
26 - typedef struct config_file {
27 - git_futils_filestamp stamp;
28 - git_oid checksum;
29 - char *path;
30 - git_array_t(struct config_file) includes;
31 - } config_file;
32 -
33 - typedef struct {
34 - git_config_backend parent;
35 - git_mutex values_mutex;
36 - git_config_entries *entries;
37 - const git_repository *repo;
38 - git_config_level_t level;
39 -
40 - git_array_t(git_config_parser) readers;
41 -
42 - bool locked;
43 - git_filebuf locked_buf;
44 - git_buf locked_content;
45 -
46 - config_file file;
47 - } config_file_backend;
48 -
49 - typedef struct {
50 - const git_repository *repo;
51 - config_file *file;
52 - git_config_entries *entries;
53 - git_config_level_t level;
54 - unsigned int depth;
55 - } config_file_parse_data;
56 -
57 - static int config_file_read(git_config_entries *entries, const git_repository *repo, config_file *file, git_config_level_t level, int depth);
58 - static int config_file_read_buffer(git_config_entries *entries, const git_repository *repo, config_file *file, git_config_level_t level, int depth, const char *buf, size_t buflen);
59 - static int config_file_write(config_file_backend *cfg, const char *orig_key, const char *key, const git_regexp *preg, const char *value);
60 - static char *escape_value(const char *ptr);
61 -
62 - /**
63 - * Take the current values map from the backend and increase its
64 - * refcount. This is its own function to make sure we use the mutex to
65 - * avoid the map pointer from changing under us.
66 - */
67 123564 2 static int config_file_entries_take(git_config_entries **out, config_file_backend *b)
68 - {
69 - int error;
70 -
71 123654 2,3 if ((error = git_mutex_lock(&b->values_mutex)) < 0) {
72 ##### 4 git_error_set(GIT_ERROR_OS, "failed to lock config backend");
73 ##### 5 return error;
74 - }
75 -
76 123654 6 git_config_entries_incref(b->entries);
77 123655 7 *out = b->entries;
78 -
79 123655 7 git_mutex_unlock(&b->values_mutex);
80 -
81 123659 8 return 0;
82 - }
83 -
84 15546 2 static void config_file_clear(config_file *file)
85 - {
86 - config_file *include;
87 - uint32_t i;
88 -
89 15546 2 if (file == NULL)
90 15544 3,11 return;
91 -
92 15694 4,6-8 git_array_foreach(file->includes, i, include) {
93 148 5 config_file_clear(include);
94 - }
95 15546 9 git_array_clear(file->includes);
96 -
97 15545 10 git__free(file->path);
98 - }
99 -
100 - 2 suppressed: function cannot be solved config_file_open (automatic due to inconsistent arc counts in .gcda files)static int config_file_open(git_config_backend *cfg, git_config_level_t level, const git_repository *repo)
101 - {
102 - 2 suppressed: function cannot be solved config_file_open (automatic due to inconsistent arc counts in .gcda files) config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
103 - int res;
104 -
105 - 2 suppressed: function cannot be solved config_file_open (automatic due to inconsistent arc counts in .gcda files) b->level = level;
106 - 2 suppressed: function cannot be solved config_file_open (automatic due to inconsistent arc counts in .gcda files) b->repo = repo;
107 -
108 - 2,3 suppressed: function cannot be solved config_file_open (automatic due to inconsistent arc counts in .gcda files) if ((res = git_config_entries_new(&b->entries)) < 0)
109 - 4 suppressed: function cannot be solved config_file_open (automatic due to inconsistent arc counts in .gcda files) return res;
110 -
111 - 5,6 suppressed: function cannot be solved config_file_open (automatic due to inconsistent arc counts in .gcda files) if (!git_path_exists(b->file.path))
112 - 7 suppressed: function cannot be solved config_file_open (automatic due to inconsistent arc counts in .gcda files) return 0;
113 -
114 - /*
115 - * git silently ignores configuration files that are not
116 - * readable. We emulate that behavior. This is particularly
117 - * important for sandboxed applications on macOS where the
118 - * git configuration files may not be readable.
119 - */
120 - 8,9 suppressed: function cannot be solved config_file_open (automatic due to inconsistent arc counts in .gcda files) if (p_access(b->file.path, R_OK) < 0)
121 - 10 suppressed: function cannot be solved config_file_open (automatic due to inconsistent arc counts in .gcda files) return GIT_ENOTFOUND;
122 -
123 - 11-13 suppressed: function cannot be solved config_file_open (automatic due to inconsistent arc counts in .gcda files) if (res < 0 || (res = config_file_read(b->entries, repo, &b->file, level, 0)) < 0) {
124 - 14 suppressed: function cannot be solved config_file_open (automatic due to inconsistent arc counts in .gcda files) git_config_entries_free(b->entries);
125 - 15 suppressed: function cannot be solved config_file_open (automatic due to inconsistent arc counts in .gcda files) b->entries = NULL;
126 - }
127 -
128 - 16 suppressed: function cannot be solved config_file_open (automatic due to inconsistent arc counts in .gcda files) return res;
129 - }
130 -
131 113215 2 static int config_file_is_modified(int *modified, config_file *file)
132 - {
133 - config_file *include;
134 113215 2 git_buf buf = GIT_BUF_INIT;
135 - git_oid hash;
136 - uint32_t i;
137 113215 2 int error = 0;
138 -
139 113215 2 *modified = 0;
140 -
141 113264 2,3 if (!git_futils_filestamp_check(&file->stamp, file->path))
142 86747 4 goto check_includes;
143 -
144 26517 5,6 if ((error = git_futils_readbuffer(&buf, file->path)) < 0)
145 24684 7 goto out;
146 -
147 1831 8,9 if ((error = git_hash_buf(&hash, buf.ptr, buf.size)) < 0)
148 ##### 10 goto out;
149 -
150 1831 11,12 if (!git_oid_equal(&hash, &file->checksum)) {
151 1830 13 *modified = 1;
152 1830 13 goto out;
153 - }
154 -
155 - check_includes:
156 87012 14,18-20 git_array_foreach(file->includes, i, include) {
157 268 15-17 if ((error = config_file_is_modified(modified, include)) < 0 || *modified)
158 - goto out;
159 - }
160 -
161 - out:
162 113262 21 git_buf_dispose(&buf);
163 -
164 113229 22 return error;
165 - }
166 -
167 6491 2 static int config_file_set_entries(git_config_backend *cfg, git_config_entries *entries)
168 - {
169 6491 2 config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
170 6491 2 git_config_entries *old = NULL;
171 - config_file *include;
172 - int error;
173 - uint32_t i;
174 -
175 6491 2 if (b->parent.readonly) {
176 ##### 3 git_error_set(GIT_ERROR_CONFIG, "this backend is read-only");
177 ##### 4 return -1;
178 - }
179 -
180 6498 5,7-9 git_array_foreach(b->file.includes, i, include)
181 7 6 config_file_clear(include);
182 6491 10 git_array_clear(b->file.includes);
183 -
184 6491 11,12 if ((error = git_mutex_lock(&b->values_mutex)) < 0) {
185 ##### 13 git_error_set(GIT_ERROR_OS, "failed to lock config backend");
186 ##### 14 goto out;
187 - }
188 -
189 6491 15 old = b->entries;
190 6491 15 b->entries = entries;
191 -
192 6491 15 git_mutex_unlock(&b->values_mutex);
193 -
194 - out:
195 6491 16 git_config_entries_free(old);
196 6491 17 return error;
197 - }
198 -
199 4661 2 static int config_file_refresh_from_buffer(git_config_backend *cfg, const char *buf, size_t buflen)
200 - {
201 4661 2 config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
202 4661 2 git_config_entries *entries = NULL;
203 - int error;
204 -
205 4661 2-5 if ((error = git_config_entries_new(&entries)) < 0 ||
206 4661 4 (error = config_file_read_buffer(entries, b->repo, &b->file,
207 4661 6,7 b->level, 0, buf, buflen)) < 0 ||
208 4661 6 (error = config_file_set_entries(cfg, entries)) < 0)
209 - goto out;
210 -
211 4661 8 entries = NULL;
212 - out:
213 4661 9 git_config_entries_free(entries);
214 4661 10 return error;
215 - }
216 -
217 112956 2 static int config_file_refresh(git_config_backend *cfg)
218 - {
219 112956 2 config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
220 112956 2 git_config_entries *entries = NULL;
221 - int error, modified;
222 -
223 112956 2 if (cfg->readonly)
224 1 3 return 0;
225 -
226 112955 4-6 if ((error = config_file_is_modified(&modified, &b->file)) < 0 && error != GIT_ENOTFOUND)
227 ##### 7 goto out;
228 -
229 112953 8 if (!modified)
230 111123 9 return 0;
231 -
232 1830 10-13 if ((error = git_config_entries_new(&entries)) < 0 ||
233 1830 12,14,15 (error = config_file_read(entries, b->repo, &b->file, b->level, 0)) < 0 ||
234 1830 14 (error = config_file_set_entries(cfg, entries)) < 0)
235 - goto out;
236 -
237 1830 16 entries = NULL;
238 - out:
239 1830 17 git_config_entries_free(entries);
240 -
241 1830 18 return (error == GIT_ENOTFOUND) ? 0 : error;
242 - }
243 -
244 15391 2 static void config_file_free(git_config_backend *_backend)
245 - {
246 15391 2 config_file_backend *backend = GIT_CONTAINER_OF(_backend, config_file_backend, parent);
247 -
248 15391 2 if (backend == NULL)
249 15390 3,8 return;
250 -
251 15391 4 config_file_clear(&backend->file);
252 15389 5 git_config_entries_free(backend->entries);
253 15389 6 git_mutex_free(&backend->values_mutex);
254 15389 7 git__free(backend);
255 - }
256 -
257 - 2 suppressed: function cannot be solved config_file_iterator (automatic due to inconsistent arc counts in .gcda files)static int config_file_iterator(
258 - git_config_iterator **iter,
259 - struct git_config_backend *backend)
260 - {
261 - 2 suppressed: function cannot be solved config_file_iterator (automatic due to inconsistent arc counts in .gcda files) config_file_backend *b = GIT_CONTAINER_OF(backend, config_file_backend, parent);
262 - 2 suppressed: function cannot be solved config_file_iterator (automatic due to inconsistent arc counts in .gcda files) git_config_entries *dupped = NULL, *entries = NULL;
263 - int error;
264 -
265 - 2-5 suppressed: function cannot be solved config_file_iterator (automatic due to inconsistent arc counts in .gcda files) if ((error = config_file_refresh(backend)) < 0 ||
266 - 6,7 suppressed: function cannot be solved config_file_iterator (automatic due to inconsistent arc counts in .gcda files) (error = config_file_entries_take(&entries, b)) < 0 ||
267 - 6,8 suppressed: function cannot be solved config_file_iterator (automatic due to inconsistent arc counts in .gcda files) (error = git_config_entries_dup(&dupped, entries)) < 0 ||
268 - 8 suppressed: function cannot be solved config_file_iterator (automatic due to inconsistent arc counts in .gcda files) (error = git_config_entries_iterator_new(iter, dupped)) < 0)
269 - goto out;
270 -
271 - out:
272 - /* Let iterator delete duplicated entries when it's done */
273 - 9 suppressed: function cannot be solved config_file_iterator (automatic due to inconsistent arc counts in .gcda files) git_config_entries_free(entries);
274 - 10 suppressed: function cannot be solved config_file_iterator (automatic due to inconsistent arc counts in .gcda files) git_config_entries_free(dupped);
275 - 11 suppressed: function cannot be solved config_file_iterator (automatic due to inconsistent arc counts in .gcda files) return error;
276 - }
277 -
278 47981 2 static int config_file_snapshot(git_config_backend **out, git_config_backend *backend)
279 - {
280 47981 2 return git_config_backend_snapshot(out, backend);
281 - }
282 -
283 4967 2 static int config_file_set(git_config_backend *cfg, const char *name, const char *value)
284 - {
285 4967 2 config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
286 - git_config_entries *entries;
287 - git_config_entry *existing;
288 4967 2 char *key, *esc_value = NULL;
289 - int error;
290 -
291 4967 2,3 if ((error = git_config__normalize_name(name, &key)) < 0)
292 9 4 return error;
293 -
294 4958 5,6 if ((error = config_file_entries_take(&entries, b)) < 0)
295 ##### 7 return error;
296 -
297 - /* Check whether we'd be modifying an included or multivar key */
298 4958 8,9 if ((error = git_config_entries_get_unique(&existing, entries, key)) < 0) {
299 2252 10 if (error != GIT_ENOTFOUND)
300 1 11 goto out;
301 2251 12 error = 0;
302 2706 13-15 } else if ((!existing->value && !value) ||
303 2706 15-17 (existing->value && value && !strcmp(existing->value, value))) {
304 - /* don't update if old and new values already match */
305 2300 18 error = 0;
306 2300 18 goto out;
307 - }
308 -
309 - /* No early returns due to sanity checks, let's write it out and refresh */
310 2657 19 if (value) {
311 2657 20 esc_value = escape_value(value);
312 2657 21,22 GIT_ERROR_CHECK_ALLOC(esc_value);
313 - }
314 -
315 2657 23,24 if ((error = config_file_write(b, name, key, NULL, esc_value)) < 0)
316 1 25 goto out;
317 -
318 - out:
319 4958 26 git_config_entries_free(entries);
320 4958 27 git__free(esc_value);
321 4958 28 git__free(key);
322 4958 29 return error;
323 - }
324 -
325 - /* release the map containing the entry as an equivalent to freeing it */
326 4068 2 static void config_file_entry_free(git_config_entry *entry)
327 - {
328 4068 2 git_config_entries *entries = (git_config_entries *) entry->payload;
329 4068 2 git_config_entries_free(entries);
330 4068 3 }
331 -
332 - /*
333 - * Internal function that actually gets the value in string form
334 - */
335 - 2 suppressed: function cannot be solved config_file_get (automatic due to inconsistent arc counts in .gcda files)static int config_file_get(git_config_backend *cfg, const char *key, git_config_entry **out)
336 - {
337 - 2 suppressed: function cannot be solved config_file_get (automatic due to inconsistent arc counts in .gcda files) config_file_backend *h = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
338 - 2 suppressed: function cannot be solved config_file_get (automatic due to inconsistent arc counts in .gcda files) git_config_entries *entries = NULL;
339 - git_config_entry *entry;
340 - 2 suppressed: function cannot be solved config_file_get (automatic due to inconsistent arc counts in .gcda files) int error = 0;
341 -
342 - 2-4 suppressed: function cannot be solved config_file_get (automatic due to inconsistent arc counts in .gcda files) if (!h->parent.readonly && ((error = config_file_refresh(cfg)) < 0))
343 - 5 suppressed: function cannot be solved config_file_get (automatic due to inconsistent arc counts in .gcda files) return error;
344 -
345 - 6,7 suppressed: function cannot be solved config_file_get (automatic due to inconsistent arc counts in .gcda files) if ((error = config_file_entries_take(&entries, h)) < 0)
346 - 8 suppressed: function cannot be solved config_file_get (automatic due to inconsistent arc counts in .gcda files) return error;
347 -
348 - 9,10 suppressed: function cannot be solved config_file_get (automatic due to inconsistent arc counts in .gcda files) if ((error = (git_config_entries_get(&entry, entries, key))) < 0) {
349 - 11 suppressed: function cannot be solved config_file_get (automatic due to inconsistent arc counts in .gcda files) git_config_entries_free(entries);
350 - 12 suppressed: function cannot be solved config_file_get (automatic due to inconsistent arc counts in .gcda files) return error;
351 - }
352 -
353 - 13 suppressed: function cannot be solved config_file_get (automatic due to inconsistent arc counts in .gcda files) entry->free = config_file_entry_free;
354 - 13 suppressed: function cannot be solved config_file_get (automatic due to inconsistent arc counts in .gcda files) entry->payload = entries;
355 - 13 suppressed: function cannot be solved config_file_get (automatic due to inconsistent arc counts in .gcda files) *out = entry;
356 -
357 - 13 suppressed: function cannot be solved config_file_get (automatic due to inconsistent arc counts in .gcda files) return 0;
358 - }
359 -
360 181 2 static int config_file_set_multivar(
361 - git_config_backend *cfg, const char *name, const char *regexp, const char *value)
362 - {
363 181 2 config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
364 - git_regexp preg;
365 - int result;
366 - char *key;
367 -
368 181 2,3 assert(regexp);
369 -
370 181 4,5 if ((result = git_config__normalize_name(name, &key)) < 0)
371 9 6 return result;
372 -
373 172 7,8 if ((result = git_regexp_compile(&preg, regexp, 0)) < 0)
374 ##### 9 goto out;
375 -
376 - /* If we do have it, set call config_file_write() and reload */
377 172 10,11 if ((result = config_file_write(b, name, key, &preg, value)) < 0)
378 ##### 12 goto out;
379 -
380 - out:
381 172 13 git__free(key);
382 172 14 git_regexp_dispose(&preg);
383 -
384 172 15 return result;
385 - }
386 -
387 5691 2 static int config_file_delete(git_config_backend *cfg, const char *name)
388 - {
389 5691 2 config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
390 5691 2 git_config_entries *entries = NULL;
391 - git_config_entry *entry;
392 5691 2 char *key = NULL;
393 - int error;
394 -
395 5691 2,3 if ((error = git_config__normalize_name(name, &key)) < 0)
396 9 4 goto out;
397 -
398 5682 5,6 if ((error = config_file_entries_take(&entries, b)) < 0)
399 ##### 7 goto out;
400 -
401 - /* Check whether we'd be modifying an included or multivar key */
402 5682 8,9 if ((error = git_config_entries_get_unique(&entry, entries, key)) < 0) {
403 3850 10 if (error == GIT_ENOTFOUND)
404 3849 11 git_error_set(GIT_ERROR_CONFIG, "could not find key '%s' to delete", name);
405 3850 12 goto out;
406 - }
407 -
408 1832 13,14 if ((error = config_file_write(b, name, entry->name, NULL, NULL)) < 0)
409 ##### 15 goto out;
410 -
411 - out:
412 5691 16 git_config_entries_free(entries);
413 5691 17 git__free(key);
414 5691 18 return error;
415 - }
416 -
417 5 2 static int config_file_delete_multivar(git_config_backend *cfg, const char *name, const char *regexp)
418 - {
419 5 2 config_file_backend *b = GIT_CONTAINER_OF(cfg, config_file_backend, parent);
420 5 2 git_config_entries *entries = NULL;
421 5 2 git_config_entry *entry = NULL;
422 5 2 git_regexp preg = GIT_REGEX_INIT;
423 5 2 char *key = NULL;
424 - int result;
425 -
426 5 2,3 if ((result = git_config__normalize_name(name, &key)) < 0)
427 ##### 4 goto out;
428 -
429 5 5,6 if ((result = config_file_entries_take(&entries, b)) < 0)
430 ##### 7 goto out;
431 -
432 5 8,9 if ((result = git_config_entries_get(&entry, entries, key)) < 0) {
433 1 10 if (result == GIT_ENOTFOUND)
434 1 11 git_error_set(GIT_ERROR_CONFIG, "could not find key '%s' to delete", name);
435 1 12 goto out;
436 - }
437 -
438 4 13,14 if ((result = git_regexp_compile(&preg, regexp, 0)) < 0)
439 ##### 15 goto out;
440 -
441 4 16,17 if ((result = config_file_write(b, name, key, &preg, NULL)) < 0)
442 ##### 18 goto out;
443 -
444 - out:
445 5 19 git_config_entries_free(entries);
446 5 20 git__free(key);
447 5 21 git_regexp_dispose(&preg);
448 5 22 return result;
449 - }
450 -
451 2 2 static int config_file_lock(git_config_backend *_cfg)
452 - {
453 2 2 config_file_backend *cfg = GIT_CONTAINER_OF(_cfg, config_file_backend, parent);
454 - int error;
455 -
456 2 2,3 if ((error = git_filebuf_open(&cfg->locked_buf, cfg->file.path, 0, GIT_CONFIG_FILE_MODE)) < 0)
457 ##### 4 return error;
458 -
459 2 5 error = git_futils_readbuffer(&cfg->locked_content, cfg->file.path);
460 2 6,7 if (error < 0 && error != GIT_ENOTFOUND) {
461 ##### 8 git_filebuf_cleanup(&cfg->locked_buf);
462 ##### 9 return error;
463 - }
464 -
465 2 10 cfg->locked = true;
466 2 10 return 0;
467 -
468 - }
469 -
470 2 2 static int config_file_unlock(git_config_backend *_cfg, int success)
471 - {
472 2 2 config_file_backend *cfg = GIT_CONTAINER_OF(_cfg, config_file_backend, parent);
473 2 2 int error = 0;
474 -
475 2 2 if (success) {
476 2 3 git_filebuf_write(&cfg->locked_buf, cfg->locked_content.ptr, cfg->locked_content.size);
477 2 4 error = git_filebuf_commit(&cfg->locked_buf);
478 - }
479 -
480 2 5 git_filebuf_cleanup(&cfg->locked_buf);
481 2 6 git_buf_dispose(&cfg->locked_content);
482 2 7 cfg->locked = false;
483 -
484 2 7 return error;
485 - }
486 -
487 15386 2 int git_config_backend_from_file(git_config_backend **out, const char *path)
488 - {
489 - config_file_backend *backend;
490 -
491 15386 2 backend = git__calloc(1, sizeof(config_file_backend));
492 15389 3,4 GIT_ERROR_CHECK_ALLOC(backend);
493 -
494 15389 5 backend->parent.version = GIT_CONFIG_BACKEND_VERSION;
495 15389 5 git_mutex_init(&backend->values_mutex);
496 -
497 15389 6 backend->file.path = git__strdup(path);
498 15389 7,8 GIT_ERROR_CHECK_ALLOC(backend->file.path);
499 15389 9 git_array_init(backend->file.includes);
500 -
501 15389 9 backend->parent.open = config_file_open;
502 15389 9 backend->parent.get = config_file_get;
503 15389 9 backend->parent.set = config_file_set;
504 15389 9 backend->parent.set_multivar = config_file_set_multivar;
505 15389 9 backend->parent.del = config_file_delete;
506 15389 9 backend->parent.del_multivar = config_file_delete_multivar;
507 15389 9 backend->parent.iterator = config_file_iterator;
508 15389 9 backend->parent.snapshot = config_file_snapshot;
509 15389 9 backend->parent.lock = config_file_lock;
510 15389 9 backend->parent.unlock = config_file_unlock;
511 15389 9 backend->parent.free = config_file_free;
512 -
513 15389 9 *out = (git_config_backend *)backend;
514 -
515 15389 9 return 0;
516 - }
517 -
518 155 2 static int included_path(git_buf *out, const char *dir, const char *path)
519 - {
520 - /* From the user's home */
521 155 2,3 if (path[0] == '~' && path[1] == '/')
522 2 4 return git_sysdir_expand_global_file(out, &path[1]);
523 -
524 153 5 return git_path_join_unrooted(out, path, dir, NULL);
525 - }
526 -
527 - /* Escape the values to write them to the file */
528 2951 2 static char *escape_value(const char *ptr)
529 - {
530 - git_buf buf;
531 - size_t len;
532 - const char *esc;
533 -
534 2951 2,3 assert(ptr);
535 -
536 2951 4 len = strlen(ptr);
537 2951 4 if (!len)
538 2 5 return git__calloc(1, sizeof(char));
539 -
540 2949 6,7 if (git_buf_init(&buf, len) < 0)
541 ##### 8 return NULL;
542 -
543 27646 9,15 while (*ptr != '\0') {
544 24697 10 if ((esc = strchr(git_config_escaped, *ptr)) != NULL) {
545 15 11 git_buf_putc(&buf, '\\');
546 15 12 git_buf_putc(&buf, git_config_escapes[esc - git_config_escaped]);
547 - } else {
548 24682 13 git_buf_putc(&buf, *ptr);
549 - }
550 24697 14 ptr++;
551 - }
552 -
553 2949 16,17 if (git_buf_oom(&buf))
554 ##### 18 return NULL;
555 -
556 2949 19 return git_buf_detach(&buf);
557 - }
558 -
559 156 2 static int parse_include(config_file_parse_data *parse_data, const char *file)
560 - {
561 - config_file *include;
562 156 2 git_buf path = GIT_BUF_INIT;
563 - char *dir;
564 - int result;
565 -
566 156 2 if (!file)
567 1 3 return 0;
568 -
569 155 4,5 if ((result = git_path_dirname_r(&path, parse_data->file->path)) < 0)
570 ##### 6 return result;
571 -
572 155 7 dir = git_buf_detach(&path);
573 155 8 result = included_path(&path, dir, file);
574 155 9 git__free(dir);
575 -
576 155 10 if (result < 0)
577 ##### 11 return result;
578 -
579 155 12-17 include = git_array_alloc(parse_data->file->includes);
580 155 18,19 GIT_ERROR_CHECK_ALLOC(include);
581 155 20 memset(include, 0, sizeof(*include));
582 155 20 git_array_init(include->includes);
583 155 20 include->path = git_buf_detach(&path);
584 -
585 155 21 result = config_file_read(parse_data->entries, parse_data->repo, include,
586 155 21 parse_data->level, parse_data->depth+1);
587 -
588 155 22 if (result == GIT_ENOTFOUND) {
589 2 23 git_error_clear();
590 2 24 result = 0;
591 - }
592 -
593 155 25 return result;
594 - }
595 -
596 26 2 static int do_match_gitdir(
597 - int *matches,
598 - const git_repository *repo,
599 - const char *cfg_file,
600 - const char *condition,
601 - bool case_insensitive)
602 - {
603 26 2 git_buf pattern = GIT_BUF_INIT, gitdir = GIT_BUF_INIT;
604 - int error;
605 -
606 26 2,3 if (condition[0] == '.' && git_path_is_dirsep(condition[1])) {
607 1 4 git_path_dirname_r(&pattern, cfg_file);
608 1 5 git_buf_joinpath(&pattern, pattern.ptr, condition + 2);
609 25 6,7 } else if (condition[0] == '~' && git_path_is_dirsep(condition[1]))
610 1 8 git_sysdir_expand_global_file(&pattern, condition + 1);
611 24 9 else if (!git_path_is_absolute(condition))
612 11 10 git_buf_joinpath(&pattern, "**", condition);
613 - else
614 13 11 git_buf_sets(&pattern, condition);
615 -
616 26 12 if (git_path_is_dirsep(condition[strlen(condition) - 1]))
617 14 13 git_buf_puts(&pattern, "**");
618 -
619 26 14,15 if (git_buf_oom(&pattern)) {
620 ##### 16 error = -1;
621 ##### 16 goto out;
622 - }
623 -
624 26 17,18 if ((error = git_repository_item_path(&gitdir, repo, GIT_REPOSITORY_ITEM_GITDIR)) < 0)
625 ##### 19 goto out;
626 -
627 26 20 if (git_path_is_dirsep(gitdir.ptr[gitdir.size - 1]))
628 26 21 git_buf_truncate(&gitdir, gitdir.size - 1);
629 -
630 26 22,23 *matches = wildmatch(pattern.ptr, gitdir.ptr,
631 26 22,23 WM_PATHNAME | (case_insensitive ? WM_CASEFOLD : 0)) == WM_MATCH;
632 - out:
633 26 24 git_buf_dispose(&pattern);
634 26 25 git_buf_dispose(&gitdir);
635 26 26 return error;
636 - }
637 -
638 24 2 static int conditional_match_gitdir(
639 - int *matches,
640 - const git_repository *repo,
641 - const char *cfg_file,
642 - const char *value)
643 - {
644 24 2 return do_match_gitdir(matches, repo, cfg_file, value, false);
645 - }
646 -
647 2 2 static int conditional_match_gitdir_i(
648 - int *matches,
649 - const git_repository *repo,
650 - const char *cfg_file,
651 - const char *value)
652 - {
653 2 2 return do_match_gitdir(matches, repo, cfg_file, value, true);
654 - }
655 -
656 24 2 static int conditional_match_onbranch(
657 - int *matches,
658 - const git_repository *repo,
659 - const char *cfg_file,
660 - const char *condition)
661 - {
662 24 2 git_buf reference = GIT_BUF_INIT, buf = GIT_BUF_INIT;
663 - int error;
664 -
665 - GIT_UNUSED(cfg_file);
666 -
667 - /*
668 - * NOTE: you cannot use `git_repository_head` here. Looking up the
669 - * HEAD reference will create the ODB, which causes us to read the
670 - * repo's config for keys like core.precomposeUnicode. As we're
671 - * just parsing the config right now, though, this would result in
672 - * an endless recursion.
673 - */
674 -
675 24 2-6 if ((error = git_buf_joinpath(&buf, git_repository_path(repo), GIT_HEAD_FILE)) < 0 ||
676 24 5 (error = git_futils_readbuffer(&reference, buf.ptr)) < 0)
677 - goto out;
678 24 7 git_buf_rtrim(&reference);
679 -
680 24 8 if (git__strncmp(reference.ptr, GIT_SYMREF, strlen(GIT_SYMREF)))
681 ##### 9 goto out;
682 24 10 git_buf_consume(&reference, reference.ptr + strlen(GIT_SYMREF));
683 -
684 24 11 if (git__strncmp(reference.ptr, GIT_REFS_HEADS_DIR, strlen(GIT_REFS_HEADS_DIR)))
685 ##### 12 goto out;
686 24 13 git_buf_consume(&reference, reference.ptr + strlen(GIT_REFS_HEADS_DIR));
687 -
688 - /*
689 - * If the condition ends with a '/', then we should treat it as if
690 - * it had '**' appended.
691 - */
692 24 14,15 if ((error = git_buf_sets(&buf, condition)) < 0)
693 ##### 16 goto out;
694 24 17-19 if (git_path_is_dirsep(condition[strlen(condition) - 1]) &&
695 - (error = git_buf_puts(&buf, "**")) < 0)
696 ##### 20 goto out;
697 -
698 24 21,22 *matches = wildmatch(buf.ptr, reference.ptr, WM_PATHNAME) == WM_MATCH;
699 - out:
700 24 23 git_buf_dispose(&reference);
701 24 24 git_buf_dispose(&buf);
702 -
703 24 25 return error;
704 -
705 - }
706 -
707 - static const struct {
708 - const char *prefix;
709 - int (*matches)(int *matches, const git_repository *repo, const char *cfg, const char *value);
710 - } conditions[] = {
711 - { "gitdir:", conditional_match_gitdir },
712 - { "gitdir/i:", conditional_match_gitdir_i },
713 - { "onbranch:", conditional_match_onbranch }
714 - };
715 -
716 51 2 static int parse_conditional_include(config_file_parse_data *parse_data, const char *section, const char *file)
717 - {
718 - char *condition;
719 - size_t i;
720 51 2 int error = 0, matches;
721 -
722 51 2,3 if (!parse_data->repo || !file)
723 ##### 4 return 0;
724 -
725 51 5 condition = git__substrdup(section + strlen("includeIf."),
726 - strlen(section) - strlen("includeIf.") - strlen(".path"));
727 -
728 104 6,9,16 for (i = 0; i < ARRAY_SIZE(conditions); i++) {
729 103 7,8 if (git__prefixcmp(condition, conditions[i].prefix))
730 53 9 continue;
731 -
732 50 10,10,10,11 if ((error = conditions[i].matches(&matches,
733 - parse_data->repo,
734 50 10 parse_data->file->path,
735 50 10 condition + strlen(conditions[i].prefix))) < 0)
736 ##### 12 break;
737 -
738 50 13 if (matches)
739 27 14 error = parse_include(parse_data, file);
740 -
741 50 15 break;
742 - }
743 -
744 51 17 git__free(condition);
745 51 18 return error;
746 - }
747 -
748 98029 2 static int read_on_variable(
749 - git_config_parser *reader,
750 - const char *current_section,
751 - const char *var_name,
752 - const char *var_value,
753 - const char *line,
754 - size_t line_len,
755 - void *data)
756 - {
757 98029 2 config_file_parse_data *parse_data = (config_file_parse_data *)data;
758 98029 2 git_buf buf = GIT_BUF_INIT;
759 - git_config_entry *entry;
760 - const char *c;
761 98029 2 int result = 0;
762 -
763 - GIT_UNUSED(reader);
764 - GIT_UNUSED(line);
765 - GIT_UNUSED(line_len);
766 -
767 98029 2 if (current_section) {
768 - /* TODO: Once warnings lang, we should likely warn
769 - * here. Git appears to warn in most cases if it sees
770 - * un-namespaced config options.
771 - */
772 98027 3 git_buf_puts(&buf, current_section);
773 98025 4 git_buf_putc(&buf, '.');
774 - }
775 -
776 888148 5,7,8 for (c = var_name; *c; c++)
777 790134 6 git_buf_putc(&buf, git__tolower(*c));
778 -
779 98014 9,10 if (git_buf_oom(&buf))
780 ##### 11 return -1;
781 -
782 98011 12 entry = git__calloc(1, sizeof(git_config_entry));
783 98034 13,14 GIT_ERROR_CHECK_ALLOC(entry);
784 98034 15 entry->name = git_buf_detach(&buf);
785 98027 16-18 entry->value = var_value ? git__strdup(var_value) : NULL;
786 98032 19 entry->level = parse_data->level;
787 98032 19 entry->include_depth = parse_data->depth;
788 -
789 98033 19,20 if ((result = git_config_entries_append(parse_data->entries, entry)) < 0)
790 ##### 21 return result;
791 -
792 98033 22 result = 0;
793 -
794 - /* Add or append the new config option */
795 98033 22 if (!git__strcmp(entry->name, "include.path"))
796 129 23 result = parse_include(parse_data, entry->value);
797 97904 24,25,27 else if (!git__prefixcmp(entry->name, "includeif.") &&
798 51 26 !git__suffixcmp(entry->name, ".path"))
799 51 28 result = parse_conditional_include(parse_data, entry->name, entry->value);
800 -
801 98033 29 return result;
802 - }
803 -
804 18707 2 static int config_file_read_buffer(
805 - git_config_entries *entries,
806 - const git_repository *repo,
807 - config_file *file,
808 - git_config_level_t level,
809 - int depth,
810 - const char *buf,
811 - size_t buflen)
812 - {
813 - config_file_parse_data parse_data;
814 - git_config_parser reader;
815 - int error;
816 -
817 18707 2 if (depth >= MAX_INCLUDE_DEPTH) {
818 1 3 git_error_set(GIT_ERROR_CONFIG, "maximum config include depth reached");
819 1 4 return -1;
820 - }
821 -
822 - /* Initialize the reading position */
823 18706 5 reader.path = file->path;
824 18706 5 git_parse_ctx_init(&reader.ctx, buf, buflen);
825 -
826 - /* If the file is empty, there's nothing for us to do */
827 18708 6,7 if (!reader.ctx.content || *reader.ctx.content == '\0') {
828 404 8 error = 0;
829 404 8 goto out;
830 - }
831 -
832 18304 9 parse_data.repo = repo;
833 18304 9 parse_data.file = file;
834 18304 9 parse_data.entries = entries;
835 18304 9 parse_data.level = level;
836 18304 9 parse_data.depth = depth;
837 -
838 18304 9 error = git_config_parse(&reader, NULL, read_on_variable, NULL, NULL, &parse_data);
839 -
840 - out:
841 18709 10 return error;
842 - }
843 -
844 14050 2 static int config_file_read(
845 - git_config_entries *entries,
846 - const git_repository *repo,
847 - config_file *file,
848 - git_config_level_t level,
849 - int depth)
850 - {
851 14050 2 git_buf contents = GIT_BUF_INIT;
852 - struct stat st;
853 - int error;
854 -
855 14051 2,3 if (p_stat(file->path, &st) < 0) {
856 2 4,5 error = git_path_set_error(errno, file->path, "stat");
857 2 6 goto out;
858 - }
859 -
860 14049 7,8 if ((error = git_futils_readbuffer(&contents, file->path)) < 0)
861 ##### 9 goto out;
862 -
863 14048 10 git_futils_filestamp_set_from_stat(&file->stamp, &st);
864 14049 11,12 if ((error = git_hash_buf(&file->checksum, contents.ptr, contents.size)) < 0)
865 ##### 13 goto out;
866 -
867 14049 14,14,15 if ((error = config_file_read_buffer(entries, repo, file, level, depth,
868 14046 14 contents.ptr, contents.size)) < 0)
869 27 16 goto out;
870 -
871 - out:
872 14051 17 git_buf_dispose(&contents);
873 14048 18 return error;
874 - }
875 -
876 850 2 static int write_section(git_buf *fbuf, const char *key)
877 - {
878 - int result;
879 - const char *dot;
880 850 2 git_buf buf = GIT_BUF_INIT;
881 -
882 - /* All of this just for [section "subsection"] */
883 850 2 dot = strchr(key, '.');
884 850 2 git_buf_putc(&buf, '[');
885 850 3 if (dot == NULL) {
886 556 4 git_buf_puts(&buf, key);
887 - } else {
888 - char *escaped;
889 294 5 git_buf_put(&buf, key, dot - key);
890 294 6 escaped = escape_value(dot + 1);
891 294 7,8 GIT_ERROR_CHECK_ALLOC(escaped);
892 294 9 git_buf_printf(&buf, " \"%s\"", escaped);
893 294 10 git__free(escaped);
894 - }
895 850 11 git_buf_puts(&buf, "]\n");
896 -
897 850 12,13 if (git_buf_oom(&buf))
898 ##### 14 return -1;
899 -
900 850 15,16 result = git_buf_put(fbuf, git_buf_cstr(&buf), buf.size);
901 850 17 git_buf_dispose(&buf);
902 -
903 850 18 return result;
904 - }
905 -
906 2830 2 static const char *quotes_for_value(const char *value)
907 - {
908 - const char *ptr;
909 -
910 2830 2,3 if (value[0] == ' ' || value[0] == '\0')
911 4 4 return "\"";
912 -
913 31183 5,9,10 for (ptr = value; *ptr; ++ptr) {
914 28359 6,7 if (*ptr == ';' || *ptr == '#')
915 2 8 return "\"";
916 - }
917 -
918 2824 11 if (ptr[-1] == ' ')
919 1 12 return "\"";
920 -
921 2823 13 return "";
922 - }
923 -
924 - struct write_data {
925 - git_buf *buf;
926 - git_buf buffered_comment;
927 - unsigned int in_section : 1,
928 - preg_replaced : 1;
929 - const char *orig_section;
930 - const char *section;
931 - const char *orig_name;
932 - const char *name;
933 - const git_regexp *preg;
934 - const char *value;
935 - };
936 -
937 34137 2 static int write_line_to(git_buf *buf, const char *line, size_t line_len)
938 - {
939 34137 2 int result = git_buf_put(buf, line, line_len);
940 -
941 34137 3-5 if (!result && line_len && line[line_len-1] != '\n')
942 3 6 result = git_buf_printf(buf, "\n");
943 -
944 34137 7 return result;
945 - }
946 -
947 33919 2 static int write_line(struct write_data *write_data, const char *line, size_t line_len)
948 - {
949 33919 2 return write_line_to(write_data->buf, line, line_len);
950 - }
951 -
952 2830 2 static int write_value(struct write_data *write_data)
953 - {
954 - const char *q;
955 - int result;
956 -
957 2830 2 q = quotes_for_value(write_data->value);
958 2830 3 result = git_buf_printf(write_data->buf,
959 - "\t%s = %s%s%s\n", write_data->orig_name, q, write_data->value, q);
960 -
961 - /* If we are updating a single name/value, we're done. Setting `value`
962 - * to `NULL` will prevent us from trying to write it again later (in
963 - * `write_on_section`) if we see the same section repeated.
964 - */
965 2830 4 if (!write_data->preg)
966 2656 5 write_data->value = NULL;
967 -
968 2830 6 return result;
969 - }
970 -
971 9423 2 static int write_on_section(
972 - git_config_parser *reader,
973 - const char *current_section,
974 - const char *line,
975 - size_t line_len,
976 - void *data)
977 - {
978 9423 2 struct write_data *write_data = (struct write_data *)data;
979 9423 2 int result = 0;
980 -
981 - GIT_UNUSED(reader);
982 -
983 - /* If we were previously in the correct section (but aren't anymore)
984 - * and haven't written our value (for a simple name/value set, not
985 - * a multivar), then append it to the end of the section before writing
986 - * the new one.
987 - */
988 9423 2-4 if (write_data->in_section && !write_data->preg && write_data->value)
989 56 5 result = write_value(write_data);
990 -
991 9423 6 write_data->in_section = strcmp(current_section, write_data->section) == 0;
992 -
993 - /*
994 - * If there were comments just before this section, dump them as well.
995 - */
996 9423 6 if (!result) {
997 9423 7 result = git_buf_put(write_data->buf, write_data->buffered_comment.ptr, write_data->buffered_comment.size);
998 9423 8 git_buf_clear(&write_data->buffered_comment);
999 - }
1000 -
1001 9423 9 if (!result)
1002 9423 10 result = write_line(write_data, line, line_len);
1003 -
1004 9423 11 return result;
1005 - }
1006 -
1007 26746 2 static int write_on_variable(
1008 - git_config_parser *reader,
1009 - const char *current_section,
1010 - const char *var_name,
1011 - const char *var_value,
1012 - const char *line,
1013 - size_t line_len,
1014 - void *data)
1015 - {
1016 26746 2 struct write_data *write_data = (struct write_data *)data;
1017 26746 2 bool has_matched = false;
1018 - int error;
1019 -
1020 - GIT_UNUSED(reader);
1021 - GIT_UNUSED(current_section);
1022 -
1023 - /*
1024 - * If there were comments just before this variable, let's dump them as well.
1025 - */
1026 26746 2,3 if ((error = git_buf_put(write_data->buf, write_data->buffered_comment.ptr, write_data->buffered_comment.size)) < 0)
1027 ##### 4 return error;
1028 -
1029 26746 5 git_buf_clear(&write_data->buffered_comment);
1030 -
1031 - /* See if we are to update this name/value pair; first examine name */
1032 26746 6,7 if (write_data->in_section &&
1033 15729 7 strcasecmp(write_data->name, var_name) == 0)
1034 2265 8 has_matched = true;
1035 -
1036 - /* If we have a regex to match the value, see if it matches */
1037 26746 9,10 if (has_matched && write_data->preg != NULL)
1038 27 11,12 has_matched = (git_regexp_match(write_data->preg, var_value) == 0);
1039 -
1040 - /* If this isn't the name/value we're looking for, simply dump the
1041 - * existing data back out and continue on.
1042 - */
1043 26746 13 if (!has_matched)
1044 24496 14 return write_line(write_data, line, line_len);
1045 -
1046 2250 15 write_data->preg_replaced = 1;
1047 -
1048 - /* If value is NULL, we are deleting this value; write nothing. */
1049 2250 15 if (!write_data->value)
1050 1841 16 return 0;
1051 -
1052 409 17 return write_value(write_data);
1053 - }
1054 -
1055 218 2 static int write_on_comment(git_config_parser *reader, const char *line, size_t line_len, void *data)
1056 - {
1057 - struct write_data *write_data;
1058 -
1059 - GIT_UNUSED(reader);
1060 -
1061 218 2 write_data = (struct write_data *)data;
1062 218 2 return write_line_to(&write_data->buffered_comment, line, line_len);
1063 - }
1064 -
1065 4664 2 static int write_on_eof(
1066 - git_config_parser *reader, const char *current_section, void *data)
1067 - {
1068 4664 2 struct write_data *write_data = (struct write_data *)data;
1069 4664 2 int result = 0;
1070 -
1071 - GIT_UNUSED(reader);
1072 -
1073 - /*
1074 - * If we've buffered comments when reaching EOF, make sure to dump them.
1075 - */
1076 4664 2,3 if ((result = git_buf_put(write_data->buf, write_data->buffered_comment.ptr, write_data->buffered_comment.size)) < 0)
1077 ##### 4 return result;
1078 -
1079 - /* If we are at the EOF and have not written our value (again, for a
1080 - * simple name/value set, not a multivar) then we have never seen the
1081 - * section in question and should create a new section and write the
1082 - * value.
1083 - */
1084 4664 5-7 if ((!write_data->preg || !write_data->preg_replaced) && write_data->value) {
1085 - /* write the section header unless we're already in it */
1086 2365 8,9 if (!current_section || strcmp(current_section, write_data->section))
1087 850 10 result = write_section(write_data->buf, write_data->orig_section);
1088 -
1089 2365 11 if (!result)
1090 2365 12 result = write_value(write_data);
1091 - }
1092 -
1093 4664 13 return result;
1094 - }
1095 -
1096 - /*
1097 - * This is pretty much the parsing, except we write out anything we don't have
1098 - */
1099 4665 2 static int config_file_write(config_file_backend *cfg, const char *orig_key, const char *key, const git_regexp *preg, const char* value)
1100 -
1101 - {
1102 4665 2 char *orig_section = NULL, *section = NULL, *orig_name, *name, *ldot;
1103 4665 2 git_buf buf = GIT_BUF_INIT, contents = GIT_BUF_INIT;
1104 4665 2 git_config_parser parser = GIT_CONFIG_PARSER_INIT;
1105 4665 2 git_filebuf file = GIT_FILEBUF_INIT;
1106 - struct write_data write_data;
1107 - int error;
1108 -
1109 4665 2 memset(&write_data, 0, sizeof(write_data));
1110 -
1111 4665 2 if (cfg->locked) {
1112 3 3-7 error = git_buf_puts(&contents, git_buf_cstr(&cfg->locked_content) == NULL ? "" : git_buf_cstr(&cfg->locked_content));
1113 - } else {
1114 4662 8,9 if ((error = git_filebuf_open(&file, cfg->file.path, GIT_FILEBUF_HASH_CONTENTS,
1115 - GIT_CONFIG_FILE_MODE)) < 0)
1116 1 10 goto done;
1117 -
1118 - /* We need to read in our own config file */
1119 4661 11 error = git_futils_readbuffer(&contents, cfg->file.path);
1120 - }
1121 4664 12,13 if (error < 0 && error != GIT_ENOTFOUND)
1122 ##### 14 goto done;
1123 -
1124 4664 15,16 if ((git_config_parser_init(&parser, cfg->file.path, contents.ptr, contents.size)) < 0)
1125 ##### 17 goto done;
1126 -
1127 4664 18 ldot = strrchr(key, '.');
1128 4664 18 name = ldot + 1;
1129 4664 18 section = git__strndup(key, ldot - key);
1130 4664 19,20 GIT_ERROR_CHECK_ALLOC(section);
1131 -
1132 4664 21 ldot = strrchr(orig_key, '.');
1133 4664 21 orig_name = ldot + 1;
1134 4664 21 orig_section = git__strndup(orig_key, ldot - orig_key);
1135 4664 22,23 GIT_ERROR_CHECK_ALLOC(orig_section);
1136 -
1137 4664 24 write_data.buf = &buf;
1138 4664 24 write_data.orig_section = orig_section;
1139 4664 24 write_data.section = section;
1140 4664 24 write_data.orig_name = orig_name;
1141 4664 24 write_data.name = name;
1142 4664 24 write_data.preg = preg;
1143 4664 24 write_data.value = value;
1144 -
1145 4664 24,25 if ((error = git_config_parse(&parser, write_on_section, write_on_variable,
1146 - write_on_comment, write_on_eof, &write_data)) < 0)
1147 ##### 26 goto done;
1148 -
1149 4664 27 if (cfg->locked) {
1150 3 28 size_t len = buf.asize;
1151 - /* Update our copy with the modified contents */
1152 3 28 git_buf_dispose(&cfg->locked_content);
1153 3 29,30 git_buf_attach(&cfg->locked_content, git_buf_detach(&buf), len);
1154 - } else {
1155 4661 31-33 git_filebuf_write(&file, git_buf_cstr(&buf), git_buf_len(&buf));
1156 -
1157 4661 34,35 if ((error = git_filebuf_commit(&file)) < 0)
1158 ##### 36 goto done;
1159 -
1160 4661 37,38 if ((error = config_file_refresh_from_buffer(&cfg->parent, buf.ptr, buf.size)) < 0)
1161 ##### 39 goto done;
1162 - }
1163 -
1164 - done:
1165 4665 40 git__free(section);
1166 4665 41 git__free(orig_section);
1167 4665 42 git_buf_dispose(&write_data.buffered_comment);
1168 4665 43 git_buf_dispose(&buf);
1169 4665 44 git_buf_dispose(&contents);
1170 4665 45 git_filebuf_cleanup(&file);
1171 4665 46 git_config_parser_dispose(&parser);
1172 -
1173 4665 47 return error;
1174 - }