source/shared.hrev: ebedc6851e (latest)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

/*
 * The helpers that more than one file needs. Repository registration and thin
 * wrappers over git's diff machinery make up most of it, beside a few string
 * and request checks. The two process-wide globals, ctx and cgit_repolist,
 * are defined here as well.
 */

#ifndef CGIT_SHARED_H
#define CGIT_SHARED_H

#include "cgit.h"

extern char cgit_default_repo_desc[];

typedef void (*filepair_fn)(struct diff_filepair *pair);
typedef void (*linediff_fn)(char *line, int len);

/*
 * Append a repository to cgit_repolist and return it, seeded from the current
 * global configuration. The returned pointer is invalidated by the next call,
 * because the list grows by reallocation.
 */
extern struct cgit_repo *cgit_add_repo(const char *url);
extern struct cgit_repo *cgit_get_repoinfo(const char *url);

/*
 * A diff format callback that hands each filepair to the filepair_fn data
 * points at, or only the pair landing on single_follow when that is set. ISO
 * C has no conversion between a function pointer and void *, so the function
 * travels by address.
 */
extern void cgit_diff_tree_cb(struct diff_queue_struct *q, struct diff_options *options, void *data);

/*
 * Diff two blobs and hand fn one line at a time. Returns non-zero when either
 * blob could not be read. A blob that is binary or larger than max-blob-size
 * sets binary instead, and produces no lines, so the caller can offer a link
 * in place of the content.
 */
extern int cgit_diff_files(const struct object_id *old_oid, const struct object_id *new_oid,
	size_t *old_size, size_t *new_size, int *binary, int context, int ignorews,
	linediff_fn fn);

/*
 * Limit a diff to the paths below prefix, which is taken literally.
 */
extern void cgit_diff_limit_path(struct diff_options *opt, const char *prefix);

/*
 * Limit a diff to path and to source, the name it was renamed from, both
 * taken literally, with rename detection on so that git pairs the two.
 */
extern void cgit_diff_limit_rename(struct diff_options *opt, const char *path, const char *source);

/*
 * The name path had in the old tree when the change between the two trees
 * renamed it, or NULL when path is no renamed file's new name. The result is
 * the caller's to free.
 */
extern char *cgit_rename_source(const struct object_id *old_oid, const struct object_id *new_oid,
	const char *path);

/*
 * Hand fn each filepair between the two trees, limited to the paths below
 * prefix when one is given. A prefix naming a file the old tree lacks still
 * comes back as the rename that produced it.
 */
extern void cgit_diff_tree(const struct object_id *old_oid, const struct object_id *new_oid,
	filepair_fn fn, const char *prefix, int ignorews);
extern void cgit_diff_commit(struct commit *commit, filepair_fn fn, const char *prefix);

/*
 * Whether a blob of size bytes is past max-blob-size. Callers ask before
 * reading the object, so a huge blob stays out of memory rather than being
 * noticed once it is already there.
 */
extern int cgit_blob_too_large(size_t size);

/*
 * Point ps at item alone, set to match path literally rather than as a glob,
 * or at no item when path is NULL, which leaves every path matching.
 */
extern void cgit_literal_pathspec(struct pathspec *ps, struct pathspec_item *item, const char *path);

/*
 * Copy str without its trailing runs of c, returning NULL if nothing is left.
 */
extern char *cgit_trim_end(const char *str, char c);

/*
 * Read the first line of a file into a newly allocated, zero terminated
 * buffer. Returns 0 on success and an errno value otherwise.
 */
extern int cgit_read_first_line(const char *path, char **buf);
extern char *cgit_strdup_first_line(const char *text);

/*
 * Give a repository that cgitrc left without a description the first line of
 * the description file git keeps in it, unless that is still git's
 * placeholder. Pages call it only for the repositories they show, so a request
 * reads no more of these files than it needs.
 */
extern void cgit_read_repo_desc(struct cgit_repo *repo);

/*
 * How many bytes the UTF-8 sequence at p holds, or 0 when it is invalid,
 * looking at most left bytes ahead.
 */
extern size_t cgit_utf8_seq_len(const unsigned char *p, size_t left);

/*
 * Replace every byte of text that is not part of a valid UTF-8 sequence with
 * a question mark, in place.
 */
extern void cgit_utf8_sanitize(char *text);

/*
 * Replace every $token in text with the matching environment variable. The
 * result is a static buffer, so a caller that needs to keep it must copy it.
 */
extern char *cgit_expand_macros(const char *text);

/*
 * Whether a readme setting names a file tracked in the repository, written
 * as ref:path or :path, rather than a file on the server's disk.
 */
extern int cgit_readme_is_tracked(const char *readme);

/*
 * Whether a revision from the request is a hex object id or a possible ref
 * name, the only forms cgit hands to git.
 */
extern int cgit_valid_rev(const char *rev);

/*
 * Whether notes_ref names a tree, which is what a notes tree can be loaded
 * from. A ref pointing at anything else makes git die on loading it, and a
 * pusher can point one anywhere.
 */
extern int cgit_notes_ref_usable(const char *notes_ref);

#endif // CGIT_SHARED_H