| 1 | // -*- mode: cpp; mode: fold -*- |
| 2 | // Description /*{{{*/ |
| 3 | // $Id: deblistparser.cc,v 1.29.2.5 2004/01/06 01:43:44 mdz 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/aptconfiguration.h> |
| 17 | #include <apt-pkg/strutl.h> |
| 18 | #include <apt-pkg/crc-16.h> |
| 19 | #include <apt-pkg/md5.h> |
| 20 | #include <apt-pkg/macros.h> |
| 21 | |
| 22 | #include <ctype.h> |
| 23 | /*}}}*/ |
| 24 | |
| 25 | static debListParser::WordList PrioList[] = {{"important",pkgCache::State::Important}, |
| 26 | {"required",pkgCache::State::Required}, |
| 27 | {"standard",pkgCache::State::Standard}, |
| 28 | {"optional",pkgCache::State::Optional}, |
| 29 | {"extra",pkgCache::State::Extra}, |
| 30 | {}}; |
| 31 | |
| 32 | // ListParser::debListParser - Constructor /*{{{*/ |
| 33 | // --------------------------------------------------------------------- |
| 34 | /* */ |
| 35 | debListParser::debListParser(FileFd *File) : Tags(File) |
| 36 | { |
| 37 | Arch = _config->Find("APT::architecture"); |
| 38 | } |
| 39 | /*}}}*/ |
| 40 | // ListParser::UniqFindTagWrite - Find the tag and write a unq string /*{{{*/ |
| 41 | // --------------------------------------------------------------------- |
| 42 | /* */ |
| 43 | unsigned long debListParser::UniqFindTagWrite(const char *Tag) |
| 44 | { |
| 45 | const char *Start; |
| 46 | const char *Stop; |
| 47 | if (Section.Find(Tag,Start,Stop) == false) |
| 48 | return 0; |
| 49 | return WriteUniqString(Start,Stop - Start); |
| 50 | } |
| 51 | /*}}}*/ |
| 52 | // ListParser::Package - Return the package name /*{{{*/ |
| 53 | // --------------------------------------------------------------------- |
| 54 | /* This is to return the name of the package this section describes */ |
| 55 | string debListParser::Package() |
| 56 | { |
| 57 | string Result = Section.FindS("Package"); |
| 58 | if (Result.empty() == true) |
| 59 | _error->Error("Encountered a section with no Package: header"); |
| 60 | return Result; |
| 61 | } |
| 62 | /*}}}*/ |
| 63 | // ListParser::Version - Return the version string /*{{{*/ |
| 64 | // --------------------------------------------------------------------- |
| 65 | /* This is to return the string describing the version in debian form, |
| 66 | epoch:upstream-release. If this returns the blank string then the |
| 67 | entry is assumed to only describe package properties */ |
| 68 | string debListParser::Version() |
| 69 | { |
| 70 | return Section.FindS("Version"); |
| 71 | } |
| 72 | /*}}}*/ |
| 73 | // ListParser::NewVersion - Fill in the version structure /*{{{*/ |
| 74 | // --------------------------------------------------------------------- |
| 75 | /* */ |
| 76 | bool debListParser::NewVersion(pkgCache::VerIterator Ver) |
| 77 | { |
| 78 | // Parse the section |
| 79 | Ver->Section = UniqFindTagWrite("Section"); |
| 80 | Ver->Arch = UniqFindTagWrite("Architecture"); |
| 81 | |
| 82 | // Archive Size |
| 83 | Ver->Size = (unsigned)Section.FindI("Size"); |
| 84 | |
| 85 | // Unpacked Size (in K) |
| 86 | Ver->InstalledSize = (unsigned)Section.FindI("Installed-Size"); |
| 87 | Ver->InstalledSize *= 1024; |
| 88 | |
| 89 | // Priority |
| 90 | const char *Start; |
| 91 | const char *Stop; |
| 92 | if (Section.Find("Priority",Start,Stop) == true) |
| 93 | { |
| 94 | if (GrabWord(string(Start,Stop-Start),PrioList,Ver->Priority) == false) |
| 95 | Ver->Priority = pkgCache::State::Extra; |
| 96 | } |
| 97 | |
| 98 | if (ParseDepends(Ver,"Depends",pkgCache::Dep::Depends) == false) |
| 99 | return false; |
| 100 | if (ParseDepends(Ver,"Pre-Depends",pkgCache::Dep::PreDepends) == false) |
| 101 | return false; |
| 102 | if (ParseDepends(Ver,"Suggests",pkgCache::Dep::Suggests) == false) |
| 103 | return false; |
| 104 | if (ParseDepends(Ver,"Recommends",pkgCache::Dep::Recommends) == false) |
| 105 | return false; |
| 106 | if (ParseDepends(Ver,"Conflicts",pkgCache::Dep::Conflicts) == false) |
| 107 | return false; |
| 108 | if (ParseDepends(Ver,"Breaks",pkgCache::Dep::DpkgBreaks) == false) |
| 109 | return false; |
| 110 | if (ParseDepends(Ver,"Replaces",pkgCache::Dep::Replaces) == false) |
| 111 | return false; |
| 112 | if (ParseDepends(Ver,"Enhances",pkgCache::Dep::Enhances) == false) |
| 113 | return false; |
| 114 | |
| 115 | // Obsolete. |
| 116 | if (ParseDepends(Ver,"Optional",pkgCache::Dep::Suggests) == false) |
| 117 | return false; |
| 118 | |
| 119 | if (ParseProvides(Ver) == false) |
| 120 | return false; |
| 121 | |
| 122 | return true; |
| 123 | } |
| 124 | /*}}}*/ |
| 125 | // ListParser::Description - Return the description string /*{{{*/ |
| 126 | // --------------------------------------------------------------------- |
| 127 | /* This is to return the string describing the package in debian |
| 128 | form. If this returns the blank string then the entry is assumed to |
| 129 | only describe package properties */ |
| 130 | string debListParser::Description() |
| 131 | { |
| 132 | string const lang = DescriptionLanguage(); |
| 133 | if (lang.empty()) |
| 134 | return Section.FindS("Description"); |
| 135 | else |
| 136 | return Section.FindS(string("Description-").append(lang).c_str()); |
| 137 | } |
| 138 | /*}}}*/ |
| 139 | // ListParser::DescriptionLanguage - Return the description lang string /*{{{*/ |
| 140 | // --------------------------------------------------------------------- |
| 141 | /* This is to return the string describing the language of |
| 142 | description. If this returns the blank string then the entry is |
| 143 | assumed to describe original description. */ |
| 144 | string debListParser::DescriptionLanguage() |
| 145 | { |
| 146 | if (Section.FindS("Description").empty() == false) |
| 147 | return ""; |
| 148 | |
| 149 | std::vector<string> const lang = APT::Configuration::getLanguages(); |
| 150 | for (std::vector<string>::const_iterator l = lang.begin(); |
| 151 | l != lang.end(); l++) |
| 152 | if (Section.FindS(string("Description-").append(*l).c_str()).empty() == false) |
| 153 | return *l; |
| 154 | |
| 155 | return ""; |
| 156 | } |
| 157 | /*}}}*/ |
| 158 | // ListParser::Description - Return the description_md5 MD5SumValue /*{{{*/ |
| 159 | // --------------------------------------------------------------------- |
| 160 | /* This is to return the md5 string to allow the check if it is the right |
| 161 | description. If no Description-md5 is found in the section it will be |
| 162 | calculated. |
| 163 | */ |
| 164 | MD5SumValue debListParser::Description_md5() |
| 165 | { |
| 166 | string value = Section.FindS("Description-md5"); |
| 167 | |
| 168 | if (value.empty()) |
| 169 | { |
| 170 | MD5Summation md5; |
| 171 | md5.Add((Description() + "\n").c_str()); |
| 172 | return md5.Result(); |
| 173 | } else |
| 174 | return MD5SumValue(value); |
| 175 | } |
| 176 | /*}}}*/ |
| 177 | // ListParser::UsePackage - Update a package structure /*{{{*/ |
| 178 | // --------------------------------------------------------------------- |
| 179 | /* This is called to update the package with any new information |
| 180 | that might be found in the section */ |
| 181 | bool debListParser::UsePackage(pkgCache::PkgIterator Pkg, |
| 182 | pkgCache::VerIterator Ver) |
| 183 | { |
| 184 | if (Pkg->Section == 0) |
| 185 | Pkg->Section = UniqFindTagWrite("Section"); |
| 186 | if (Section.FindFlag("Essential",Pkg->Flags,pkgCache::Flag::Essential) == false) |
| 187 | return false; |
| 188 | if (Section.FindFlag("Important",Pkg->Flags,pkgCache::Flag::Important) == false) |
| 189 | return false; |
| 190 | |
| 191 | if (strcmp(Pkg.Name(),"apt") == 0) |
| 192 | Pkg->Flags |= pkgCache::Flag::Important; |
| 193 | |
| 194 | if (ParseStatus(Pkg,Ver) == false) |
| 195 | return false; |
| 196 | return true; |
| 197 | } |
| 198 | /*}}}*/ |
| 199 | // ListParser::VersionHash - Compute a unique hash for this version /*{{{*/ |
| 200 | // --------------------------------------------------------------------- |
| 201 | /* */ |
| 202 | unsigned short debListParser::VersionHash() |
| 203 | { |
| 204 | const char *Sections[] ={"Installed-Size", |
| 205 | "Depends", |
| 206 | "Pre-Depends", |
| 207 | // "Suggests", |
| 208 | // "Recommends", |
| 209 | "Conflicts", |
| 210 | "Breaks", |
| 211 | "Replaces",0}; |
| 212 | unsigned long Result = INIT_FCS; |
| 213 | char S[1024]; |
| 214 | for (const char **I = Sections; *I != 0; I++) |
| 215 | { |
| 216 | const char *Start; |
| 217 | const char *End; |
| 218 | if (Section.Find(*I,Start,End) == false || End - Start >= (signed)sizeof(S)) |
| 219 | continue; |
| 220 | |
| 221 | /* Strip out any spaces from the text, this undoes dpkgs reformatting |
| 222 | of certain fields. dpkg also has the rather interesting notion of |
| 223 | reformatting depends operators < -> <= */ |
| 224 | char *I = S; |
| 225 | for (; Start != End; Start++) |
| 226 | { |
| 227 | if (isspace(*Start) == 0) |
| 228 | *I++ = tolower_ascii(*Start); |
| 229 | if (*Start == '<' && Start[1] != '<' && Start[1] != '=') |
| 230 | *I++ = '='; |
| 231 | if (*Start == '>' && Start[1] != '>' && Start[1] != '=') |
| 232 | *I++ = '='; |
| 233 | } |
| 234 | |
| 235 | Result = AddCRC16(Result,S,I - S); |
| 236 | } |
| 237 | |
| 238 | return Result; |
| 239 | } |
| 240 | /*}}}*/ |
| 241 | // ListParser::ParseStatus - Parse the status field /*{{{*/ |
| 242 | // --------------------------------------------------------------------- |
| 243 | /* Status lines are of the form, |
| 244 | Status: want flag status |
| 245 | want = unknown, install, hold, deinstall, purge |
| 246 | flag = ok, reinstreq, hold, hold-reinstreq |
| 247 | status = not-installed, unpacked, half-configured, |
| 248 | half-installed, config-files, post-inst-failed, |
| 249 | removal-failed, installed |
| 250 | |
| 251 | Some of the above are obsolete (I think?) flag = hold-* and |
| 252 | status = post-inst-failed, removal-failed at least. |
| 253 | */ |
| 254 | bool debListParser::ParseStatus(pkgCache::PkgIterator Pkg, |
| 255 | pkgCache::VerIterator Ver) |
| 256 | { |
| 257 | const char *Start; |
| 258 | const char *Stop; |
| 259 | if (Section.Find("Status",Start,Stop) == false) |
| 260 | return true; |
| 261 | |
| 262 | // Isolate the first word |
| 263 | const char *I = Start; |
| 264 | for(; I < Stop && *I != ' '; I++); |
| 265 | if (I >= Stop || *I != ' ') |
| 266 | return _error->Error("Malformed Status line"); |
| 267 | |
| 268 | // Process the want field |
| 269 | WordList WantList[] = {{"unknown",pkgCache::State::Unknown}, |
| 270 | {"install",pkgCache::State::Install}, |
| 271 | {"hold",pkgCache::State::Hold}, |
| 272 | {"deinstall",pkgCache::State::DeInstall}, |
| 273 | {"purge",pkgCache::State::Purge}, |
| 274 | {}}; |
| 275 | if (GrabWord(string(Start,I-Start),WantList,Pkg->SelectedState) == false) |
| 276 | return _error->Error("Malformed 1st word in the Status line"); |
| 277 | |
| 278 | // Isloate the next word |
| 279 | I++; |
| 280 | Start = I; |
| 281 | for(; I < Stop && *I != ' '; I++); |
| 282 | if (I >= Stop || *I != ' ') |
| 283 | return _error->Error("Malformed status line, no 2nd word"); |
| 284 | |
| 285 | // Process the flag field |
| 286 | WordList FlagList[] = {{"ok",pkgCache::State::Ok}, |
| 287 | {"reinstreq",pkgCache::State::ReInstReq}, |
| 288 | {"hold",pkgCache::State::HoldInst}, |
| 289 | {"hold-reinstreq",pkgCache::State::HoldReInstReq}, |
| 290 | {}}; |
| 291 | if (GrabWord(string(Start,I-Start),FlagList,Pkg->InstState) == false) |
| 292 | return _error->Error("Malformed 2nd word in the Status line"); |
| 293 | |
| 294 | // Isloate the last word |
| 295 | I++; |
| 296 | Start = I; |
| 297 | for(; I < Stop && *I != ' '; I++); |
| 298 | if (I != Stop) |
| 299 | return _error->Error("Malformed Status line, no 3rd word"); |
| 300 | |
| 301 | // Process the flag field |
| 302 | WordList StatusList[] = {{"not-installed",pkgCache::State::NotInstalled}, |
| 303 | {"unpacked",pkgCache::State::UnPacked}, |
| 304 | {"half-configured",pkgCache::State::HalfConfigured}, |
| 305 | {"installed",pkgCache::State::Installed}, |
| 306 | {"half-installed",pkgCache::State::HalfInstalled}, |
| 307 | {"config-files",pkgCache::State::ConfigFiles}, |
| 308 | {"triggers-awaited",pkgCache::State::TriggersAwaited}, |
| 309 | {"triggers-pending",pkgCache::State::TriggersPending}, |
| 310 | {"post-inst-failed",pkgCache::State::HalfConfigured}, |
| 311 | {"removal-failed",pkgCache::State::HalfInstalled}, |
| 312 | {}}; |
| 313 | if (GrabWord(string(Start,I-Start),StatusList,Pkg->CurrentState) == false) |
| 314 | return _error->Error("Malformed 3rd word in the Status line"); |
| 315 | |
| 316 | /* A Status line marks the package as indicating the current |
| 317 | version as well. Only if it is actually installed.. Otherwise |
| 318 | the interesting dpkg handling of the status file creates bogus |
| 319 | entries. */ |
| 320 | if (!(Pkg->CurrentState == pkgCache::State::NotInstalled || |
| 321 | Pkg->CurrentState == pkgCache::State::ConfigFiles)) |
| 322 | { |
| 323 | if (Ver.end() == true) |
| 324 | _error->Warning("Encountered status field in a non-version description"); |
| 325 | else |
| 326 | Pkg->CurrentVer = Ver.Index(); |
| 327 | } |
| 328 | |
| 329 | return true; |
| 330 | } |
| 331 | |
| 332 | const char *debListParser::ConvertRelation(const char *I,unsigned int &Op) |
| 333 | { |
| 334 | // Determine the operator |
| 335 | switch (*I) |
| 336 | { |
| 337 | case '<': |
| 338 | I++; |
| 339 | if (*I == '=') |
| 340 | { |
| 341 | I++; |
| 342 | Op = pkgCache::Dep::LessEq; |
| 343 | break; |
| 344 | } |
| 345 | |
| 346 | if (*I == '<') |
| 347 | { |
| 348 | I++; |
| 349 | Op = pkgCache::Dep::Less; |
| 350 | break; |
| 351 | } |
| 352 | |
| 353 | // < is the same as <= and << is really Cs < for some reason |
| 354 | Op = pkgCache::Dep::LessEq; |
| 355 | break; |
| 356 | |
| 357 | case '>': |
| 358 | I++; |
| 359 | if (*I == '=') |
| 360 | { |
| 361 | I++; |
| 362 | Op = pkgCache::Dep::GreaterEq; |
| 363 | break; |
| 364 | } |
| 365 | |
| 366 | if (*I == '>') |
| 367 | { |
| 368 | I++; |
| 369 | Op = pkgCache::Dep::Greater; |
| 370 | break; |
| 371 | } |
| 372 | |
| 373 | // > is the same as >= and >> is really Cs > for some reason |
| 374 | Op = pkgCache::Dep::GreaterEq; |
| 375 | break; |
| 376 | |
| 377 | case '=': |
| 378 | Op = pkgCache::Dep::Equals; |
| 379 | I++; |
| 380 | break; |
| 381 | |
| 382 | // HACK around bad package definitions |
| 383 | default: |
| 384 | Op = pkgCache::Dep::Equals; |
| 385 | break; |
| 386 | } |
| 387 | return I; |
| 388 | } |
| 389 | |
| 390 | /*}}}*/ |
| 391 | // ListParser::ParseDepends - Parse a dependency element /*{{{*/ |
| 392 | // --------------------------------------------------------------------- |
| 393 | /* This parses the dependency elements out of a standard string in place, |
| 394 | bit by bit. */ |
| 395 | const char *debListParser::ParseDepends(const char *Start,const char *Stop, |
| 396 | string &Package,string &Ver, |
| 397 | unsigned int &Op, bool const &ParseArchFlags, |
| 398 | bool const &StripMultiArch) |
| 399 | { |
| 400 | // Strip off leading space |
| 401 | for (;Start != Stop && isspace(*Start) != 0; Start++); |
| 402 | |
| 403 | // Parse off the package name |
| 404 | const char *I = Start; |
| 405 | for (;I != Stop && isspace(*I) == 0 && *I != '(' && *I != ')' && |
| 406 | *I != ',' && *I != '|'; I++); |
| 407 | |
| 408 | // Malformed, no '(' |
| 409 | if (I != Stop && *I == ')') |
| 410 | return 0; |
| 411 | |
| 412 | if (I == Start) |
| 413 | return 0; |
| 414 | |
| 415 | // Stash the package name |
| 416 | Package.assign(Start,I - Start); |
| 417 | |
| 418 | // We don't want to confuse library users which can't handle MultiArch |
| 419 | if (StripMultiArch == true) { |
| 420 | size_t const found = Package.rfind(':'); |
| 421 | if (found != string::npos) |
| 422 | Package = Package.substr(0,found); |
| 423 | } |
| 424 | |
| 425 | // Skip white space to the '(' |
| 426 | for (;I != Stop && isspace(*I) != 0 ; I++); |
| 427 | |
| 428 | // Parse a version |
| 429 | if (I != Stop && *I == '(') |
| 430 | { |
| 431 | // Skip the '(' |
| 432 | for (I++; I != Stop && isspace(*I) != 0 ; I++); |
| 433 | if (I + 3 >= Stop) |
| 434 | return 0; |
| 435 | I = ConvertRelation(I,Op); |
| 436 | |
| 437 | // Skip whitespace |
| 438 | for (;I != Stop && isspace(*I) != 0; I++); |
| 439 | Start = I; |
| 440 | for (;I != Stop && *I != ')'; I++); |
| 441 | if (I == Stop || Start == I) |
| 442 | return 0; |
| 443 | |
| 444 | // Skip trailing whitespace |
| 445 | const char *End = I; |
| 446 | for (; End > Start && isspace(End[-1]); End--); |
| 447 | |
| 448 | Ver.assign(Start,End-Start); |
| 449 | I++; |
| 450 | } |
| 451 | else |
| 452 | { |
| 453 | Ver.clear(); |
| 454 | Op = pkgCache::Dep::NoOp; |
| 455 | } |
| 456 | |
| 457 | // Skip whitespace |
| 458 | for (;I != Stop && isspace(*I) != 0; I++); |
| 459 | |
| 460 | if (ParseArchFlags == true) |
| 461 | { |
| 462 | string arch = _config->Find("APT::Architecture"); |
| 463 | |
| 464 | // Parse an architecture |
| 465 | if (I != Stop && *I == '[') |
| 466 | { |
| 467 | // malformed |
| 468 | I++; |
| 469 | if (I == Stop) |
| 470 | return 0; |
| 471 | |
| 472 | const char *End = I; |
| 473 | bool Found = false; |
| 474 | bool NegArch = false; |
| 475 | while (I != Stop) |
| 476 | { |
| 477 | // look for whitespace or ending ']' |
| 478 | while (End != Stop && !isspace(*End) && *End != ']') |
| 479 | End++; |
| 480 | |
| 481 | if (End == Stop) |
| 482 | return 0; |
| 483 | |
| 484 | if (*I == '!') |
| 485 | { |
| 486 | NegArch = true; |
| 487 | I++; |
| 488 | } |
| 489 | |
| 490 | if (stringcmp(arch,I,End) == 0) |
| 491 | Found = true; |
| 492 | |
| 493 | if (*End++ == ']') { |
| 494 | I = End; |
| 495 | break; |
| 496 | } |
| 497 | |
| 498 | I = End; |
| 499 | for (;I != Stop && isspace(*I) != 0; I++); |
| 500 | } |
| 501 | |
| 502 | if (NegArch) |
| 503 | Found = !Found; |
| 504 | |
| 505 | if (Found == false) |
| 506 | Package = ""; /* not for this arch */ |
| 507 | } |
| 508 | |
| 509 | // Skip whitespace |
| 510 | for (;I != Stop && isspace(*I) != 0; I++); |
| 511 | } |
| 512 | |
| 513 | if (I != Stop && *I == '|') |
| 514 | Op |= pkgCache::Dep::Or; |
| 515 | |
| 516 | if (I == Stop || *I == ',' || *I == '|') |
| 517 | { |
| 518 | if (I != Stop) |
| 519 | for (I++; I != Stop && isspace(*I) != 0; I++); |
| 520 | return I; |
| 521 | } |
| 522 | |
| 523 | return 0; |
| 524 | } |
| 525 | /*}}}*/ |
| 526 | // ListParser::ParseDepends - Parse a dependency list /*{{{*/ |
| 527 | // --------------------------------------------------------------------- |
| 528 | /* This is the higher level depends parser. It takes a tag and generates |
| 529 | a complete depends tree for the given version. */ |
| 530 | bool debListParser::ParseDepends(pkgCache::VerIterator Ver, |
| 531 | const char *Tag,unsigned int Type) |
| 532 | { |
| 533 | const char *Start; |
| 534 | const char *Stop; |
| 535 | if (Section.Find(Tag,Start,Stop) == false) |
| 536 | return true; |
| 537 | |
| 538 | string Package; |
| 539 | string Version; |
| 540 | unsigned int Op; |
| 541 | |
| 542 | while (1) |
| 543 | { |
| 544 | Start = ParseDepends(Start,Stop,Package,Version,Op); |
| 545 | if (Start == 0) |
| 546 | return _error->Error("Problem parsing dependency %s",Tag); |
| 547 | |
| 548 | if (NewDepends(Ver,Package,Version,Op,Type) == false) |
| 549 | return false; |
| 550 | if (Start == Stop) |
| 551 | break; |
| 552 | } |
| 553 | return true; |
| 554 | } |
| 555 | /*}}}*/ |
| 556 | // ListParser::ParseProvides - Parse the provides list /*{{{*/ |
| 557 | // --------------------------------------------------------------------- |
| 558 | /* */ |
| 559 | bool debListParser::ParseProvides(pkgCache::VerIterator Ver) |
| 560 | { |
| 561 | const char *Start; |
| 562 | const char *Stop; |
| 563 | if (Section.Find("Provides",Start,Stop) == false) |
| 564 | return true; |
| 565 | |
| 566 | string Package; |
| 567 | string Version; |
| 568 | unsigned int Op; |
| 569 | |
| 570 | while (1) |
| 571 | { |
| 572 | Start = ParseDepends(Start,Stop,Package,Version,Op); |
| 573 | if (Start == 0) |
| 574 | return _error->Error("Problem parsing Provides line"); |
| 575 | if (Op != pkgCache::Dep::NoOp) { |
| 576 | _error->Warning("Ignoring Provides line with DepCompareOp for package %s", Package.c_str()); |
| 577 | } else { |
| 578 | if (NewProvides(Ver,Package,Version) == false) |
| 579 | return false; |
| 580 | } |
| 581 | |
| 582 | if (Start == Stop) |
| 583 | break; |
| 584 | } |
| 585 | |
| 586 | return true; |
| 587 | } |
| 588 | /*}}}*/ |
| 589 | // ListParser::GrabWord - Matches a word and returns /*{{{*/ |
| 590 | // --------------------------------------------------------------------- |
| 591 | /* Looks for a word in a list of words - for ParseStatus */ |
| 592 | bool debListParser::GrabWord(string Word,WordList *List,unsigned char &Out) |
| 593 | { |
| 594 | for (unsigned int C = 0; List[C].Str != 0; C++) |
| 595 | { |
| 596 | if (strcasecmp(Word.c_str(),List[C].Str) == 0) |
| 597 | { |
| 598 | Out = List[C].Val; |
| 599 | return true; |
| 600 | } |
| 601 | } |
| 602 | return false; |
| 603 | } |
| 604 | /*}}}*/ |
| 605 | // ListParser::Step - Move to the next section in the file /*{{{*/ |
| 606 | // --------------------------------------------------------------------- |
| 607 | /* This has to be carefull to only process the correct architecture */ |
| 608 | bool debListParser::Step() |
| 609 | { |
| 610 | iOffset = Tags.Offset(); |
| 611 | while (Tags.Step(Section) == true) |
| 612 | { |
| 613 | /* See if this is the correct Architecture, if it isn't then we |
| 614 | drop the whole section. A missing arch tag only happens (in theory) |
| 615 | inside the Status file, so that is a positive return */ |
| 616 | const char *Start; |
| 617 | const char *Stop; |
| 618 | if (Section.Find("Architecture",Start,Stop) == false) |
| 619 | return true; |
| 620 | |
| 621 | if (stringcmp(Arch,Start,Stop) == 0) |
| 622 | return true; |
| 623 | |
| 624 | if (stringcmp(Start,Stop,"all") == 0) |
| 625 | return true; |
| 626 | |
| 627 | iOffset = Tags.Offset(); |
| 628 | } |
| 629 | return false; |
| 630 | } |
| 631 | /*}}}*/ |
| 632 | // ListParser::LoadReleaseInfo - Load the release information /*{{{*/ |
| 633 | // --------------------------------------------------------------------- |
| 634 | /* */ |
| 635 | bool debListParser::LoadReleaseInfo(pkgCache::PkgFileIterator FileI, |
| 636 | FileFd &File, string component) |
| 637 | { |
| 638 | pkgTagFile Tags(&File, File.Size() + 256); // XXX |
| 639 | pkgTagSection Section; |
| 640 | if (Tags.Step(Section) == false) |
| 641 | return false; |
| 642 | |
| 643 | //mvo: I don't think we need to fill that in (it's unused since apt-0.6) |
| 644 | //FileI->Architecture = WriteUniqString(Arch); |
| 645 | |
| 646 | // apt-secure does no longer download individual (per-section) Release |
| 647 | // file. to provide Component pinning we use the section name now |
| 648 | FileI->Component = WriteUniqString(component); |
| 649 | |
| 650 | const char *Start; |
| 651 | const char *Stop; |
| 652 | if (Section.Find("Suite",Start,Stop) == true) |
| 653 | FileI->Archive = WriteUniqString(Start,Stop - Start); |
| 654 | if (Section.Find("Component",Start,Stop) == true) |
| 655 | FileI->Component = WriteUniqString(Start,Stop - Start); |
| 656 | if (Section.Find("Version",Start,Stop) == true) |
| 657 | FileI->Version = WriteUniqString(Start,Stop - Start); |
| 658 | if (Section.Find("Origin",Start,Stop) == true) |
| 659 | FileI->Origin = WriteUniqString(Start,Stop - Start); |
| 660 | if (Section.Find("Codename",Start,Stop) == true) |
| 661 | FileI->Codename = WriteUniqString(Start,Stop - Start); |
| 662 | if (Section.Find("Label",Start,Stop) == true) |
| 663 | FileI->Label = WriteUniqString(Start,Stop - Start); |
| 664 | if (Section.Find("Architecture",Start,Stop) == true) |
| 665 | FileI->Architecture = WriteUniqString(Start,Stop - Start); |
| 666 | |
| 667 | if (Section.FindFlag("NotAutomatic",FileI->Flags, |
| 668 | pkgCache::Flag::NotAutomatic) == false) |
| 669 | _error->Warning("Bad NotAutomatic flag"); |
| 670 | |
| 671 | return !_error->PendingError(); |
| 672 | } |
| 673 | /*}}}*/ |
| 674 | // ListParser::GetPrio - Convert the priority from a string /*{{{*/ |
| 675 | // --------------------------------------------------------------------- |
| 676 | /* */ |
| 677 | unsigned char debListParser::GetPrio(string Str) |
| 678 | { |
| 679 | unsigned char Out; |
| 680 | if (GrabWord(Str,PrioList,Out) == false) |
| 681 | Out = pkgCache::State::Extra; |
| 682 | |
| 683 | return Out; |
| 684 | } |
| 685 | /*}}}*/ |