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
143
144
145
146
147
148
149
150
151
152
153
154
155
|
/* ui-snapshot.c: generate snapshot of a commit
*
* Copyright (C) 2006 Lars Hjemli
*
* Licensed under GNU General Public License v2
* (see COPYING for full license text)
*/
#include "cgit.h"
static int write_compressed_tar_archive(struct archiver_args *args,const char *filter)
{
int rw[2];
pid_t gzpid;
int stdout2;
int status;
int rv;
stdout2 = chk_non_negative(dup(STDIN_FILENO), "Preserving STDOUT before compressing");
chk_zero(pipe(rw), "Opening pipe from compressor subprocess");
gzpid = chk_non_negative(fork(), "Forking compressor subprocess");
if(gzpid==0) {
/* child */
chk_zero(close(rw[1]), "Closing write end of pipe in child");
chk_zero(close(STDIN_FILENO), "Closing STDIN");
chk_non_negative(dup2(rw[0],STDIN_FILENO), "Redirecting compressor input to stdin");
execlp(filter,filter,NULL);
_exit(-1);
}
/* parent */
chk_zero(close(rw[0]), "Closing read end of pipe");
chk_non_negative(dup2(rw[1],STDOUT_FILENO), "Redirecting output to compressor");
rv = write_tar_archive(args);
chk_zero(close(STDOUT_FILENO), "Closing STDOUT redirected to compressor");
chk_non_negative(dup2(stdout2,STDOUT_FILENO), "Restoring uncompressed STDOUT");
chk_zero(close(stdout2), "Closing uncompressed STDOUT");
chk_zero(close(rw[1]), "Closing write end of pipe in parent");
chk_positive(waitpid(gzpid,&status,0), "Waiting on compressor process");
if(! ( WIFEXITED(status) && WEXITSTATUS(status)==0 ) )
cgit_print_error("Failed to compress archive");
return rv;
}
static int write_tar_gzip_archive(struct archiver_args *args)
{
return write_compressed_tar_archive(args,"gzip");
}
static int write_tar_bzip2_archive(struct archiver_args *args)
{
return write_compressed_tar_archive(args,"bzip2");
}
static const struct snapshot_archive_t {
const char *suffix;
const char *mimetype;
write_archive_fn_t write_func;
int bit;
} snapshot_archives[] = {
{ ".zip", "application/x-zip", write_zip_archive, 0x1 },
{ ".tar.gz", "application/x-tar", write_tar_gzip_archive, 0x2 },
{ ".tar.bz2", "application/x-tar", write_tar_bzip2_archive, 0x4 },
{ ".tar", "application/x-tar", write_tar_archive, 0x8 }
};
void cgit_print_snapshot(struct cacheitem *item, const char *head,
const char *hex, const char *prefix,
const char *filename, int snapshots)
{
int fnl = strlen(filename);
int f, n;
n = sizeof(snapshot_archives) / sizeof(*snapshot_archives);
for(f=0; f<n; f++) {
const struct snapshot_archive_t* sat = &snapshot_archives[f];
int sl;
if(!(snapshots & sat->bit))
continue;
sl = strlen(sat->suffix);
if(fnl<sl || strcmp(&filename[fnl-sl],sat->suffix))
continue;
struct archiver_args args;
struct commit *commit;
unsigned char sha1[20];
if (!hex)
hex = head;
if(get_sha1(hex, sha1)) {
cgit_print_error(fmt("Bad object id: %s", hex));
return;
}
commit = lookup_commit_reference(sha1);
if(!commit) {
cgit_print_error(fmt("Not a commit reference: %s", hex));
return;;
}
memset(&args,0,sizeof(args));
args.base = fmt("%s/", prefix);
args.tree = commit->tree;
cgit_print_snapshot_start(sat->mimetype, filename, item);
(*sat->write_func)(&args);
return;
}
cgit_print_error(fmt("Unsupported snapshot format: %s", filename));
}
void cgit_print_snapshot_links(const char *repo, const char *head,
const char *hex, int snapshots)
{
char *filename;
int f, n;
n = sizeof(snapshot_archives) / sizeof(*snapshot_archives);
for(f=0; f<n ;f++) {
const struct snapshot_archive_t* sat = &snapshot_archives[f];
if(!(snapshots & sat->bit))
continue;
filename = fmt("%s-%s%s", cgit_repobasename(repo), hex,
sat->suffix);
cgit_snapshot_link(filename, NULL, NULL, (char *)head,
(char *)hex, filename);
html("<br/>");
}
}
int cgit_parse_snapshots_mask(const char *str)
{
static const char *delim = " \t,:/|;";
int f, tl, rv = 0;
/* favor legacy setting */
if(atoi(str)) return 1;
for(;;) {
str += strspn(str,delim);
tl = strcspn(str,delim);
if(!tl)
break;
for(f=0;f<(sizeof(snapshot_archives)/sizeof(*snapshot_archives));++f) {
const struct snapshot_archive_t* sat = &snapshot_archives[f];
if(! ( strncmp(sat->suffix,str,tl) && strncmp(sat->suffix+1,str,tl-1) ) ) {
rv |= sat->bit;
break;
}
}
str += tl;
}
return rv;
}
/* vim:set sw=8: */
|
