projects / apt.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
More MD5
[apt.git] / apt-pkg / deb / deblistparser.cc
0 / 529 (  0%)
CommitLineData
1// -*- mode: cpp; mode: fold -*-
2// Description /*{{{*/
3// $Id: deblistparser.cc,v 1.23 1999/09/30 06:30:34 jgg Exp $
4/* ######################################################################
5
6 Package Cache Generator - Generator for the cache structure.
7
8 This builds the cache structure from the abstract package list parser.
9
10 ##################################################################### */
11 /*}}}*/
12// Include Files /*{{{*/
13#include <apt-pkg/deblistparser.h>
14#include <apt-pkg/error.h>
15#include <apt-pkg/configuration.h>
16#include <apt-pkg/strutl.h>
17#include <apt-pkg/crc-16.h>
18
19#include <system.h>
20 /*}}}*/
21
22// ListParser::debListParser - Constructor /*{{{*/
23// ---------------------------------------------------------------------
24/* */
25debListParser::debListParser(FileFd &File) : Tags(File)
26{
27 Arch = _config->Find("APT::architecture");
28}
29 /*}}}*/
30// ListParser::UniqFindTagWrite - Find the tag and write a unq string /*{{{*/
31// ---------------------------------------------------------------------
32/* */
33unsigned long debListParser::UniqFindTagWrite(const char *Tag)
34{
35 const char *Start;
36 const char *Stop;
37 if (Section.Find(Tag,Start,Stop) == false)
38 return 0;
39 return WriteUniqString(Start,Stop - Start);
40}
41 /*}}}*/
42// ListParser::Package - Return the package name /*{{{*/
43// ---------------------------------------------------------------------
44/* This is to return the name of the package this section describes */
45string debListParser::Package()
46{
47 string Result = Section.FindS("Package");
48 if (Result.empty() == true)
49 _error->Error("Encountered a section with no Package: header");
50 return Result;
51}
52 /*}}}*/
53// ListParser::Version - Return the version string /*{{{*/
54// ---------------------------------------------------------------------
55/* This is to return the string describing the version in debian form,
56 epoch:upstream-release. If this returns the blank string then the
57 entry is assumed to only describe package properties */
58string debListParser::Version()
59{
60 return Section.FindS("Version");
61}
62 /*}}}*/
63// ListParser::NewVersion - Fill in the version structure /*{{{*/
64// ---------------------------------------------------------------------
65/* */
66bool debListParser::NewVersion(pkgCache::VerIterator Ver)
67{
68 // Parse the section
69 Ver->Section = UniqFindTagWrite("Section");
70 Ver->Arch = UniqFindTagWrite("Architecture");
71
72 // Archive Size
73 Ver->Size = (unsigned)Section.FindI("Size");
74
75 // Unpacked Size (in K)
76 Ver->InstalledSize = (unsigned)Section.FindI("Installed-Size");
77 Ver->InstalledSize *= 1024;
78
79 // Priority
80 const char *Start;
81 const char *Stop;
82 if (Section.Find("Priority",Start,Stop) == true)
83 {
84 WordList PrioList[] = {{"important",pkgCache::State::Important},
85 {"required",pkgCache::State::Required},
86 {"standard",pkgCache::State::Standard},
87 {"optional",pkgCache::State::Optional},
88 {"extra",pkgCache::State::Extra}};
89 if (GrabWord(string(Start,Stop-Start),PrioList,
90 _count(PrioList),Ver->Priority) == false)
91 Ver->Priority = pkgCache::State::Extra;
92 }
93
94 if (ParseDepends(Ver,"Depends",pkgCache::Dep::Depends) == false)
95 return false;
96 if (ParseDepends(Ver,"Pre-Depends",pkgCache::Dep::PreDepends) == false)
97 return false;
98 if (ParseDepends(Ver,"Suggests",pkgCache::Dep::Suggests) == false)
99 return false;
100 if (ParseDepends(Ver,"Recommends",pkgCache::Dep::Recommends) == false)
101 return false;
102 if (ParseDepends(Ver,"Conflicts",pkgCache::Dep::Conflicts) == false)
103 return false;
104 if (ParseDepends(Ver,"Replaces",pkgCache::Dep::Replaces) == false)
105 return false;
106
107 if (ParseProvides(Ver) == false)
108 return false;
109
110 return true;
111}
112 /*}}}*/
113// ListParser::UsePackage - Update a package structure /*{{{*/
114// ---------------------------------------------------------------------
115/* This is called to update the package with any new information
116 that might be found in the section */
117bool debListParser::UsePackage(pkgCache::PkgIterator Pkg,
118 pkgCache::VerIterator Ver)
119{
120 if (Pkg->Section == 0)
121 Pkg->Section = UniqFindTagWrite("Section");
122 if (Section.FindFlag("Essential",Pkg->Flags,pkgCache::Flag::Essential) == false)
123 return false;
124 if (Section.FindFlag("Important",Pkg->Flags,pkgCache::Flag::Important) == false)
125 return false;
126
127 if (strcmp(Pkg.Name(),"apt") == 0)
128 Pkg->Flags |= pkgCache::Flag::Important;
129
130 if (ParseStatus(Pkg,Ver) == false)
131 return false;
132 return true;
133}
134 /*}}}*/
135// ListParser::VersionHash - Compute a unique hash for this version /*{{{*/
136// ---------------------------------------------------------------------
137/* */
138unsigned short debListParser::VersionHash()
139{
140 const char *Sections[] ={"Installed-Size",
141 "Depends",
142 "Pre-Depends",
143// "Suggests",
144// "Recommends",
145 "Conflicts",
146 "Replaces",0};
147 unsigned long Result = INIT_FCS;
148 char S[300];
149 for (const char **I = Sections; *I != 0; I++)
150 {
151 const char *Start;
152 const char *End;
153 if (Section.Find(*I,Start,End) == false || End - Start >= (signed)sizeof(S))
154 continue;
155
156 /* Strip out any spaces from the text, this undoes dpkgs reformatting
157 of certain fields. dpkg also has the rather interesting notion of
158 reformatting depends operators < -> <= */
159 char *I = S;
160 for (; Start != End; Start++)
161 {
162 if (isspace(*Start) == 0)
163 *I++ = tolower(*Start);
164 if (*Start == '<' && Start[1] != '<' && Start[1] != '=')
165 *I++ = '=';
166 if (*Start == '>' && Start[1] != '>' && Start[1] != '=')
167 *I++ = '=';
168 }
169
170 Result = AddCRC16(Result,S,I - S);
171 }
172
173 return Result;
174}
175 /*}}}*/
176// ListParser::ParseStatus - Parse the status field /*{{{*/
177// ---------------------------------------------------------------------
178/* Status lines are of the form,
179 Status: want flag status
180 want = unknown, install, hold, deinstall, purge
181 flag = ok, reinstreq, hold, hold-reinstreq
182 status = not-installed, unpacked, half-configured,
183 half-installed, config-files, post-inst-failed,
184 removal-failed, installed
185
186 Some of the above are obsolete (I think?) flag = hold-* and
187 status = post-inst-failed, removal-failed at least.
188 */
189bool debListParser::ParseStatus(pkgCache::PkgIterator Pkg,
190 pkgCache::VerIterator Ver)
191{
192 const char *Start;
193 const char *Stop;
194 if (Section.Find("Status",Start,Stop) == false)
195 return true;
196
197 // Isolate the first word
198 const char *I = Start;
199 for(; I < Stop && *I != ' '; I++);
200 if (I >= Stop || *I != ' ')
201 return _error->Error("Malformed Status line");
202
203 // Process the want field
204 WordList WantList[] = {{"unknown",pkgCache::State::Unknown},
205 {"install",pkgCache::State::Install},
206 {"hold",pkgCache::State::Hold},
207 {"deinstall",pkgCache::State::DeInstall},
208 {"purge",pkgCache::State::Purge}};
209 if (GrabWord(string(Start,I-Start),WantList,
210 _count(WantList),Pkg->SelectedState) == false)
211 return _error->Error("Malformed 1st word in the Status line");
212
213 // Isloate the next word
214 I++;
215 Start = I;
216 for(; I < Stop && *I != ' '; I++);
217 if (I >= Stop || *I != ' ')
218 return _error->Error("Malformed status line, no 2nd word");
219
220 // Process the flag field
221 WordList FlagList[] = {{"ok",pkgCache::State::Ok},
222 {"reinstreq",pkgCache::State::ReInstReq},
223 {"hold",pkgCache::State::HoldInst},
224 {"hold-reinstreq",pkgCache::State::HoldReInstReq}};
225 if (GrabWord(string(Start,I-Start),FlagList,
226 _count(FlagList),Pkg->InstState) == false)
227 return _error->Error("Malformed 2nd word in the Status line");
228
229 // Isloate the last word
230 I++;
231 Start = I;
232 for(; I < Stop && *I != ' '; I++);
233 if (I != Stop)
234 return _error->Error("Malformed Status line, no 3rd word");
235
236 // Process the flag field
237 WordList StatusList[] = {{"not-installed",pkgCache::State::NotInstalled},
238 {"unpacked",pkgCache::State::UnPacked},
239 {"half-configured",pkgCache::State::HalfConfigured},
240 {"installed",pkgCache::State::Installed},
241 {"half-installed",pkgCache::State::HalfInstalled},
242 {"config-files",pkgCache::State::ConfigFiles},
243 {"post-inst-failed",pkgCache::State::HalfConfigured},
244 {"removal-failed",pkgCache::State::HalfInstalled}};
245 if (GrabWord(string(Start,I-Start),StatusList,
246 _count(StatusList),Pkg->CurrentState) == false)
247 return _error->Error("Malformed 3rd word in the Status line");
248
249 /* A Status line marks the package as indicating the current
250 version as well. Only if it is actually installed.. Otherwise
251 the interesting dpkg handling of the status file creates bogus
252 entries. */
253 if (!(Pkg->CurrentState == pkgCache::State::NotInstalled ||
254 Pkg->CurrentState == pkgCache::State::ConfigFiles))
255 {
256 if (Ver.end() == true)
257 _error->Warning("Encountered status field in a non-version description");
258 else
259 Pkg->CurrentVer = Ver.Index();
260 }
261
262 return true;
263}
264 /*}}}*/
265// ListParser::ParseDepends - Parse a dependency element /*{{{*/
266// ---------------------------------------------------------------------
267/* This parses the dependency elements out of a standard string in place,
268 bit by bit. */
269const char *debListParser::ParseDepends(const char *Start,const char *Stop,
270 string &Package,string &Ver,
271 unsigned int &Op)
272{
273 // Strip off leading space
274 for (;Start != Stop && isspace(*Start) != 0; Start++);
275
276 // Parse off the package name
277 const char *I = Start;
278 for (;I != Stop && isspace(*I) == 0 && *I != '(' && *I != ')' &&
279 *I != ',' && *I != '|'; I++);
280
281 // Malformed, no '('
282 if (I != Stop && *I == ')')
283 return 0;
284
285 if (I == Start)
286 return 0;
287
288 // Stash the package name
289 Package.assign(Start,I - Start);
290
291 // Skip white space to the '('
292 for (;I != Stop && isspace(*I) != 0 ; I++);
293
294 // Parse a version
295 if (I != Stop && *I == '(')
296 {
297 // Skip the '('
298 for (I++; I != Stop && isspace(*I) != 0 ; I++);
299 if (I + 3 >= Stop)
300 return 0;
301
302 // Determine the operator
303 switch (*I)
304 {
305 case '<':
306 I++;
307 if (*I == '=')
308 {
309 I++;
310 Op = pkgCache::Dep::LessEq;
311 break;
312 }
313
314 if (*I == '<')
315 {
316 I++;
317 Op = pkgCache::Dep::Less;
318 break;
319 }
320
321 // < is the same as <= and << is really Cs < for some reason
322 Op = pkgCache::Dep::LessEq;
323 break;
324
325 case '>':
326 I++;
327 if (*I == '=')
328 {
329 I++;
330 Op = pkgCache::Dep::GreaterEq;
331 break;
332 }
333
334 if (*I == '>')
335 {
336 I++;
337 Op = pkgCache::Dep::Greater;
338 break;
339 }
340
341 // > is the same as >= and >> is really Cs > for some reason
342 Op = pkgCache::Dep::GreaterEq;
343 break;
344
345 case '=':
346 Op = pkgCache::Dep::Equals;
347 I++;
348 break;
349
350 // HACK around bad package definitions
351 default:
352 Op = pkgCache::Dep::Equals;
353 break;
354 }
355
356 // Skip whitespace
357 for (;I != Stop && isspace(*I) != 0; I++);
358 Start = I;
359 for (;I != Stop && *I != ')'; I++);
360 if (I == Stop || Start == I)
361 return 0;
362
363 // Skip trailing whitespace
364 const char *End = I;
365 for (; End > Start && isspace(End[-1]); End--);
366
367 Ver = string(Start,End-Start);
368 I++;
369 }
370 else
371 {
372 Ver = string();
373 Op = pkgCache::Dep::NoOp;
374 }
375
376 // Skip whitespace
377 for (;I != Stop && isspace(*I) != 0; I++);
378 if (I != Stop && *I == '|')
379 Op |= pkgCache::Dep::Or;
380
381 if (I == Stop || *I == ',' || *I == '|')
382 {
383 if (I != Stop)
384 for (I++; I != Stop && isspace(*I) != 0; I++);
385 return I;
386 }
387
388 return 0;
389}
390 /*}}}*/
391// ListParser::ParseDepends - Parse a dependency list /*{{{*/
392// ---------------------------------------------------------------------
393/* This is the higher level depends parser. It takes a tag and generates
394 a complete depends tree for the given version. */
395bool debListParser::ParseDepends(pkgCache::VerIterator Ver,
396 const char *Tag,unsigned int Type)
397{
398 const char *Start;
399 const char *Stop;
400 if (Section.Find(Tag,Start,Stop) == false)
401 return true;
402
403 string Package;
404 string Version;
405 unsigned int Op;
406
407 while (1)
408 {
409 Start = ParseDepends(Start,Stop,Package,Version,Op);
410 if (Start == 0)
411 return _error->Error("Problem parsing dependency %s",Tag);
412
413 if (NewDepends(Ver,Package,Version,Op,Type) == false)
414 return false;
415 if (Start == Stop)
416 break;
417 }
418 return true;
419}
420 /*}}}*/
421// ListParser::ParseProvides - Parse the provides list /*{{{*/
422// ---------------------------------------------------------------------
423/* */
424bool debListParser::ParseProvides(pkgCache::VerIterator Ver)
425{
426 const char *Start;
427 const char *Stop;
428 if (Section.Find("Provides",Start,Stop) == false)
429 return true;
430
431 string Package;
432 string Version;
433 unsigned int Op;
434
435 while (1)
436 {
437 Start = ParseDepends(Start,Stop,Package,Version,Op);
438 if (Start == 0)
439 return _error->Error("Problem parsing Provides line");
440 if (Op != pkgCache::Dep::NoOp)
441 return _error->Error("Malformed provides line");
442
443 if (NewProvides(Ver,Package,Version) == false)
444 return false;
445
446 if (Start == Stop)
447 break;
448 }
449
450 return true;
451}
452 /*}}}*/
453// ListParser::GrabWord - Matches a word and returns /*{{{*/
454// ---------------------------------------------------------------------
455/* Looks for a word in a list of words - for ParseStatus */
456bool debListParser::GrabWord(string Word,WordList *List,int Count,
457 unsigned char &Out)
458{
459 for (int C = 0; C != Count; C++)
460 {
461 if (strcasecmp(Word.c_str(),List[C].Str) == 0)
462 {
463 Out = List[C].Val;
464 return true;
465 }
466 }
467 return false;
468}
469 /*}}}*/
470// ListParser::Step - Move to the next section in the file /*{{{*/
471// ---------------------------------------------------------------------
472/* This has to be carefull to only process the correct architecture */
473bool debListParser::Step()
474{
475 iOffset = Tags.Offset();
476 while (Tags.Step(Section) == true)
477 {
478 /* See if this is the correct Architecture, if it isn't then we
479 drop the whole section. A missing arch tag only happens (in theory)
480 inside the Status file, so that is a positive return */
481 const char *Start;
482 const char *Stop;
483 if (Section.Find("Architecture",Start,Stop) == false)
484 return true;
485
486 if (stringcmp(Start,Stop,Arch.begin(),Arch.end()) == 0)
487 return true;
488
489 if (stringcmp(Start,Stop,"all") == 0)
490 return true;
491
492 iOffset = Tags.Offset();
493 }
494 return false;
495}
496 /*}}}*/
497// ListParser::LoadReleaseInfo - Load the release information /*{{{*/
498// ---------------------------------------------------------------------
499/* */
500bool debListParser::LoadReleaseInfo(pkgCache::PkgFileIterator FileI,
501 FileFd &File)
502{
503 pkgTagFile Tags(File);
504 pkgTagSection Section;
505 if (Tags.Step(Section) == false)
506 return false;
507
508 const char *Start;
509 const char *Stop;
510 if (Section.Find("Archive",Start,Stop) == true)
511 FileI->Archive = WriteUniqString(Start,Stop - Start);
512 if (Section.Find("Component",Start,Stop) == true)
513 FileI->Component = WriteUniqString(Start,Stop - Start);
514 if (Section.Find("Version",Start,Stop) == true)
515 FileI->Version = WriteUniqString(Start,Stop - Start);
516 if (Section.Find("Origin",Start,Stop) == true)
517 FileI->Origin = WriteUniqString(Start,Stop - Start);
518 if (Section.Find("Label",Start,Stop) == true)
519 FileI->Label = WriteUniqString(Start,Stop - Start);
520 if (Section.Find("Architecture",Start,Stop) == true)
521 FileI->Architecture = WriteUniqString(Start,Stop - Start);
522
523 if (Section.FindFlag("NotAutomatic",FileI->Flags,
524 pkgCache::Flag::NotAutomatic) == false)
525 _error->Warning("Bad NotAutomatic flag");
526
527 return !_error->PendingError();
528}
529 /*}}}*/
APT (for Cydia)