1 // -*- mode: cpp; mode: fold -*-
3 // $Id: strutl.cc,v 1.48 2003/07/18 14:15:11 mdz Exp $
4 /* ######################################################################
6 String Util - Some useful string functions.
8 These have been collected from here and there to do all sorts of useful
9 things to strings. They are useful in file parsers, URI handlers and
10 especially in APT methods.
12 This source is placed in the Public Domain, do with it what you will
13 It was originally written by Jason Gunthorpe <jgg@gpu.srv.ualberta.ca>
15 ##################################################################### */
20 #include <apt-pkg/strutl.h>
21 #include <apt-pkg/fileutl.h>
22 #include <apt-pkg/error.h>
47 // Strip - Remove white space from the front and back of a string /*{{{*/
48 // ---------------------------------------------------------------------
51 std::string
Strip(const std::string
&str
)
53 // ensure we have at least one character
54 if (str
.empty() == true)
57 char const * const s
= str
.c_str();
59 for (; isspace(s
[start
]) != 0; ++start
)
60 ; // find the first not-space
62 // string contains only whitespaces
66 size_t end
= str
.length() - 1;
67 for (; isspace(s
[end
]) != 0; --end
)
68 ; // find the last not-space
70 return str
.substr(start
, end
- start
+ 1);
73 bool Endswith(const std::string
&s
, const std::string
&end
)
75 if (end
.size() > s
.size())
77 return (s
.compare(s
.size() - end
.size(), end
.size(), end
) == 0);
80 bool Startswith(const std::string
&s
, const std::string
&start
)
82 if (start
.size() > s
.size())
84 return (s
.compare(0, start
.size(), start
) == 0);
90 // UTF8ToCodeset - Convert some UTF-8 string for some codeset /*{{{*/
91 // ---------------------------------------------------------------------
92 /* This is handy to use before display some information for enduser */
93 bool UTF8ToCodeset(const char *codeset
, const string
&orig
, string
*dest
)
98 size_t insize
, bufsize
;
101 cd
= iconv_open(codeset
, "UTF-8");
102 if (cd
== (iconv_t
)(-1)) {
103 // Something went wrong
105 _error
->Error("conversion from 'UTF-8' to '%s' not available",
108 perror("iconv_open");
113 insize
= bufsize
= orig
.size();
115 inptr
= (char *)inbuf
;
116 outbuf
= new char[bufsize
];
117 size_t lastError
= -1;
121 char *outptr
= outbuf
;
122 size_t outsize
= bufsize
;
123 size_t const err
= iconv(cd
, &inptr
, &insize
, &outptr
, &outsize
);
124 dest
->append(outbuf
, outptr
- outbuf
);
125 if (err
== (size_t)(-1))
132 // replace a series of unknown multibytes with a single "?"
133 if (lastError
!= insize
) {
134 lastError
= insize
- 1;
142 if (outptr
== outbuf
)
146 outbuf
= new char[bufsize
];
160 // strstrip - Remove white space from the front and back of a string /*{{{*/
161 // ---------------------------------------------------------------------
162 /* This is handy to use when parsing a file. It also removes \n's left
163 over from fgets and company */
164 char *_strstrip(char *String
)
166 for (;*String
!= 0 && (*String
== ' ' || *String
== '\t'); String
++);
170 return _strrstrip(String
);
173 // strrstrip - Remove white space from the back of a string /*{{{*/
174 // ---------------------------------------------------------------------
175 char *_strrstrip(char *String
)
177 char *End
= String
+ strlen(String
) - 1;
178 for (;End
!= String
- 1 && (*End
== ' ' || *End
== '\t' || *End
== '\n' ||
179 *End
== '\r'); End
--);
185 // strtabexpand - Converts tabs into 8 spaces /*{{{*/
186 // ---------------------------------------------------------------------
188 char *_strtabexpand(char *String
,size_t Len
)
190 for (char *I
= String
; I
!= I
+ Len
&& *I
!= 0; I
++)
194 if (I
+ 8 > String
+ Len
)
200 /* Assume the start of the string is 0 and find the next 8 char
206 Len
= 8 - ((String
- I
) % 8);
214 memmove(I
+ Len
,I
+ 1,strlen(I
) + 1);
215 for (char *J
= I
; J
+ Len
!= I
; *I
= ' ', I
++);
220 // ParseQuoteWord - Parse a single word out of a string /*{{{*/
221 // ---------------------------------------------------------------------
222 /* This grabs a single word, converts any % escaped characters to their
223 proper values and advances the pointer. Double quotes are understood
224 and striped out as well. This is for URI/URL parsing. It also can
225 understand [] brackets.*/
226 bool ParseQuoteWord(const char *&String
,string
&Res
)
228 // Skip leading whitespace
229 const char *C
= String
;
230 for (;*C
!= 0 && *C
== ' '; C
++);
234 // Jump to the next word
235 for (;*C
!= 0 && isspace(*C
) == 0; C
++)
239 C
= strchr(C
+ 1, '"');
245 C
= strchr(C
+ 1, ']');
251 // Now de-quote characters
254 const char *Start
= String
;
256 for (I
= Buffer
; I
< Buffer
+ sizeof(Buffer
) && Start
!= C
; I
++)
258 if (*Start
== '%' && Start
+ 2 < C
&&
259 isxdigit(Start
[1]) && isxdigit(Start
[2]))
264 *I
= (char)strtol(Tmp
,0,16);
277 // Skip ending white space
278 for (;*C
!= 0 && isspace(*C
) != 0; C
++);
283 // ParseCWord - Parses a string like a C "" expression /*{{{*/
284 // ---------------------------------------------------------------------
285 /* This expects a series of space separated strings enclosed in ""'s.
286 It concatenates the ""'s into a single string. */
287 bool ParseCWord(const char *&String
,string
&Res
)
289 // Skip leading whitespace
290 const char *C
= String
;
291 for (;*C
!= 0 && *C
== ' '; C
++);
297 if (strlen(String
) >= sizeof(Buffer
))
304 for (C
++; *C
!= 0 && *C
!= '"'; C
++)
313 if (C
!= String
&& isspace(*C
) != 0 && isspace(C
[-1]) != 0)
315 if (isspace(*C
) == 0)
325 // QuoteString - Convert a string into quoted from /*{{{*/
326 // ---------------------------------------------------------------------
328 string
QuoteString(const string
&Str
, const char *Bad
)
330 std::stringstream Res
;
331 for (string::const_iterator I
= Str
.begin(); I
!= Str
.end(); ++I
)
333 if (strchr(Bad
,*I
) != 0 || isprint(*I
) == 0 ||
334 *I
== 0x25 || // percent '%' char
335 *I
<= 0x20 || *I
>= 0x7F) // control chars
337 ioprintf(Res
, "%%%02hhx", *I
);
345 // DeQuoteString - Convert a string from quoted from /*{{{*/
346 // ---------------------------------------------------------------------
347 /* This undoes QuoteString */
348 string
DeQuoteString(const string
&Str
)
350 return DeQuoteString(Str
.begin(),Str
.end());
352 string
DeQuoteString(string::const_iterator
const &begin
,
353 string::const_iterator
const &end
)
356 for (string::const_iterator I
= begin
; I
!= end
; ++I
)
358 if (*I
== '%' && I
+ 2 < end
&&
359 isxdigit(I
[1]) && isxdigit(I
[2]))
365 Res
+= (char)strtol(Tmp
,0,16);
376 // SizeToStr - Convert a long into a human readable size /*{{{*/
377 // ---------------------------------------------------------------------
378 /* A max of 4 digits are shown before conversion to the next highest unit.
379 The max length of the string will be 5 chars unless the size is > 10
381 string
SizeToStr(double Size
)
389 /* bytes, KiloBytes, MegaBytes, GigaBytes, TeraBytes, PetaBytes,
390 ExaBytes, ZettaBytes, YottaBytes */
391 char Ext
[] = {'\0','k','M','G','T','P','E','Z','Y'};
395 if (ASize
< 100 && I
!= 0)
398 strprintf(S
, "%'.1f %c", ASize
, Ext
[I
]);
405 strprintf(S
, "%'.0f %c", ASize
, Ext
[I
]);
414 // TimeToStr - Convert the time into a string /*{{{*/
415 // ---------------------------------------------------------------------
416 /* Converts a number of seconds to a hms format */
417 string
TimeToStr(unsigned long Sec
)
422 //TRANSLATOR: d means days, h means hours, min means minutes, s means seconds
423 strprintf(S
,_("%lid %lih %limin %lis"),Sec
/60/60/24,(Sec
/60/60) % 24,(Sec
/60) % 60,Sec
% 60);
425 else if (Sec
> 60*60)
427 //TRANSLATOR: h means hours, min means minutes, s means seconds
428 strprintf(S
,_("%lih %limin %lis"),Sec
/60/60,(Sec
/60) % 60,Sec
% 60);
432 //TRANSLATOR: min means minutes, s means seconds
433 strprintf(S
,_("%limin %lis"),Sec
/60,Sec
% 60);
437 //TRANSLATOR: s means seconds
438 strprintf(S
,_("%lis"),Sec
);
443 // SubstVar - Substitute a string for another string /*{{{*/
444 // ---------------------------------------------------------------------
445 /* This replaces all occurrences of Subst with Contents in Str. */
446 string
SubstVar(const string
&Str
,const string
&Subst
,const string
&Contents
)
448 if (Subst
.empty() == true)
451 string::size_type Pos
= 0;
452 string::size_type OldPos
= 0;
455 while (OldPos
< Str
.length() &&
456 (Pos
= Str
.find(Subst
,OldPos
)) != string::npos
)
459 Temp
.append(Str
, OldPos
, Pos
- OldPos
);
460 if (Contents
.empty() == false)
461 Temp
.append(Contents
);
462 OldPos
= Pos
+ Subst
.length();
468 if (OldPos
>= Str
.length())
471 Temp
.append(Str
, OldPos
, string::npos
);
474 string
SubstVar(string Str
,const struct SubstVar
*Vars
)
476 for (; Vars
->Subst
!= 0; Vars
++)
477 Str
= SubstVar(Str
,Vars
->Subst
,*Vars
->Contents
);
481 // OutputInDepth - return a string with separator multiplied with depth /*{{{*/
482 // ---------------------------------------------------------------------
483 /* Returns a string with the supplied separator depth + 1 times in it */
484 std::string
OutputInDepth(const unsigned long Depth
, const char* Separator
)
486 std::string output
= "";
487 for(unsigned long d
=Depth
+1; d
> 0; d
--)
488 output
.append(Separator
);
492 // URItoFileName - Convert the uri into a unique file name /*{{{*/
493 // ---------------------------------------------------------------------
494 /* This converts a URI into a safe filename. It quotes all unsafe characters
495 and converts / to _ and removes the scheme identifier. The resulting
496 file name should be unique and never occur again for a different file */
497 string
URItoFileName(const string
&URI
)
499 // Nuke 'sensitive' items
505 // "\x00-\x20{}|\\\\^\\[\\]<>\"\x7F-\xFF";
506 string NewURI
= QuoteString(U
,"\\|{}[]<>\"^~_=!@#$%^&*");
507 replace(NewURI
.begin(),NewURI
.end(),'/','_');
511 // Base64Encode - Base64 Encoding routine for short strings /*{{{*/
512 // ---------------------------------------------------------------------
513 /* This routine performs a base64 transformation on a string. It was ripped
514 from wget and then patched and bug fixed.
516 This spec can be found in rfc2045 */
517 string
Base64Encode(const string
&S
)
520 static char tbl
[64] = {'A','B','C','D','E','F','G','H',
521 'I','J','K','L','M','N','O','P',
522 'Q','R','S','T','U','V','W','X',
523 'Y','Z','a','b','c','d','e','f',
524 'g','h','i','j','k','l','m','n',
525 'o','p','q','r','s','t','u','v',
526 'w','x','y','z','0','1','2','3',
527 '4','5','6','7','8','9','+','/'};
529 // Pre-allocate some space
531 Final
.reserve((4*S
.length() + 2)/3 + 2);
533 /* Transform the 3x8 bits to 4x6 bits, as required by
535 for (string::const_iterator I
= S
.begin(); I
< S
.end(); I
+= 3)
537 char Bits
[3] = {0,0,0};
544 Final
+= tbl
[Bits
[0] >> 2];
545 Final
+= tbl
[((Bits
[0] & 3) << 4) + (Bits
[1] >> 4)];
547 if (I
+ 1 >= S
.end())
550 Final
+= tbl
[((Bits
[1] & 0xf) << 2) + (Bits
[2] >> 6)];
552 if (I
+ 2 >= S
.end())
555 Final
+= tbl
[Bits
[2] & 0x3f];
558 /* Apply the padding elements, this tells how many bytes the remote
559 end should discard */
560 if (S
.length() % 3 == 2)
562 if (S
.length() % 3 == 1)
568 // stringcmp - Arbitrary string compare /*{{{*/
569 // ---------------------------------------------------------------------
570 /* This safely compares two non-null terminated strings of arbitrary
572 int stringcmp(const char *A
,const char *AEnd
,const char *B
,const char *BEnd
)
574 for (; A
!= AEnd
&& B
!= BEnd
; A
++, B
++)
578 if (A
== AEnd
&& B
== BEnd
)
590 int stringcmp(string::const_iterator A
,string::const_iterator AEnd
,
591 const char *B
,const char *BEnd
)
593 for (; A
!= AEnd
&& B
!= BEnd
; A
++, B
++)
597 if (A
== AEnd
&& B
== BEnd
)
607 int stringcmp(string::const_iterator A
,string::const_iterator AEnd
,
608 string::const_iterator B
,string::const_iterator BEnd
)
610 for (; A
!= AEnd
&& B
!= BEnd
; A
++, B
++)
614 if (A
== AEnd
&& B
== BEnd
)
626 // stringcasecmp - Arbitrary case insensitive string compare /*{{{*/
627 // ---------------------------------------------------------------------
629 int stringcasecmp(const char *A
,const char *AEnd
,const char *B
,const char *BEnd
)
631 for (; A
!= AEnd
&& B
!= BEnd
; A
++, B
++)
632 if (tolower_ascii(*A
) != tolower_ascii(*B
))
635 if (A
== AEnd
&& B
== BEnd
)
641 if (tolower_ascii(*A
) < tolower_ascii(*B
))
646 int stringcasecmp(string::const_iterator A
,string::const_iterator AEnd
,
647 const char *B
,const char *BEnd
)
649 for (; A
!= AEnd
&& B
!= BEnd
; A
++, B
++)
650 if (tolower_ascii(*A
) != tolower_ascii(*B
))
653 if (A
== AEnd
&& B
== BEnd
)
659 if (tolower_ascii(*A
) < tolower_ascii(*B
))
663 int stringcasecmp(string::const_iterator A
,string::const_iterator AEnd
,
664 string::const_iterator B
,string::const_iterator BEnd
)
666 for (; A
!= AEnd
&& B
!= BEnd
; A
++, B
++)
667 if (tolower_ascii(*A
) != tolower_ascii(*B
))
670 if (A
== AEnd
&& B
== BEnd
)
676 if (tolower_ascii(*A
) < tolower_ascii(*B
))
682 // LookupTag - Lookup the value of a tag in a taged string /*{{{*/
683 // ---------------------------------------------------------------------
684 /* The format is like those used in package files and the method
685 communication system */
686 string
LookupTag(const string
&Message
,const char *Tag
,const char *Default
)
688 // Look for a matching tag.
689 int Length
= strlen(Tag
);
690 for (string::const_iterator I
= Message
.begin(); I
+ Length
< Message
.end(); ++I
)
693 if (I
[Length
] == ':' && stringcasecmp(I
,I
+Length
,Tag
) == 0)
695 // Find the end of line and strip the leading/trailing spaces
696 string::const_iterator J
;
698 for (; isspace_ascii(*I
) != 0 && I
< Message
.end(); ++I
);
699 for (J
= I
; *J
!= '\n' && J
< Message
.end(); ++J
);
700 for (; J
> I
&& isspace_ascii(J
[-1]) != 0; --J
);
705 for (; *I
!= '\n' && I
< Message
.end(); ++I
);
708 // Failed to find a match
714 // StringToBool - Converts a string into a boolean /*{{{*/
715 // ---------------------------------------------------------------------
716 /* This inspects the string to see if it is true or if it is false and
717 then returns the result. Several varients on true/false are checked. */
718 int StringToBool(const string
&Text
,int Default
)
721 int Res
= strtol(Text
.c_str(),&ParseEnd
,0);
722 // ensure that the entire string was converted by strtol to avoid
723 // failures on "apt-cache show -a 0ad" where the "0" is converted
724 const char *TextEnd
= Text
.c_str()+Text
.size();
725 if (ParseEnd
== TextEnd
&& Res
>= 0 && Res
<= 1)
728 // Check for positives
729 if (strcasecmp(Text
.c_str(),"no") == 0 ||
730 strcasecmp(Text
.c_str(),"false") == 0 ||
731 strcasecmp(Text
.c_str(),"without") == 0 ||
732 strcasecmp(Text
.c_str(),"off") == 0 ||
733 strcasecmp(Text
.c_str(),"disable") == 0)
736 // Check for negatives
737 if (strcasecmp(Text
.c_str(),"yes") == 0 ||
738 strcasecmp(Text
.c_str(),"true") == 0 ||
739 strcasecmp(Text
.c_str(),"with") == 0 ||
740 strcasecmp(Text
.c_str(),"on") == 0 ||
741 strcasecmp(Text
.c_str(),"enable") == 0)
747 // TimeRFC1123 - Convert a time_t into RFC1123 format /*{{{*/
748 // ---------------------------------------------------------------------
749 /* This converts a time_t into a string time representation that is
750 year 2000 complient and timezone neutral */
751 string
TimeRFC1123(time_t Date
)
754 if (gmtime_r(&Date
, &Conv
) == NULL
)
757 auto const posix
= std::locale("C.UTF-8");
758 std::ostringstream datestr
;
759 datestr
.imbue(posix
);
760 datestr
<< std::put_time(&Conv
, "%a, %d %b %Y %H:%M:%S GMT");
761 return datestr
.str();
764 // ReadMessages - Read messages from the FD /*{{{*/
765 // ---------------------------------------------------------------------
766 /* This pulls full messages from the input FD into the message buffer.
767 It assumes that messages will not pause during transit so no
768 fancy buffering is used.
770 In particular: this reads blocks from the input until it believes
771 that it's run out of input text. Each block is terminated by a
772 double newline ('\n' followed by '\n').
774 bool ReadMessages(int Fd
, vector
<string
> &List
)
777 // Represents any left-over from the previous iteration of the
778 // parse loop. (i.e., if a message is split across the end
779 // of the buffer, it goes here)
780 string PartialMessage
;
783 int const Res
= read(Fd
, Buffer
, sizeof(Buffer
));
784 if (Res
< 0 && errno
== EINTR
)
787 // process we read from has died
792 #if EAGAIN != EWOULDBLOCK
793 if (Res
< 0 && (errno
== EAGAIN
|| errno
== EWOULDBLOCK
))
795 if (Res
< 0 && errno
== EAGAIN
)
801 // extract the message(s) from the buffer
802 char const *Start
= Buffer
;
803 char const * const End
= Buffer
+ Res
;
805 char const * NL
= (char const *) memchr(Start
, '\n', End
- Start
);
808 // end of buffer: store what we have so far and read new data in
809 PartialMessage
.append(Start
, End
- Start
);
815 if (PartialMessage
.empty() == false && Start
< End
)
817 // if we start with a new line, see if the partial message we have ended with one
818 // so that we properly detect records ending between two read() runs
819 // cases are: \n|\n , \r\n|\r\n and \r\n\r|\n
820 // the case \r|\n\r\n is handled by the usual double-newline handling
821 if ((NL
- Start
) == 1 || ((NL
- Start
) == 2 && *Start
== '\r'))
823 if (APT::String::Endswith(PartialMessage
, "\n") || APT::String::Endswith(PartialMessage
, "\r\n\r"))
825 PartialMessage
.erase(PartialMessage
.find_last_not_of("\r\n") + 1);
826 List
.push_back(PartialMessage
);
827 PartialMessage
.clear();
828 while (NL
< End
&& (*NL
== '\n' || *NL
== '\r')) ++NL
;
834 while (Start
< End
) {
835 char const * NL2
= (char const *) memchr(NL
, '\n', End
- NL
);
838 // end of buffer: store what we have so far and read new data in
839 PartialMessage
.append(Start
, End
- Start
);
844 // did we find a double newline?
845 if ((NL2
- NL
) == 1 || ((NL2
- NL
) == 2 && *NL
== '\r'))
847 PartialMessage
.append(Start
, NL2
- Start
);
848 PartialMessage
.erase(PartialMessage
.find_last_not_of("\r\n") + 1);
849 List
.push_back(PartialMessage
);
850 PartialMessage
.clear();
851 while (NL2
< End
&& (*NL2
== '\n' || *NL2
== '\r')) ++NL2
;
857 // we have read at least one complete message and nothing left
858 if (PartialMessage
.empty() == true)
861 if (WaitFd(Fd
) == false)
866 // MonthConv - Converts a month string into a number /*{{{*/
867 // ---------------------------------------------------------------------
868 /* This was lifted from the boa webserver which lifted it from 'wn-v1.07'
869 Made it a bit more robust with a few tolower_ascii though. */
870 static int MonthConv(char *Month
)
872 switch (tolower_ascii(*Month
))
875 return tolower_ascii(Month
[1]) == 'p'?3:7;
881 if (tolower_ascii(Month
[1]) == 'a')
883 return tolower_ascii(Month
[2]) == 'n'?5:6;
885 return tolower_ascii(Month
[2]) == 'r'?2:4;
893 // Pretend it is January..
899 // timegm - Internal timegm if the gnu version is not available /*{{{*/
900 // ---------------------------------------------------------------------
901 /* Converts struct tm to time_t, assuming the data in tm is UTC rather
902 than local timezone (mktime assumes the latter).
904 This function is a nonstandard GNU extension that is also present on
905 the BSDs and maybe other systems. For others we follow the advice of
906 the manpage of timegm and use his portable replacement. */
908 static time_t timegm(struct tm
*t
)
910 char *tz
= getenv("TZ");
913 time_t ret
= mktime(t
);
923 // RFC1123StrToTime - Converts a HTTP1.1 full date strings into a time_t /*{{{*/
924 // ---------------------------------------------------------------------
925 /* tries to parses a full date as specified in RFC7231 §7.1.1.1
926 with one exception: HTTP/1.1 valid dates need to have GMT as timezone.
927 As we encounter dates from UTC or with a numeric timezone in other places,
928 we allow them here to to be able to reuse the method. Either way, a date
929 must be in UTC or parsing will fail. Previous implementations of this
930 method used to ignore the timezone and assume always UTC. */
931 bool RFC1123StrToTime(const char* const str
,time_t &time
)
934 auto const &posix
= std::locale("C.UTF-8");
935 auto const parse_time
= [&](char const * const s
, bool const has_timezone
) {
936 std::istringstream
ss(str
);
938 ss
>> std::get_time(&t
, s
);
939 if (has_timezone
&& ss
.fail() == false)
941 std::string timezone
;
943 if (timezone
.empty())
945 if (timezone
!= "GMT" && timezone
!= "UTC" && timezone
!= "Z") // RFC 822
947 // numeric timezones as a should of RFC 1123 and generally preferred
950 auto const zone
= std::stoi(timezone
, &pos
);
951 if (zone
!= 0 || pos
!= timezone
.length())
959 return ss
.fail() == false;
963 // Sun, 06 Nov 1994 08:49:37 GMT ; RFC 822, updated by RFC 1123
964 parse_time("%a, %d %b %Y %H:%M:%S", true) ||
965 // Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036
966 parse_time("%A, %d-%b-%y %H:%M:%S", true) ||
967 // Sun Nov 6 08:49:37 1994 ; ANSI C's asctime() format
968 parse_time("%c", false); // "%a %b %d %H:%M:%S %Y"
976 // FTPMDTMStrToTime - Converts a ftp modification date into a time_t /*{{{*/
977 // ---------------------------------------------------------------------
979 bool FTPMDTMStrToTime(const char* const str
,time_t &time
)
982 // MDTM includes no whitespaces but recommend and ignored by strptime
983 if (strptime(str
, "%Y %m %d %H %M %S", &Tm
) == NULL
)
990 // StrToTime - Converts a string into a time_t /*{{{*/
991 // ---------------------------------------------------------------------
992 /* This handles all 3 popular time formats including RFC 1123, RFC 1036
993 and the C library asctime format. It requires the GNU library function
994 'timegm' to convert a struct tm in UTC to a time_t. For some bizzar
995 reason the C library does not provide any such function :< This also
996 handles the weird, but unambiguous FTP time format*/
997 bool StrToTime(const string
&Val
,time_t &Result
)
1002 // Skip the day of the week
1003 const char *I
= strchr(Val
.c_str(), ' ');
1005 // Handle RFC 1123 time
1007 if (sscanf(I
," %2d %3s %4d %2d:%2d:%2d GMT",&Tm
.tm_mday
,Month
,&Tm
.tm_year
,
1008 &Tm
.tm_hour
,&Tm
.tm_min
,&Tm
.tm_sec
) != 6)
1010 // Handle RFC 1036 time
1011 if (sscanf(I
," %2d-%3s-%3d %2d:%2d:%2d GMT",&Tm
.tm_mday
,Month
,
1012 &Tm
.tm_year
,&Tm
.tm_hour
,&Tm
.tm_min
,&Tm
.tm_sec
) == 6)
1017 if (sscanf(I
," %3s %2d %2d:%2d:%2d %4d",Month
,&Tm
.tm_mday
,
1018 &Tm
.tm_hour
,&Tm
.tm_min
,&Tm
.tm_sec
,&Tm
.tm_year
) != 6)
1021 if (sscanf(Val
.c_str(),"%4d%2d%2d%2d%2d%2d",&Tm
.tm_year
,&Tm
.tm_mon
,
1022 &Tm
.tm_mday
,&Tm
.tm_hour
,&Tm
.tm_min
,&Tm
.tm_sec
) != 6)
1031 Tm
.tm_mon
= MonthConv(Month
);
1033 Tm
.tm_mon
= 0; // we don't have a month, so pick something
1036 // Convert to local time and then to GMT
1037 Result
= timegm(&Tm
);
1041 // StrToNum - Convert a fixed length string to a number /*{{{*/
1042 // ---------------------------------------------------------------------
1043 /* This is used in decoding the crazy fixed length string headers in
1044 tar and ar files. */
1045 bool StrToNum(const char *Str
,unsigned long &Res
,unsigned Len
,unsigned Base
)
1048 if (Len
>= sizeof(S
))
1053 // All spaces is a zero
1056 for (I
= 0; S
[I
] == ' '; I
++);
1061 Res
= strtoul(S
,&End
,Base
);
1068 // StrToNum - Convert a fixed length string to a number /*{{{*/
1069 // ---------------------------------------------------------------------
1070 /* This is used in decoding the crazy fixed length string headers in
1071 tar and ar files. */
1072 bool StrToNum(const char *Str
,unsigned long long &Res
,unsigned Len
,unsigned Base
)
1075 if (Len
>= sizeof(S
))
1080 // All spaces is a zero
1083 for (I
= 0; S
[I
] == ' '; I
++);
1088 Res
= strtoull(S
,&End
,Base
);
1096 // Base256ToNum - Convert a fixed length binary to a number /*{{{*/
1097 // ---------------------------------------------------------------------
1098 /* This is used in decoding the 256bit encoded fixed length fields in
1100 bool Base256ToNum(const char *Str
,unsigned long long &Res
,unsigned int Len
)
1102 if ((Str
[0] & 0x80) == 0)
1106 Res
= Str
[0] & 0x7F;
1107 for(unsigned int i
= 1; i
< Len
; ++i
)
1108 Res
= (Res
<<8) + Str
[i
];
1113 // Base256ToNum - Convert a fixed length binary to a number /*{{{*/
1114 // ---------------------------------------------------------------------
1115 /* This is used in decoding the 256bit encoded fixed length fields in
1117 bool Base256ToNum(const char *Str
,unsigned long &Res
,unsigned int Len
)
1119 unsigned long long Num
;
1122 rc
= Base256ToNum(Str
, Num
, Len
);
1130 // HexDigit - Convert a hex character into an integer /*{{{*/
1131 // ---------------------------------------------------------------------
1132 /* Helper for Hex2Num */
1133 static int HexDigit(int c
)
1135 if (c
>= '0' && c
<= '9')
1137 if (c
>= 'a' && c
<= 'f')
1138 return c
- 'a' + 10;
1139 if (c
>= 'A' && c
<= 'F')
1140 return c
- 'A' + 10;
1144 // Hex2Num - Convert a long hex number into a buffer /*{{{*/
1145 // ---------------------------------------------------------------------
1146 /* The length of the buffer must be exactly 1/2 the length of the string. */
1147 bool Hex2Num(const string
&Str
,unsigned char *Num
,unsigned int Length
)
1149 return Hex2Num(APT::StringView(Str
), Num
, Length
);
1152 bool Hex2Num(const APT::StringView Str
,unsigned char *Num
,unsigned int Length
)
1154 if (Str
.length() != Length
*2)
1157 // Convert each digit. We store it in the same order as the string
1159 for (auto I
= Str
.begin(); I
!= Str
.end();J
++, I
+= 2)
1161 int first_half
= HexDigit(I
[0]);
1166 second_half
= HexDigit(I
[1]);
1167 if (second_half
< 0)
1169 Num
[J
] = first_half
<< 4;
1170 Num
[J
] += second_half
;
1176 // TokSplitString - Split a string up by a given token /*{{{*/
1177 // ---------------------------------------------------------------------
1178 /* This is intended to be a faster splitter, it does not use dynamic
1179 memories. Input is changed to insert nulls at each token location. */
1180 bool TokSplitString(char Tok
,char *Input
,char **List
,
1181 unsigned long ListMax
)
1183 // Strip any leading spaces
1184 char *Start
= Input
;
1185 char *Stop
= Start
+ strlen(Start
);
1186 for (; *Start
!= 0 && isspace(*Start
) != 0; Start
++);
1188 unsigned long Count
= 0;
1192 // Skip to the next Token
1193 for (; Pos
!= Stop
&& *Pos
!= Tok
; Pos
++);
1195 // Back remove spaces
1197 for (; End
> Start
&& (End
[-1] == Tok
|| isspace(End
[-1]) != 0); End
--);
1200 List
[Count
++] = Start
;
1201 if (Count
>= ListMax
)
1208 for (; Pos
!= Stop
&& (*Pos
== Tok
|| isspace(*Pos
) != 0 || *Pos
== 0); Pos
++);
1216 // VectorizeString - Split a string up into a vector of strings /*{{{*/
1217 // ---------------------------------------------------------------------
1218 /* This can be used to split a given string up into a vector, so the
1219 propose is the same as in the method above and this one is a bit slower
1220 also, but the advantage is that we have an iteratable vector */
1221 vector
<string
> VectorizeString(string
const &haystack
, char const &split
)
1223 vector
<string
> exploded
;
1224 if (haystack
.empty() == true)
1226 string::const_iterator start
= haystack
.begin();
1227 string::const_iterator end
= start
;
1229 for (; end
!= haystack
.end() && *end
!= split
; ++end
);
1230 exploded
.push_back(string(start
, end
));
1232 } while (end
!= haystack
.end() && (++end
) != haystack
.end());
1236 // StringSplit - split a string into a string vector by token /*{{{*/
1237 // ---------------------------------------------------------------------
1238 /* See header for details.
1240 vector
<string
> StringSplit(std::string
const &s
, std::string
const &sep
,
1241 unsigned int maxsplit
)
1243 vector
<string
> split
;
1246 // no separator given, this is bogus
1251 while (pos
!= string::npos
)
1253 pos
= s
.find(sep
, start
);
1254 split
.push_back(s
.substr(start
, pos
-start
));
1256 // if maxsplit is reached, the remaining string is the last item
1257 if(split
.size() >= maxsplit
)
1259 split
[split
.size()-1] = s
.substr(start
);
1262 start
= pos
+sep
.size();
1267 // RegexChoice - Simple regex list/list matcher /*{{{*/
1268 // ---------------------------------------------------------------------
1270 unsigned long RegexChoice(RxChoiceList
*Rxs
,const char **ListBegin
,
1271 const char **ListEnd
)
1273 for (RxChoiceList
*R
= Rxs
; R
->Str
!= 0; R
++)
1276 unsigned long Hits
= 0;
1277 for (; ListBegin
< ListEnd
; ++ListBegin
)
1279 // Check if the name is a regex
1282 for (I
= *ListBegin
; *I
!= 0; I
++)
1283 if (*I
== '.' || *I
== '?' || *I
== '*' || *I
== '|')
1288 // Compile the regex pattern
1291 if (regcomp(&Pattern
,*ListBegin
,REG_EXTENDED
| REG_ICASE
|
1297 for (RxChoiceList
*R
= Rxs
; R
->Str
!= 0; R
++)
1302 if (strcasecmp(R
->Str
,*ListBegin
) != 0)
1306 if (regexec(&Pattern
,R
->Str
,0,0,0) != 0)
1311 if (R
->Hit
== false)
1321 _error
->Warning(_("Selection %s not found"),*ListBegin
);
1327 // {str,io}printf - C format string outputter to C++ strings/iostreams /*{{{*/
1328 // ---------------------------------------------------------------------
1329 /* This is used to make the internationalization strings easier to translate
1330 and to allow reordering of parameters */
1331 static bool iovprintf(ostream
&out
, const char *format
,
1332 va_list &args
, ssize_t
&size
) {
1333 char *S
= (char*)malloc(size
);
1334 ssize_t
const n
= vsnprintf(S
, size
, format
, args
);
1335 if (n
> -1 && n
< size
) {
1348 void ioprintf(ostream
&out
,const char *format
,...)
1354 va_start(args
,format
);
1355 ret
= iovprintf(out
, format
, args
, size
);
1361 void strprintf(string
&out
,const char *format
,...)
1365 std::ostringstream outstr
;
1368 va_start(args
,format
);
1369 ret
= iovprintf(outstr
, format
, args
, size
);
1377 // safe_snprintf - Safer snprintf /*{{{*/
1378 // ---------------------------------------------------------------------
1379 /* This is a snprintf that will never (ever) go past 'End' and returns a
1380 pointer to the end of the new string. The returned string is always null
1381 terminated unless Buffer == end. This is a better alterantive to using
1382 consecutive snprintfs. */
1383 char *safe_snprintf(char *Buffer
,char *End
,const char *Format
,...)
1390 va_start(args
,Format
);
1391 Did
= vsnprintf(Buffer
,End
- Buffer
,Format
,args
);
1394 if (Did
< 0 || Buffer
+ Did
> End
)
1396 return Buffer
+ Did
;
1399 // StripEpoch - Remove the version "epoch" from a version string /*{{{*/
1400 // ---------------------------------------------------------------------
1401 string
StripEpoch(const string
&VerStr
)
1403 size_t i
= VerStr
.find(":");
1404 if (i
== string::npos
)
1406 return VerStr
.substr(i
+1);
1410 // tolower_ascii - tolower() function that ignores the locale /*{{{*/
1411 // ---------------------------------------------------------------------
1412 /* This little function is the most called method we have and tries
1413 therefore to do the absolut minimum - and is notable faster than
1414 standard tolower/toupper and as a bonus avoids problems with different
1415 locales - we only operate on ascii chars anyway. */
1416 #undef tolower_ascii
1417 int tolower_ascii(int const c
) APT_CONST APT_COLD
;
1418 int tolower_ascii(int const c
)
1420 return tolower_ascii_inline(c
);
1424 // isspace_ascii - isspace() function that ignores the locale /*{{{*/
1425 // ---------------------------------------------------------------------
1426 /* This little function is one of the most called methods we have and tries
1427 therefore to do the absolut minimum - and is notable faster than
1428 standard isspace() and as a bonus avoids problems with different
1429 locales - we only operate on ascii chars anyway. */
1430 #undef isspace_ascii
1431 int isspace_ascii(int const c
) APT_CONST APT_COLD
;
1432 int isspace_ascii(int const c
)
1434 return isspace_ascii_inline(c
);
1438 // CheckDomainList - See if Host is in a , separate list /*{{{*/
1439 // ---------------------------------------------------------------------
1440 /* The domain list is a comma separate list of domains that are suffix
1441 matched against the argument */
1442 bool CheckDomainList(const string
&Host
,const string
&List
)
1444 string::const_iterator Start
= List
.begin();
1445 for (string::const_iterator Cur
= List
.begin(); Cur
<= List
.end(); ++Cur
)
1447 if (Cur
< List
.end() && *Cur
!= ',')
1450 // Match the end of the string..
1451 if ((Host
.size() >= (unsigned)(Cur
- Start
)) &&
1453 stringcasecmp(Host
.end() - (Cur
- Start
),Host
.end(),Start
,Cur
) == 0)
1461 // strv_length - Return the length of a NULL-terminated string array /*{{{*/
1462 // ---------------------------------------------------------------------
1464 size_t strv_length(const char **str_array
)
1467 for (i
=0; str_array
[i
] != NULL
; i
++)
1473 // DeEscapeString - unescape (\0XX and \xXX) from a string /*{{{*/
1474 // ---------------------------------------------------------------------
1476 string
DeEscapeString(const string
&input
)
1479 string::const_iterator it
;
1481 for (it
= input
.begin(); it
!= input
.end(); ++it
)
1483 // just copy non-escape chars
1490 // deal with double escape
1492 (it
+ 1 < input
.end()) && it
[1] == '\\')
1496 // advance iterator one step further
1501 // ensure we have a char to read
1502 if (it
+ 1 == input
.end())
1510 if (it
+ 2 <= input
.end()) {
1514 output
+= (char)strtol(tmp
, 0, 8);
1519 if (it
+ 2 <= input
.end()) {
1523 output
+= (char)strtol(tmp
, 0, 16);
1528 // FIXME: raise exception here?
1535 // URI::CopyFrom - Copy from an object /*{{{*/
1536 // ---------------------------------------------------------------------
1537 /* This parses the URI into all of its components */
1538 void URI::CopyFrom(const string
&U
)
1540 string::const_iterator I
= U
.begin();
1542 // Locate the first colon, this separates the scheme
1543 for (; I
< U
.end() && *I
!= ':' ; ++I
);
1544 string::const_iterator FirstColon
= I
;
1546 /* Determine if this is a host type URI with a leading double //
1547 and then search for the first single / */
1548 string::const_iterator SingleSlash
= I
;
1549 if (I
+ 3 < U
.end() && I
[1] == '/' && I
[2] == '/')
1552 /* Find the / indicating the end of the hostname, ignoring /'s in the
1554 bool InBracket
= false;
1555 for (; SingleSlash
< U
.end() && (*SingleSlash
!= '/' || InBracket
== true); ++SingleSlash
)
1557 if (*SingleSlash
== '[')
1559 if (InBracket
== true && *SingleSlash
== ']')
1563 if (SingleSlash
> U
.end())
1564 SingleSlash
= U
.end();
1566 // We can now write the access and path specifiers
1567 Access
.assign(U
.begin(),FirstColon
);
1568 if (SingleSlash
!= U
.end())
1569 Path
.assign(SingleSlash
,U
.end());
1570 if (Path
.empty() == true)
1573 // Now we attempt to locate a user:pass@host fragment
1574 if (FirstColon
+ 2 <= U
.end() && FirstColon
[1] == '/' && FirstColon
[2] == '/')
1578 if (FirstColon
>= U
.end())
1581 if (FirstColon
> SingleSlash
)
1582 FirstColon
= SingleSlash
;
1584 // Find the colon...
1586 if (I
> SingleSlash
)
1588 for (; I
< SingleSlash
&& *I
!= ':'; ++I
);
1589 string::const_iterator SecondColon
= I
;
1591 // Search for the @ after the colon
1592 for (; I
< SingleSlash
&& *I
!= '@'; ++I
);
1593 string::const_iterator At
= I
;
1595 // Now write the host and user/pass
1596 if (At
== SingleSlash
)
1598 if (FirstColon
< SingleSlash
)
1599 Host
.assign(FirstColon
,SingleSlash
);
1603 Host
.assign(At
+1,SingleSlash
);
1604 // username and password must be encoded (RFC 3986)
1605 User
.assign(DeQuoteString(FirstColon
,SecondColon
));
1606 if (SecondColon
< At
)
1607 Password
.assign(DeQuoteString(SecondColon
+1,At
));
1610 // Now we parse the RFC 2732 [] hostnames.
1611 unsigned long PortEnd
= 0;
1613 for (unsigned I
= 0; I
!= Host
.length();)
1622 if (InBracket
== true && Host
[I
] == ']')
1633 if (InBracket
== true)
1639 // Now we parse off a port number from the hostname
1641 string::size_type Pos
= Host
.rfind(':');
1642 if (Pos
== string::npos
|| Pos
< PortEnd
)
1645 Port
= atoi(string(Host
,Pos
+1).c_str());
1646 Host
.assign(Host
,0,Pos
);
1649 // URI::operator string - Convert the URI to a string /*{{{*/
1650 // ---------------------------------------------------------------------
1652 URI::operator string()
1654 std::stringstream Res
;
1656 if (Access
.empty() == false)
1657 Res
<< Access
<< ':';
1659 if (Host
.empty() == false)
1661 if (Access
.empty() == false)
1664 if (User
.empty() == false)
1666 // FIXME: Technically userinfo is permitted even less
1667 // characters than these, but this is not conveniently
1668 // expressed with a blacklist.
1669 Res
<< QuoteString(User
, ":/?#[]@");
1670 if (Password
.empty() == false)
1671 Res
<< ":" << QuoteString(Password
, ":/?#[]@");
1675 // Add RFC 2732 escaping characters
1676 if (Access
.empty() == false && Host
.find_first_of("/:") != string::npos
)
1677 Res
<< '[' << Host
<< ']';
1682 Res
<< ':' << std::to_string(Port
);
1685 if (Path
.empty() == false)
1696 // URI::SiteOnly - Return the schema and site for the URI /*{{{*/
1697 string
URI::SiteOnly(const string
&URI
)
1706 // URI::ArchiveOnly - Return the schema, site and cleaned path for the URI /*{{{*/
1707 string
URI::ArchiveOnly(const string
&URI
)
1712 if (U
.Path
.empty() == false && U
.Path
[U
.Path
.length() - 1] == '/')
1713 U
.Path
.erase(U
.Path
.length() - 1);
1717 // URI::NoUserPassword - Return the schema, site and path for the URI /*{{{*/
1718 string
URI::NoUserPassword(const string
&URI
)