Branch data Line data Source code
1 : : /*-
2 : : * Copyright (c) 2011-2013 Baptiste Daroussin <bapt@FreeBSD.org>
3 : : * Copyright (c) 2011-2012 Julien Laffaye <jlaffaye@FreeBSD.org>
4 : : * Copyright (c) 2013 Matthew Seaman <matthew@FreeBSD.org>
5 : : * All rights reserved.
6 : : *
7 : : * Redistribution and use in source and binary forms, with or without
8 : : * modification, are permitted provided that the following conditions
9 : : * are met:
10 : : * 1. Redistributions of source code must retain the above copyright
11 : : * notice, this list of conditions and the following disclaimer
12 : : * in this position and unchanged.
13 : : * 2. Redistributions in binary form must reproduce the above copyright
14 : : * notice, this list of conditions and the following disclaimer in the
15 : : * documentation and/or other materials provided with the distribution.
16 : : *
17 : : * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
18 : : * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19 : : * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 : : * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
21 : : * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22 : : * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 : : * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 : : * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 : : * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26 : : * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 : : */
28 : :
29 : : #include <assert.h>
30 : :
31 : : #include "pkg.h"
32 : : #include "private/event.h"
33 : : #include "private/pkg.h"
34 : :
35 : : /*
36 : : * Dep
37 : : */
38 : : void
39 : 499 : pkg_dep_free(struct pkg_dep *d)
40 : : {
41 [ + - ]: 499 : if (d == NULL)
42 : 0 : return;
43 : :
44 : 499 : free(d->origin);
45 : 499 : free(d->name);
46 : 499 : free(d->version);
47 : 499 : free(d->uid);
48 : 499 : free(d);
49 : 499 : }
50 : :
51 : : const char *
52 : 5 : pkg_dep_get(struct pkg_dep const * const d, const pkg_dep_attr attr)
53 : : {
54 [ + - ]: 5 : assert(d != NULL);
55 : :
56 [ - - + - ]: 5 : switch (attr) {
57 : : case PKG_DEP_NAME:
58 : 5 : return (d->name);
59 : : break;
60 : : case PKG_DEP_ORIGIN:
61 : 0 : return (d->origin);
62 : : break;
63 : : case PKG_DEP_VERSION:
64 : 0 : return (d->version);
65 : : break;
66 : : default:
67 : 0 : return (NULL);
68 : : break;
69 : : }
70 : 5 : }
71 : :
72 : : bool
73 : 0 : pkg_dep_is_locked(struct pkg_dep const * const d)
74 : : {
75 [ # # ]: 0 : assert(d != NULL);
76 : :
77 : 0 : return d->locked;
78 : : }
79 : :
80 : : /*
81 : : * File
82 : : */
83 : : void
84 : 827 : pkg_file_free(struct pkg_file *file)
85 : : {
86 : :
87 : 827 : free(file->sum);
88 : 827 : free(file);
89 : 827 : }
90 : :
91 : : /*
92 : : * Script
93 : : */
94 : :
95 : : const char *
96 : 11313 : pkg_script_get(struct pkg const * const p, pkg_script i)
97 : : {
98 [ + + ]: 11313 : if (p->scripts[i] == NULL)
99 : 11167 : return (NULL);
100 : :
101 : 146 : fflush(p->scripts[i]->fp);
102 : 146 : return (p->scripts[i]->buf);
103 : 11313 : }
104 : :
105 : : /*
106 : : * Option
107 : : */
108 : : void
109 : 184 : pkg_option_free(struct pkg_option *option)
110 : : {
111 [ + - ]: 184 : if (option == NULL)
112 : 0 : return;
113 : :
114 : 184 : free(option->key);
115 : 184 : free(option->value);
116 : 184 : free(option->default_value);
117 : 184 : free(option->description);
118 : 184 : free(option);
119 : 184 : }
120 : :
121 : : /*
122 : : * Conflicts
123 : : */
124 : : void
125 : 0 : pkg_conflict_free(struct pkg_conflict *c)
126 : : {
127 [ # # ]: 0 : if (c == NULL)
128 : 0 : return;
129 : :
130 : 0 : free(c->uid);
131 : 0 : free(c->digest);
132 : 0 : free(c);
133 : 0 : }
134 : :
135 : : /*
136 : : * Config files
137 : : */
138 : : void
139 : 46 : pkg_config_file_free(struct pkg_config_file *c)
140 : : {
141 [ + - ]: 46 : if (c == NULL)
142 : 0 : return;
143 : :
144 : 46 : free(c->content);
145 : 46 : free(c);
146 : 46 : }
147 : :
148 : :
149 : : /*
150 : : * kv
151 : : */
152 : :
153 : : struct pkg_kv *
154 : 2796 : pkg_kv_new(const char *key, const char *val)
155 : : {
156 : : struct pkg_kv *c;
157 : :
158 : 2796 : c = xcalloc(1, sizeof(struct pkg_kv));
159 : 2796 : c->key = xstrdup(key);
160 : 2796 : c->value = xstrdup(val);
161 : :
162 : 2796 : return (c);
163 : : }
164 : :
165 : : void
166 : 2722 : pkg_kv_free(struct pkg_kv *c)
167 : : {
168 [ + - ]: 2722 : if (c == NULL)
169 : 0 : return;
170 : :
171 : 2722 : free(c->key);
172 : 2722 : free(c->value);
173 : 2722 : free(c);
174 : 2722 : }
175 : :
176 : : struct pkg_kvlist_iterator *
177 : 8 : pkg_kvlist_iterator(struct pkg_kvlist *l)
178 : : {
179 : 8 : struct pkg_kvlist_iterator *it = xcalloc(1, sizeof(struct pkg_kvlist_iterator));
180 : 8 : it->list = l->list;
181 : 8 : return (it);
182 : : };
183 : :
184 : : struct pkg_kv *
185 : 17 : pkg_kvlist_next(struct pkg_kvlist_iterator *it)
186 : : {
187 [ + + ]: 17 : if (it->cur == NULL)
188 : 8 : it->cur = it->list->head;
189 : : else
190 : 9 : it->cur = ((__typeof__(it->list->head))it->cur)->next;
191 [ + + ]: 17 : if (it->cur == NULL)
192 : 2 : return (NULL);
193 : 15 : return (((__typeof__(it->list->head))it->cur)->item);
194 : 17 : }
195 : :
196 : : struct pkg_stringlist_iterator *
197 : 0 : pkg_stringlist_iterator(struct pkg_stringlist *l)
198 : : {
199 : 0 : struct pkg_stringlist_iterator *it = xcalloc(1, sizeof(struct pkg_stringlist_iterator));
200 : 0 : it->list = l->list;
201 : 0 : return (it);
202 : : };
203 : :
204 : : const char *
205 : 0 : pkg_stringlist_next(struct pkg_stringlist_iterator *it)
206 : : {
207 [ # # ]: 0 : if (it->cur == NULL)
208 : 0 : it->cur = it->list->head;
209 : : else
210 : 0 : it->cur = ((__typeof__(it->list->head))it->cur)->next;
211 [ # # ]: 0 : if (it->cur == NULL)
212 : 0 : return (NULL);
213 : 0 : return (((__typeof__(it->list->head))it->cur)->item);
214 : 0 : }
215 : :
216 : : struct pkg_el *
217 : 818 : pkg_get_element(struct pkg *p, pkg_attr a)
218 : : {
219 : 818 : struct pkg_el *e = xcalloc(1, sizeof(*e));
220 : :
221 [ - - - - : 818 : switch (a) {
- - - + -
- + + + +
+ + - + -
+ - - - -
+ - + - -
- - ]
222 : : case PKG_ATTR_NAME:
223 : 0 : e->string = p->name;
224 : 0 : e->type = PKG_STR;
225 : 0 : break;
226 : : case PKG_ATTR_MAINTAINER:
227 : 0 : e->string = p->maintainer;
228 : 0 : e->type = PKG_STR;
229 : 0 : break;
230 : : case PKG_ATTR_PREFIX:
231 : 0 : e->string = p->prefix;
232 : 0 : e->type = PKG_STR;
233 : 0 : break;
234 : : case PKG_ATTR_DESC:
235 : 0 : e->string = p->desc;
236 : 0 : e->type = PKG_STR;
237 : 0 : break;
238 : : case PKG_ATTR_WWW:
239 : 0 : e->string = p->www;
240 : 0 : e->type = PKG_STR;
241 : 0 : break;
242 : : case PKG_ATTR_ABI:
243 : 0 : e->string = p->abi;
244 : 0 : e->type = PKG_STR;
245 : 0 : break;
246 : : case PKG_ATTR_ARCH:
247 : 0 : e->string = p->altabi;
248 : 0 : e->type = PKG_STR;
249 : 0 : break;
250 : : case PKG_ATTR_VERSION:
251 : 27 : e->string = p->version;
252 : 27 : e->type = PKG_STR;
253 : 27 : break;
254 : : case PKG_ATTR_ORIGIN:
255 : 0 : e->string = p->origin;
256 : 0 : e->type = PKG_STR;
257 : 0 : break;
258 : : case PKG_ATTR_UNIQUEID:
259 : 0 : e->string = p->uid;
260 : 0 : e->type = PKG_STR;
261 : 0 : break;
262 : : case PKG_ATTR_CKSUM:
263 : 2 : e->string = p->sum;
264 : 2 : e->type = PKG_STR;
265 : 2 : break;
266 : : case PKG_ATTR_REPONAME:
267 : 8 : e->string = p->reponame;
268 : 8 : e->type = PKG_STR;
269 : 8 : break;
270 : : case PKG_ATTR_REPOPATH:
271 : 150 : e->string = p->repopath;
272 : 150 : e->type = PKG_STR;
273 : 150 : break;
274 : : case PKG_ATTR_REPOURL:
275 : 72 : e->string = p->repourl;
276 : 72 : e->type = PKG_STR;
277 : 72 : break;
278 : : case PKG_ATTR_REASON:
279 : 48 : e->string = p->reason;
280 : 48 : e->type = PKG_STR;
281 : 48 : break;
282 : : case PKG_ATTR_AUTOMATIC:
283 : 7 : e->boolean = p->automatic;
284 : 7 : e->type = PKG_BOOLEAN;
285 : 7 : break;
286 : : case PKG_ATTR_LOCKED:
287 : 0 : e->boolean = p->locked;
288 : 0 : e->type = PKG_BOOLEAN;
289 : 0 : break;
290 : : case PKG_ATTR_VITAL:
291 : 6 : e->boolean = p->vital;
292 : 6 : e->type = PKG_BOOLEAN;
293 : 6 : break;
294 : : case PKG_ATTR_FLATSIZE:
295 : 194 : e->integer = p->flatsize;
296 : 194 : e->type = PKG_INTEGER;
297 : 194 : break;
298 : : case PKG_ATTR_OLD_FLATSIZE:
299 : 0 : e->integer = p->old_flatsize;
300 : 0 : e->type = PKG_INTEGER;
301 : 0 : break;
302 : : case PKG_ATTR_PKGSIZE:
303 : 296 : e->integer = p->pkgsize;
304 : 296 : e->type = PKG_INTEGER;
305 : 296 : break;
306 : : case PKG_ATTR_CATEGORIES:
307 : 0 : e->stringlist = xcalloc(1, sizeof(struct pkg_stringlist *));
308 : 0 : e->stringlist->list = &p->categories;
309 : 0 : e->type = PKG_STRINGLIST;
310 : 0 : break;
311 : : case PKG_ATTR_ANNOTATIONS:
312 : 8 : e->kvlist = xcalloc(1, sizeof(struct pkg_kvlist *));
313 : 8 : e->kvlist->list = &p->annotations;
314 : 8 : e->type = PKG_KVLIST;
315 : 8 : break;
316 : : case PKG_ATTR_SHLIBS_REQUIRED:
317 : 0 : e->stringlist = xcalloc(1, sizeof(struct pkg_stringlist *));
318 : 0 : e->stringlist->list = &p->shlibs_required;
319 : 0 : e->type = PKG_STRINGLIST;
320 : 0 : break;
321 : : case PKG_ATTR_SHLIBS_PROVIDED:
322 : 0 : e->stringlist = xcalloc(1, sizeof(struct pkg_stringlist *));
323 : 0 : e->stringlist->list = &p->shlibs_provided;
324 : 0 : e->type = PKG_STRINGLIST;
325 : 0 : break;
326 : : case PKG_ATTR_PROVIDES:
327 : 0 : e->stringlist = xcalloc(1, sizeof(struct pkg_stringlist *));
328 : 0 : e->stringlist->list = &p->provides;
329 : 0 : e->type = PKG_STRINGLIST;
330 : 0 : break;
331 : : case PKG_ATTR_REQUIRES:
332 : 0 : e->stringlist = xcalloc(1, sizeof(struct pkg_stringlist *));
333 : 0 : e->stringlist->list = &p->requires;
334 : 0 : e->type = PKG_STRINGLIST;
335 : 0 : break;
336 : : case PKG_ATTR_USERS:
337 : 0 : e->stringlist = xcalloc(1, sizeof(struct pkg_stringlist *));
338 : 0 : e->stringlist->list = &p->users;
339 : 0 : e->type = PKG_STRINGLIST;
340 : 0 : break;
341 : : case PKG_ATTR_GROUPS:
342 : 0 : e->stringlist = xcalloc(1, sizeof(struct pkg_stringlist *));
343 : 0 : e->stringlist->list = &p->groups;
344 : 0 : e->type = PKG_STRINGLIST;
345 : 0 : break;
346 : : case PKG_ATTR_LICENSES:
347 : 0 : e->stringlist = xcalloc(1, sizeof(struct pkg_stringlist *));
348 : 0 : e->stringlist->list = &p->licenses;
349 : 0 : e->type = PKG_STRINGLIST;
350 : 0 : break;
351 : : }
352 : :
353 : 818 : return (e);
354 : : }
355 : :
356 : : bool
357 : 67 : stringlist_contains(stringlist_t *l, const char *name)
358 : : {
359 [ + + + + : 85 : tll_foreach(*l, e) {
+ + ]
360 [ + + ]: 37 : if (STREQ(e->item, name))
361 : 19 : return (true);
362 : 18 : }
363 : 48 : return (false);
364 : 67 : }
|
