1 /*
2 * repo_products.c
3 *
4 * Parses all files below 'proddir'
5 * See http://en.opensuse.org/Product_Management/Code11
6 *
7 *
8 * Copyright (c) 2008, Novell Inc.
9 *
10 * This program is licensed under the BSD license, read LICENSE.BSD
11 * for further information
12 */
13
14 #define _GNU_SOURCE
15 #define _XOPEN_SOURCE
16 #include <time.h>
17 #include <sys/types.h>
18 #include <sys/stat.h>
19 #include <unistd.h>
20 #include <errno.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <assert.h>
25 #include <dirent.h>
26
27 #include "pool.h"
28 #include "repo.h"
29 #include "util.h"
30 #include "solv_xmlparser.h"
31 #define DISABLE_SPLIT
32 #include "tools_util.h"
33 #include "repo_content.h"
34 #include "repo_zyppdb.h"
35 #include "repo_products.h"
36 #include "repo_releasefile_products.h"
37
38
39 enum state {
40 STATE_START,
41 STATE_PRODUCT,
42 STATE_VENDOR,
43 STATE_NAME,
44 STATE_VERSION,
45 STATE_RELEASE,
46 STATE_ARCH,
47 STATE_SUMMARY,
48 STATE_SHORTSUMMARY,
49 STATE_DESCRIPTION,
50 STATE_UPDATEREPOKEY,
51 STATE_CPEID,
52 STATE_URLS,
53 STATE_URL,
54 STATE_RUNTIMECONFIG,
55 STATE_LINGUAS,
56 STATE_LANG,
57 STATE_REGISTER,
58 STATE_TARGET,
59 STATE_REGRELEASE,
60 STATE_REGFLAVOR,
61 STATE_PRODUCTLINE,
62 STATE_REGUPDATES,
63 STATE_REGUPDREPO,
64 STATE_ENDOFLIFE,
65 NUMSTATES
66 };
67
68 static struct solv_xmlparser_element stateswitches[] = {
69 { STATE_START, "product", STATE_PRODUCT, 0 },
70 { STATE_PRODUCT, "vendor", STATE_VENDOR, 1 },
71 { STATE_PRODUCT, "name", STATE_NAME, 1 },
72 { STATE_PRODUCT, "version", STATE_VERSION, 1 },
73 { STATE_PRODUCT, "release", STATE_RELEASE, 1 },
74 { STATE_PRODUCT, "arch", STATE_ARCH, 1 },
75 { STATE_PRODUCT, "productline", STATE_PRODUCTLINE, 1 },
76 { STATE_PRODUCT, "summary", STATE_SUMMARY, 1 },
77 { STATE_PRODUCT, "shortsummary", STATE_SHORTSUMMARY, 1 },
78 { STATE_PRODUCT, "description", STATE_DESCRIPTION, 1 },
79 { STATE_PRODUCT, "register", STATE_REGISTER, 0 },
80 { STATE_PRODUCT, "urls", STATE_URLS, 0 },
81 { STATE_PRODUCT, "runtimeconfig", STATE_RUNTIMECONFIG, 0 },
82 { STATE_PRODUCT, "linguas", STATE_LINGUAS, 0 },
83 { STATE_PRODUCT, "updaterepokey", STATE_UPDATEREPOKEY, 1 },
84 { STATE_PRODUCT, "cpeid", STATE_CPEID, 1 },
85 { STATE_PRODUCT, "endoflife", STATE_ENDOFLIFE, 1 },
86 { STATE_URLS, "url", STATE_URL, 1 },
87 { STATE_LINGUAS, "lang", STATE_LANG, 0 },
88 { STATE_REGISTER, "target", STATE_TARGET, 1 },
89 { STATE_REGISTER, "release", STATE_REGRELEASE, 1 },
90 { STATE_REGISTER, "flavor", STATE_REGFLAVOR, 1 },
91 { STATE_REGISTER, "updates", STATE_REGUPDATES, 0 },
92 { STATE_REGUPDATES, "repository", STATE_REGUPDREPO, 0 },
93 { NUMSTATES }
94 };
95
96 struct parsedata {
97 const char *filename;
98 const char *basename;
99 Pool *pool;
100 Repo *repo;
101 Repodata *data;
102
103 struct solv_xmlparser xmlp;
104 struct joindata jd;
105
106 const char *tmplang;
107
108 const char *tmpvers;
109 const char *tmprel;
110 Id urltype;
111
112 unsigned int ctime;
113
114 Solvable *solvable;
115 Id handle;
116
117 ino_t baseproduct;
118 ino_t currentproduct;
119 int productscheme;
120 };
121
122
123 static time_t
datestr2timestamp(const char * date)124 datestr2timestamp(const char *date)
125 {
126 const char *p;
127 struct tm tm;
128
129 if (!date || !*date)
130 return 0;
131 for (p = date; *p >= '0' && *p <= '9'; p++)
132 ;
133 if (!*p)
134 return atoi(date);
135 memset(&tm, 0, sizeof(tm));
136 p = strptime(date, "%F%T", &tm);
137 if (!p)
138 {
139 memset(&tm, 0, sizeof(tm));
140 p = strptime(date, "%F", &tm);
141 if (!p || *p)
142 return 0;
143 }
144 return timegm(&tm);
145 }
146
147 static void
startElement(struct solv_xmlparser * xmlp,int state,const char * name,const char ** atts)148 startElement(struct solv_xmlparser *xmlp, int state, const char *name, const char **atts)
149 {
150 struct parsedata *pd = xmlp->userdata;
151 Pool *pool = pd->pool;
152 Solvable *s = pd->solvable;
153
154 switch(state)
155 {
156 case STATE_PRODUCT:
157 /* parse 'schemeversion' and store in global variable */
158 {
159 const char * scheme = solv_xmlparser_find_attr("schemeversion", atts);
160 pd->productscheme = (scheme && *scheme) ? atoi(scheme) : -1;
161 }
162 if (!s)
163 {
164 s = pd->solvable = pool_id2solvable(pool, repo_add_solvable(pd->repo));
165 pd->handle = s - pool->solvables;
166 }
167 break;
168
169 /* <summary lang="xy">... */
170 case STATE_SUMMARY:
171 case STATE_DESCRIPTION:
172 pd->tmplang = join_dup(&pd->jd, solv_xmlparser_find_attr("lang", atts));
173 break;
174 case STATE_URL:
175 pd->urltype = pool_str2id(pd->pool, solv_xmlparser_find_attr("name", atts), 1);
176 break;
177 case STATE_REGUPDREPO:
178 {
179 const char *repoid = solv_xmlparser_find_attr("repoid", atts);
180 if (repoid && *repoid)
181 {
182 Id h = repodata_new_handle(pd->data);
183 repodata_set_str(pd->data, h, PRODUCT_UPDATES_REPOID, repoid);
184 repodata_add_flexarray(pd->data, pd->handle, PRODUCT_UPDATES, h);
185 }
186 break;
187 }
188 default:
189 break;
190 }
191 }
192
193
194 static void
endElement(struct solv_xmlparser * xmlp,int state,char * content)195 endElement(struct solv_xmlparser *xmlp, int state, char *content)
196 {
197 struct parsedata *pd = xmlp->userdata;
198 Solvable *s = pd->solvable;
199
200 switch (state)
201 {
202 case STATE_PRODUCT:
203 /* product done, finish solvable */
204 if (pd->ctime)
205 repodata_set_num(pd->data, pd->handle, SOLVABLE_INSTALLTIME, pd->ctime);
206
207 if (pd->basename)
208 repodata_set_str(pd->data, pd->handle, PRODUCT_REFERENCEFILE, pd->basename);
209
210 /* this is where <productsdir>/baseproduct points to */
211 if (pd->currentproduct == pd->baseproduct)
212 repodata_set_str(pd->data, pd->handle, PRODUCT_TYPE, "base");
213
214 if (pd->tmprel)
215 {
216 if (pd->tmpvers)
217 s->evr = makeevr(pd->pool, join2(&pd->jd, pd->tmpvers, "-", pd->tmprel));
218 else
219 {
220 fprintf(stderr, "Seen <release> but no <version>\n");
221 }
222 }
223 else if (pd->tmpvers)
224 s->evr = makeevr(pd->pool, pd->tmpvers); /* just version, no release */
225 pd->tmpvers = solv_free((void *)pd->tmpvers);
226 pd->tmprel = solv_free((void *)pd->tmprel);
227 if (!s->arch)
228 s->arch = ARCH_NOARCH;
229 if (!s->evr)
230 s->evr = ID_EMPTY;
231 if (s->name && s->arch != ARCH_SRC && s->arch != ARCH_NOSRC)
232 s->provides = repo_addid_dep(pd->repo, s->provides, pool_rel2id(pd->pool, s->name, s->evr, REL_EQ, 1), 0);
233 pd->solvable = 0;
234 break;
235 case STATE_VENDOR:
236 s->vendor = pool_str2id(pd->pool, content, 1);
237 break;
238 case STATE_NAME:
239 s->name = pool_str2id(pd->pool, join2(&pd->jd, "product", ":", content), 1);
240 break;
241 case STATE_VERSION:
242 pd->tmpvers = solv_strdup(content);
243 break;
244 case STATE_RELEASE:
245 pd->tmprel = solv_strdup(content);
246 break;
247 case STATE_ARCH:
248 s->arch = pool_str2id(pd->pool, content, 1);
249 break;
250 case STATE_PRODUCTLINE:
251 repodata_set_str(pd->data, pd->handle, PRODUCT_PRODUCTLINE, content);
252 break;
253 case STATE_UPDATEREPOKEY:
254 /** obsolete **/
255 break;
256 case STATE_SUMMARY:
257 repodata_set_str(pd->data, pd->handle, pool_id2langid(pd->pool, SOLVABLE_SUMMARY, pd->tmplang, 1), content);
258 break;
259 case STATE_SHORTSUMMARY:
260 repodata_set_str(pd->data, pd->handle, PRODUCT_SHORTLABEL, content);
261 break;
262 case STATE_DESCRIPTION:
263 repodata_set_str(pd->data, pd->handle, pool_id2langid(pd->pool, SOLVABLE_DESCRIPTION, pd->tmplang, 1), content);
264 break;
265 case STATE_URL:
266 if (pd->urltype)
267 {
268 repodata_add_poolstr_array(pd->data, pd->handle, PRODUCT_URL, content);
269 repodata_add_idarray(pd->data, pd->handle, PRODUCT_URL_TYPE, pd->urltype);
270 }
271 break;
272 case STATE_TARGET:
273 repodata_set_str(pd->data, pd->handle, PRODUCT_REGISTER_TARGET, content);
274 break;
275 case STATE_REGRELEASE:
276 repodata_set_str(pd->data, pd->handle, PRODUCT_REGISTER_RELEASE, content);
277 break;
278 case STATE_REGFLAVOR:
279 repodata_set_str(pd->data, pd->handle, PRODUCT_REGISTER_FLAVOR, content);
280 break;
281 case STATE_CPEID:
282 if (*content)
283 repodata_set_str(pd->data, pd->handle, SOLVABLE_CPEID, content);
284 break;
285 case STATE_ENDOFLIFE:
286 /* FATE#320699: Support tri-state product-endoflife (tag absent, present but nodate(0), present + date) */
287 repodata_set_num(pd->data, pd->handle, PRODUCT_ENDOFLIFE, (*content ? datestr2timestamp(content) : 0));
288 break;
289 default:
290 break;
291 }
292 }
293
294 int
repo_add_code11_products(Repo * repo,const char * dirpath,int flags)295 repo_add_code11_products(Repo *repo, const char *dirpath, int flags)
296 {
297 Repodata *data;
298 struct parsedata pd;
299 DIR *dir;
300
301 data = repo_add_repodata(repo, flags);
302
303 memset(&pd, 0, sizeof(pd));
304 pd.repo = repo;
305 pd.pool = repo->pool;
306 pd.data = data;
307
308 solv_xmlparser_init(&pd.xmlp, stateswitches, &pd, startElement, endElement);
309
310 if (flags & REPO_USE_ROOTDIR)
311 dirpath = pool_prepend_rootdir(repo->pool, dirpath);
312 dir = opendir(dirpath);
313 if (dir)
314 {
315 struct dirent *entry;
316 struct stat st;
317 char *fullpath;
318
319 /* check for <productsdir>/baseproduct on code11 and remember its target inode */
320 if (stat(join2(&pd.jd, dirpath, "/", "baseproduct"), &st) == 0) /* follow symlink */
321 pd.baseproduct = st.st_ino;
322 else
323 pd.baseproduct = 0;
324
325 while ((entry = readdir(dir)))
326 {
327 int len = strlen(entry->d_name);
328 FILE *fp;
329 if (len <= 5 || strcmp(entry->d_name + len - 5, ".prod") != 0)
330 continue;
331 fullpath = join2(&pd.jd, dirpath, "/", entry->d_name);
332 fp = fopen(fullpath, "r");
333 if (!fp)
334 {
335 pool_error(repo->pool, 0, "%s: %s", fullpath, strerror(errno));
336 continue;
337 }
338 if (fstat(fileno(fp), &st))
339 {
340 pool_error(repo->pool, 0, "%s: %s", fullpath, strerror(errno));
341 fclose(fp);
342 continue;
343 }
344 pd.currentproduct = st.st_ino;
345 pd.ctime = (unsigned int)st.st_ctime;
346 pd.filename = fullpath;
347 pd.basename = entry->d_name;
348 if (solv_xmlparser_parse(&pd.xmlp, fp) != SOLV_XMLPARSER_OK)
349 {
350 pool_debug(pd.pool, SOLV_ERROR, "%s: %s at line %u:%u\n", pd.filename, pd.xmlp.errstr, pd.xmlp.line, pd.xmlp.column);
351 pd.solvable = solvable_free(pd.solvable, 1);
352 }
353 fclose(fp);
354 }
355 closedir(dir);
356 }
357 solv_xmlparser_free(&pd.xmlp);
358 join_freemem(&pd.jd);
359 if (flags & REPO_USE_ROOTDIR)
360 solv_free((char *)dirpath);
361
362 if (!(flags & REPO_NO_INTERNALIZE))
363 repodata_internalize(data);
364 return 0;
365 }
366
367
368 /******************************************************************************************/
369
370
371 /*
372 * read all installed products
373 *
374 * try proddir (reading all .xml files from this directory) first
375 * if not available, assume non-code11 layout and parse /etc/xyz-release
376 *
377 * parse each one as a product
378 */
379
380 /* Oh joy! Three parsers for the price of one! */
381
382 int
repo_add_products(Repo * repo,const char * proddir,int flags)383 repo_add_products(Repo *repo, const char *proddir, int flags)
384 {
385 const char *fullpath;
386 DIR *dir;
387
388 if (proddir)
389 {
390 dir = opendir(flags & REPO_USE_ROOTDIR ? pool_prepend_rootdir_tmp(repo->pool, proddir) : proddir);
391 if (dir)
392 {
393 /* assume code11 stype products */
394 closedir(dir);
395 return repo_add_code11_products(repo, proddir, flags);
396 }
397 }
398
399 /* code11 didn't work, try old code10 zyppdb */
400 fullpath = "/var/lib/zypp/db/products";
401 if (flags & REPO_USE_ROOTDIR)
402 fullpath = pool_prepend_rootdir_tmp(repo->pool, fullpath);
403 dir = opendir(fullpath);
404 if (dir)
405 {
406 closedir(dir);
407 /* assume code10 style products */
408 return repo_add_zyppdb_products(repo, "/var/lib/zypp/db/products", flags);
409 }
410
411 /* code10/11 didn't work, try -release files parsing */
412 fullpath = "/etc";
413 if (flags & REPO_USE_ROOTDIR)
414 fullpath = pool_prepend_rootdir_tmp(repo->pool, fullpath);
415 dir = opendir(fullpath);
416 if (dir)
417 {
418 closedir(dir);
419 return repo_add_releasefile_products(repo, "/etc", flags);
420 }
421
422 /* no luck. check if the rootdir exists */
423 fullpath = pool_get_rootdir(repo->pool);
424 if (fullpath && *fullpath)
425 {
426 dir = opendir(fullpath);
427 if (!dir)
428 return pool_error(repo->pool, -1, "%s: %s", fullpath, strerror(errno));
429 closedir(dir);
430 }
431
432 /* the least we can do... */
433 if (!(flags & REPO_NO_INTERNALIZE) && (flags & REPO_REUSE_REPODATA) != 0)
434 repodata_internalize(repo_last_repodata(repo));
435 return 0;
436 }
437
438 /* EOF */
439