]> git.saurik.com Git - apt.git/blame_incremental - apt-pkg/tagfile.cc
Merge remote-tracking branch 'mvo/feature/build-dep-dsc2' into debian/experimental
[apt.git] / apt-pkg / tagfile.cc
... / ...
CommitLineData
1// -*- mode: cpp; mode: fold -*-
2// Description /*{{{*/
3// $Id: tagfile.cc,v 1.37.2.2 2003/12/31 16:02:30 mdz Exp $
4/* ######################################################################
5
6 Fast scanner for RFC-822 type header information
7
8 This uses a rotating buffer to load the package information into.
9 The scanner runs over it and isolates and indexes a single section.
10
11 ##################################################################### */
12 /*}}}*/
13// Include Files /*{{{*/
14#include<config.h>
15
16#include <apt-pkg/tagfile.h>
17#include <apt-pkg/error.h>
18#include <apt-pkg/strutl.h>
19#include <apt-pkg/fileutl.h>
20
21#include <string>
22#include <stdio.h>
23#include <ctype.h>
24#include <stdlib.h>
25#include <string.h>
26
27#include <apti18n.h>
28 /*}}}*/
29
30using std::string;
31
32class pkgTagFilePrivate
33{
34public:
35 pkgTagFilePrivate(FileFd *pFd, unsigned long long Size) : Fd(*pFd), Buffer(NULL),
36 Start(NULL), End(NULL),
37 Done(false), iOffset(0),
38 Size(Size)
39 {
40 }
41 FileFd &Fd;
42 char *Buffer;
43 char *Start;
44 char *End;
45 bool Done;
46 unsigned long long iOffset;
47 unsigned long long Size;
48};
49
50// TagFile::pkgTagFile - Constructor /*{{{*/
51// ---------------------------------------------------------------------
52/* */
53pkgTagFile::pkgTagFile(FileFd *pFd,unsigned long long Size)
54 : d(NULL)
55{
56 Init(pFd, Size);
57}
58
59void pkgTagFile::Init(FileFd *pFd,unsigned long long Size)
60{
61 /* The size is increased by 4 because if we start with the Size of the
62 filename we need to try to read 1 char more to see an EOF faster, 1
63 char the end-pointer can be on and maybe 2 newlines need to be added
64 to the end of the file -> 4 extra chars */
65 Size += 4;
66 if(d != NULL)
67 {
68 free(d->Buffer);
69 delete d;
70 }
71 d = new pkgTagFilePrivate(pFd, Size);
72
73 if (d->Fd.IsOpen() == false)
74 d->Start = d->End = d->Buffer = 0;
75 else
76 d->Buffer = (char*)malloc(sizeof(char) * Size);
77
78 if (d->Buffer == NULL)
79 d->Done = true;
80 else
81 d->Done = false;
82
83 d->Start = d->End = d->Buffer;
84 d->iOffset = 0;
85 if (d->Done == false)
86 Fill();
87}
88 /*}}}*/
89// TagFile::~pkgTagFile - Destructor /*{{{*/
90// ---------------------------------------------------------------------
91/* */
92pkgTagFile::~pkgTagFile()
93{
94 free(d->Buffer);
95 delete d;
96}
97 /*}}}*/
98// TagFile::Offset - Return the current offset in the buffer /*{{{*/
99APT_PURE unsigned long pkgTagFile::Offset()
100{
101 return d->iOffset;
102}
103 /*}}}*/
104// TagFile::Resize - Resize the internal buffer /*{{{*/
105// ---------------------------------------------------------------------
106/* Resize the internal buffer (double it in size). Fail if a maximum size
107 * size is reached.
108 */
109bool pkgTagFile::Resize()
110{
111 // fail is the buffer grows too big
112 if(d->Size > 1024*1024+1)
113 return false;
114
115 return Resize(d->Size * 2);
116}
117bool pkgTagFile::Resize(unsigned long long const newSize)
118{
119 unsigned long long const EndSize = d->End - d->Start;
120
121 // get new buffer and use it
122 char* newBuffer = (char*)realloc(d->Buffer, sizeof(char) * newSize);
123 if (newBuffer == NULL)
124 return false;
125 d->Buffer = newBuffer;
126 d->Size = newSize;
127
128 // update the start/end pointers to the new buffer
129 d->Start = d->Buffer;
130 d->End = d->Start + EndSize;
131 return true;
132}
133 /*}}}*/
134// TagFile::Step - Advance to the next section /*{{{*/
135// ---------------------------------------------------------------------
136/* If the Section Scanner fails we refill the buffer and try again.
137 * If that fails too, double the buffer size and try again until a
138 * maximum buffer is reached.
139 */
140bool pkgTagFile::Step(pkgTagSection &Tag)
141{
142 while (Tag.Scan(d->Start,d->End - d->Start) == false)
143 {
144 if (Fill() == false)
145 return false;
146
147 if(Tag.Scan(d->Start,d->End - d->Start))
148 break;
149
150 if (Resize() == false)
151 return _error->Error(_("Unable to parse package file %s (1)"),
152 d->Fd.Name().c_str());
153 }
154 d->Start += Tag.size();
155 d->iOffset += Tag.size();
156
157 Tag.Trim();
158 return true;
159}
160 /*}}}*/
161// TagFile::Fill - Top up the buffer /*{{{*/
162// ---------------------------------------------------------------------
163/* This takes the bit at the end of the buffer and puts it at the start
164 then fills the rest from the file */
165bool pkgTagFile::Fill()
166{
167 unsigned long long EndSize = d->End - d->Start;
168 unsigned long long Actual = 0;
169
170 memmove(d->Buffer,d->Start,EndSize);
171 d->Start = d->Buffer;
172 d->End = d->Buffer + EndSize;
173
174 if (d->Done == false)
175 {
176 // See if only a bit of the file is left
177 unsigned long long const dataSize = d->Size - ((d->End - d->Buffer) + 1);
178 if (d->Fd.Read(d->End, dataSize, &Actual) == false)
179 return false;
180 if (Actual != dataSize)
181 d->Done = true;
182 d->End += Actual;
183 }
184
185 if (d->Done == true)
186 {
187 if (EndSize <= 3 && Actual == 0)
188 return false;
189 if (d->Size - (d->End - d->Buffer) < 4)
190 return true;
191
192 // Append a double new line if one does not exist
193 unsigned int LineCount = 0;
194 for (const char *E = d->End - 1; E - d->End < 6 && (*E == '\n' || *E == '\r'); E--)
195 if (*E == '\n')
196 LineCount++;
197 if (LineCount < 2)
198 {
199 if ((unsigned)(d->End - d->Buffer) >= d->Size)
200 Resize(d->Size + 3);
201 for (; LineCount < 2; LineCount++)
202 *d->End++ = '\n';
203 }
204
205 return true;
206 }
207
208 return true;
209}
210 /*}}}*/
211// TagFile::Jump - Jump to a pre-recorded location in the file /*{{{*/
212// ---------------------------------------------------------------------
213/* This jumps to a pre-recorded file location and reads the record
214 that is there */
215bool pkgTagFile::Jump(pkgTagSection &Tag,unsigned long long Offset)
216{
217 // We are within a buffer space of the next hit..
218 if (Offset >= d->iOffset && d->iOffset + (d->End - d->Start) > Offset)
219 {
220 unsigned long long Dist = Offset - d->iOffset;
221 d->Start += Dist;
222 d->iOffset += Dist;
223 // if we have seen the end, don't ask for more
224 if (d->Done == true)
225 return Tag.Scan(d->Start, d->End - d->Start);
226 else
227 return Step(Tag);
228 }
229
230 // Reposition and reload..
231 d->iOffset = Offset;
232 d->Done = false;
233 if (d->Fd.Seek(Offset) == false)
234 return false;
235 d->End = d->Start = d->Buffer;
236
237 if (Fill() == false)
238 return false;
239
240 if (Tag.Scan(d->Start, d->End - d->Start) == true)
241 return true;
242
243 // This appends a double new line (for the real eof handling)
244 if (Fill() == false)
245 return false;
246
247 if (Tag.Scan(d->Start, d->End - d->Start) == false)
248 return _error->Error(_("Unable to parse package file %s (2)"),d->Fd.Name().c_str());
249
250 return true;
251}
252 /*}}}*/
253// pkgTagSection::pkgTagSection - Constructor /*{{{*/
254// ---------------------------------------------------------------------
255/* */
256pkgTagSection::pkgTagSection()
257 : Section(0), TagCount(0), d(NULL), Stop(0)
258{
259 memset(&Indexes, 0, sizeof(Indexes));
260 memset(&AlphaIndexes, 0, sizeof(AlphaIndexes));
261}
262 /*}}}*/
263// TagSection::Scan - Scan for the end of the header information /*{{{*/
264// ---------------------------------------------------------------------
265/* This looks for the first double new line in the data stream.
266 It also indexes the tags in the section. */
267bool pkgTagSection::Scan(const char *Start,unsigned long MaxLength)
268{
269 const char *End = Start + MaxLength;
270 Stop = Section = Start;
271 memset(AlphaIndexes,0,sizeof(AlphaIndexes));
272
273 if (Stop == 0)
274 return false;
275
276 TagCount = 0;
277 while (TagCount+1 < sizeof(Indexes)/sizeof(Indexes[0]) && Stop < End)
278 {
279 TrimRecord(true,End);
280
281 // this can happen when TrimRecord trims away the entire Record
282 // (e.g. because it just contains comments)
283 if(Stop == End)
284 return true;
285
286 // Start a new index and add it to the hash
287 if (isspace(Stop[0]) == 0)
288 {
289 Indexes[TagCount++] = Stop - Section;
290 AlphaIndexes[AlphaHash(Stop,End)] = TagCount;
291 }
292
293 Stop = (const char *)memchr(Stop,'\n',End - Stop);
294
295 if (Stop == 0)
296 return false;
297
298 for (; Stop+1 < End && Stop[1] == '\r'; Stop++)
299 /* nothing */
300 ;
301
302 // Double newline marks the end of the record
303 if (Stop+1 < End && Stop[1] == '\n')
304 {
305 Indexes[TagCount] = Stop - Section;
306 TrimRecord(false,End);
307 return true;
308 }
309
310 Stop++;
311 }
312
313 return false;
314}
315 /*}}}*/
316// TagSection::TrimRecord - Trim off any garbage before/after a record /*{{{*/
317// ---------------------------------------------------------------------
318/* There should be exactly 2 newline at the end of the record, no more. */
319void pkgTagSection::TrimRecord(bool BeforeRecord, const char*& End)
320{
321 if (BeforeRecord == true)
322 return;
323 for (; Stop < End && (Stop[0] == '\n' || Stop[0] == '\r'); Stop++);
324}
325 /*}}}*/
326// TagSection::Trim - Trim off any trailing garbage /*{{{*/
327// ---------------------------------------------------------------------
328/* There should be exactly 1 newline at the end of the buffer, no more. */
329void pkgTagSection::Trim()
330{
331 for (; Stop > Section + 2 && (Stop[-2] == '\n' || Stop[-2] == '\r'); Stop--);
332}
333 /*}}}*/
334// TagSection::Exists - return True if a tag exists /*{{{*/
335bool pkgTagSection::Exists(const char* const Tag)
336{
337 unsigned int tmp;
338 return Find(Tag, tmp);
339}
340 /*}}}*/
341// TagSection::Find - Locate a tag /*{{{*/
342// ---------------------------------------------------------------------
343/* This searches the section for a tag that matches the given string. */
344bool pkgTagSection::Find(const char *Tag,unsigned int &Pos) const
345{
346 unsigned int Length = strlen(Tag);
347 unsigned int I = AlphaIndexes[AlphaHash(Tag)];
348 if (I == 0)
349 return false;
350 I--;
351
352 for (unsigned int Counter = 0; Counter != TagCount; Counter++,
353 I = (I+1)%TagCount)
354 {
355 const char *St;
356 St = Section + Indexes[I];
357 if (strncasecmp(Tag,St,Length) != 0)
358 continue;
359
360 // Make sure the colon is in the right place
361 const char *C = St + Length;
362 for (; isspace(*C) != 0; C++);
363 if (*C != ':')
364 continue;
365 Pos = I;
366 return true;
367 }
368
369 Pos = 0;
370 return false;
371}
372 /*}}}*/
373// TagSection::Find - Locate a tag /*{{{*/
374// ---------------------------------------------------------------------
375/* This searches the section for a tag that matches the given string. */
376bool pkgTagSection::Find(const char *Tag,const char *&Start,
377 const char *&End) const
378{
379 unsigned int Length = strlen(Tag);
380 unsigned int I = AlphaIndexes[AlphaHash(Tag)];
381 if (I == 0)
382 return false;
383 I--;
384
385 for (unsigned int Counter = 0; Counter != TagCount; Counter++,
386 I = (I+1)%TagCount)
387 {
388 const char *St;
389 St = Section + Indexes[I];
390 if (strncasecmp(Tag,St,Length) != 0)
391 continue;
392
393 // Make sure the colon is in the right place
394 const char *C = St + Length;
395 for (; isspace(*C) != 0; C++);
396 if (*C != ':')
397 continue;
398
399 // Strip off the gunk from the start end
400 Start = C;
401 End = Section + Indexes[I+1];
402 if (Start >= End)
403 return _error->Error("Internal parsing error");
404
405 for (; (isspace(*Start) != 0 || *Start == ':') && Start < End; Start++);
406 for (; isspace(End[-1]) != 0 && End > Start; End--);
407
408 return true;
409 }
410
411 Start = End = 0;
412 return false;
413}
414 /*}}}*/
415// TagSection::FindS - Find a string /*{{{*/
416// ---------------------------------------------------------------------
417/* */
418string pkgTagSection::FindS(const char *Tag) const
419{
420 const char *Start;
421 const char *End;
422 if (Find(Tag,Start,End) == false)
423 return string();
424 return string(Start,End);
425}
426 /*}}}*/
427// TagSection::FindI - Find an integer /*{{{*/
428// ---------------------------------------------------------------------
429/* */
430signed int pkgTagSection::FindI(const char *Tag,signed long Default) const
431{
432 const char *Start;
433 const char *Stop;
434 if (Find(Tag,Start,Stop) == false)
435 return Default;
436
437 // Copy it into a temp buffer so we can use strtol
438 char S[300];
439 if ((unsigned)(Stop - Start) >= sizeof(S))
440 return Default;
441 strncpy(S,Start,Stop-Start);
442 S[Stop - Start] = 0;
443
444 char *End;
445 signed long Result = strtol(S,&End,10);
446 if (S == End)
447 return Default;
448 return Result;
449}
450 /*}}}*/
451// TagSection::FindULL - Find an unsigned long long integer /*{{{*/
452// ---------------------------------------------------------------------
453/* */
454unsigned long long pkgTagSection::FindULL(const char *Tag, unsigned long long const &Default) const
455{
456 const char *Start;
457 const char *Stop;
458 if (Find(Tag,Start,Stop) == false)
459 return Default;
460
461 // Copy it into a temp buffer so we can use strtoull
462 char S[100];
463 if ((unsigned)(Stop - Start) >= sizeof(S))
464 return Default;
465 strncpy(S,Start,Stop-Start);
466 S[Stop - Start] = 0;
467
468 char *End;
469 unsigned long long Result = strtoull(S,&End,10);
470 if (S == End)
471 return Default;
472 return Result;
473}
474 /*}}}*/
475// TagSection::FindFlag - Locate a yes/no type flag /*{{{*/
476// ---------------------------------------------------------------------
477/* The bits marked in Flag are masked on/off in Flags */
478bool pkgTagSection::FindFlag(const char *Tag,unsigned long &Flags,
479 unsigned long Flag) const
480{
481 const char *Start;
482 const char *Stop;
483 if (Find(Tag,Start,Stop) == false)
484 return true;
485 return FindFlag(Flags, Flag, Start, Stop);
486}
487bool pkgTagSection::FindFlag(unsigned long &Flags, unsigned long Flag,
488 char const* Start, char const* Stop)
489{
490 switch (StringToBool(string(Start, Stop)))
491 {
492 case 0:
493 Flags &= ~Flag;
494 return true;
495
496 case 1:
497 Flags |= Flag;
498 return true;
499
500 default:
501 _error->Warning("Unknown flag value: %s",string(Start,Stop).c_str());
502 return true;
503 }
504 return true;
505}
506 /*}}}*/
507// TFRewrite - Rewrite a control record /*{{{*/
508// ---------------------------------------------------------------------
509/* This writes the control record to stdout rewriting it as necessary. The
510 override map item specificies the rewriting rules to follow. This also
511 takes the time to sort the feild list. */
512
513/* The order of this list is taken from dpkg source lib/parse.c the fieldinfos
514 array. */
515static const char *iTFRewritePackageOrder[] = {
516 "Package",
517 "Essential",
518 "Status",
519 "Priority",
520 "Section",
521 "Installed-Size",
522 "Maintainer",
523 "Original-Maintainer",
524 "Architecture",
525 "Source",
526 "Version",
527 "Revision", // Obsolete
528 "Config-Version", // Obsolete
529 "Replaces",
530 "Provides",
531 "Depends",
532 "Pre-Depends",
533 "Recommends",
534 "Suggests",
535 "Conflicts",
536 "Breaks",
537 "Conffiles",
538 "Filename",
539 "Size",
540 "MD5Sum",
541 "SHA1",
542 "SHA256",
543 "SHA512",
544 "MSDOS-Filename", // Obsolete
545 "Description",
546 0};
547static const char *iTFRewriteSourceOrder[] = {"Package",
548 "Source",
549 "Binary",
550 "Version",
551 "Priority",
552 "Section",
553 "Maintainer",
554 "Original-Maintainer",
555 "Build-Depends",
556 "Build-Depends-Indep",
557 "Build-Conflicts",
558 "Build-Conflicts-Indep",
559 "Architecture",
560 "Standards-Version",
561 "Format",
562 "Directory",
563 "Files",
564 0};
565
566/* Two levels of initialization are used because gcc will set the symbol
567 size of an array to the length of the array, causing dynamic relinking
568 errors. Doing this makes the symbol size constant */
569const char **TFRewritePackageOrder = iTFRewritePackageOrder;
570const char **TFRewriteSourceOrder = iTFRewriteSourceOrder;
571
572bool TFRewrite(FILE *Output,pkgTagSection const &Tags,const char *Order[],
573 TFRewriteData *Rewrite)
574{
575 unsigned char Visited[256]; // Bit 1 is Order, Bit 2 is Rewrite
576 for (unsigned I = 0; I != 256; I++)
577 Visited[I] = 0;
578
579 // Set new tag up as necessary.
580 for (unsigned int J = 0; Rewrite != 0 && Rewrite[J].Tag != 0; J++)
581 {
582 if (Rewrite[J].NewTag == 0)
583 Rewrite[J].NewTag = Rewrite[J].Tag;
584 }
585
586 // Write all all of the tags, in order.
587 if (Order != NULL)
588 {
589 for (unsigned int I = 0; Order[I] != 0; I++)
590 {
591 bool Rewritten = false;
592
593 // See if this is a field that needs to be rewritten
594 for (unsigned int J = 0; Rewrite != 0 && Rewrite[J].Tag != 0; J++)
595 {
596 if (strcasecmp(Rewrite[J].Tag,Order[I]) == 0)
597 {
598 Visited[J] |= 2;
599 if (Rewrite[J].Rewrite != 0 && Rewrite[J].Rewrite[0] != 0)
600 {
601 if (isspace(Rewrite[J].Rewrite[0]))
602 fprintf(Output,"%s:%s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
603 else
604 fprintf(Output,"%s: %s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
605 }
606 Rewritten = true;
607 break;
608 }
609 }
610
611 // See if it is in the fragment
612 unsigned Pos;
613 if (Tags.Find(Order[I],Pos) == false)
614 continue;
615 Visited[Pos] |= 1;
616
617 if (Rewritten == true)
618 continue;
619
620 /* Write out this element, taking a moment to rewrite the tag
621 in case of changes of case. */
622 const char *Start;
623 const char *Stop;
624 Tags.Get(Start,Stop,Pos);
625
626 if (fputs(Order[I],Output) < 0)
627 return _error->Errno("fputs","IO Error to output");
628 Start += strlen(Order[I]);
629 if (fwrite(Start,Stop - Start,1,Output) != 1)
630 return _error->Errno("fwrite","IO Error to output");
631 if (Stop[-1] != '\n')
632 fprintf(Output,"\n");
633 }
634 }
635
636 // Now write all the old tags that were missed.
637 for (unsigned int I = 0; I != Tags.Count(); I++)
638 {
639 if ((Visited[I] & 1) == 1)
640 continue;
641
642 const char *Start;
643 const char *Stop;
644 Tags.Get(Start,Stop,I);
645 const char *End = Start;
646 for (; End < Stop && *End != ':'; End++);
647
648 // See if this is a field that needs to be rewritten
649 bool Rewritten = false;
650 for (unsigned int J = 0; Rewrite != 0 && Rewrite[J].Tag != 0; J++)
651 {
652 if (stringcasecmp(Start,End,Rewrite[J].Tag) == 0)
653 {
654 Visited[J] |= 2;
655 if (Rewrite[J].Rewrite != 0 && Rewrite[J].Rewrite[0] != 0)
656 {
657 if (isspace(Rewrite[J].Rewrite[0]))
658 fprintf(Output,"%s:%s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
659 else
660 fprintf(Output,"%s: %s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
661 }
662
663 Rewritten = true;
664 break;
665 }
666 }
667
668 if (Rewritten == true)
669 continue;
670
671 // Write out this element
672 if (fwrite(Start,Stop - Start,1,Output) != 1)
673 return _error->Errno("fwrite","IO Error to output");
674 if (Stop[-1] != '\n')
675 fprintf(Output,"\n");
676 }
677
678 // Now write all the rewrites that were missed
679 for (unsigned int J = 0; Rewrite != 0 && Rewrite[J].Tag != 0; J++)
680 {
681 if ((Visited[J] & 2) == 2)
682 continue;
683
684 if (Rewrite[J].Rewrite != 0 && Rewrite[J].Rewrite[0] != 0)
685 {
686 if (isspace(Rewrite[J].Rewrite[0]))
687 fprintf(Output,"%s:%s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
688 else
689 fprintf(Output,"%s: %s\n",Rewrite[J].NewTag,Rewrite[J].Rewrite);
690 }
691 }
692
693 return true;
694}
695 /*}}}*/