DropPrivs: Document what it does

[apt.git] / apt-pkg / contrib / strutl.cc

diff --git a/apt-pkg/contrib/strutl.cc b/apt-pkg/contrib/strutl.cc
index 0955b69f79a67f538e1af0f59359f543cc3f5bb5..aad358a55d74d72271c21d9a28af3e9f96e60329 100644 (file)
--- a/apt-pkg/contrib/strutl.cc
+++ b/apt-pkg/contrib/strutl.cc
@@ -21,6 +21,11 @@
 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/error.h>
 
 #include <apt-pkg/fileutl.h>
 #include <apt-pkg/error.h>
 

+#include <stddef.h>
+#include <stdlib.h>
+#include <time.h>
+#include <string>
+#include <vector>

 #include <ctype.h>
 #include <string.h>
 #include <sstream>
 #include <ctype.h>
 #include <string.h>
 #include <sstream>


@@ -33,10 +38,52 @@
 #include <iconv.h>
 
 #include <apti18n.h>
 #include <iconv.h>
 
 #include <apti18n.h>

-
-using namespace std;

                                                                        /*}}}*/
                                                                        /*}}}*/

+using namespace std;
+
+// Strip - Remove white space from the front and back of a string       /*{{{*/
+// ---------------------------------------------------------------------
+namespace APT {
+   namespace String {
+std::string Strip(const std::string &str)
+{
+   // ensure we have at least one character
+   if (str.empty() == true)
+      return str;
+
+   char const * const s = str.c_str();
+   size_t start = 0;
+   for (; isspace(s[start]) != 0; ++start)
+      ; // find the first not-space
+
+   // string contains only whitespaces
+   if (s[start] == '\0')
+      return "";
+
+   size_t end = str.length() - 1;
+   for (; isspace(s[end]) != 0; --end)
+      ; // find the last not-space
+
+   return str.substr(start, end - start + 1);
+}
+
+bool Endswith(const std::string &s, const std::string &end)
+{
+   if (end.size() > s.size())
+      return false;
+   return (s.substr(s.size() - end.size(), s.size()) == end);
+}
+
+bool Startswith(const std::string &s, const std::string &start)
+{
+   if (start.size() > s.size())
+      return false;
+   return (s.substr(0, start.size()) == start);
+}

 
 

+}
+}
+                                                                       /*}}}*/

 // UTF8ToCodeset - Convert some UTF-8 string for some codeset          /*{{{*/
 // ---------------------------------------------------------------------
 /* This is handy to use before display some information for enduser  */
 // UTF8ToCodeset - Convert some UTF-8 string for some codeset          /*{{{*/
 // ---------------------------------------------------------------------
 /* This is handy to use before display some information for enduser  */


@@ -130,7 +177,7 @@ char *_strrstrip(char *String)
    End++;
    *End = 0;
    return String;
    End++;
    *End = 0;
    return String;

-};
+}

                                                                        /*}}}*/
 // strtabexpand - Converts tabs into 8 spaces                          /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // strtabexpand - Converts tabs into 8 spaces                          /*{{{*/
 // ---------------------------------------------------------------------


@@ -403,26 +450,33 @@ string TimeToStr(unsigned long Sec)
                                                                        /*}}}*/
 // SubstVar - Substitute a string for another string                   /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // SubstVar - Substitute a string for another string                   /*{{{*/
 // ---------------------------------------------------------------------

-/* This replaces all occurances of Subst with Contents in Str. */
+/* This replaces all occurrences of Subst with Contents in Str. */

 string SubstVar(const string &Str,const string &Subst,const string &Contents)
 {
 string SubstVar(const string &Str,const string &Subst,const string &Contents)
 {

+   if (Subst.empty() == true)
+      return Str;
+

    string::size_type Pos = 0;
    string::size_type OldPos = 0;
    string Temp;
    string::size_type Pos = 0;
    string::size_type OldPos = 0;
    string Temp;

-   
-   while (OldPos < Str.length() && 
+
+   while (OldPos < Str.length() &&

          (Pos = Str.find(Subst,OldPos)) != string::npos)
    {
          (Pos = Str.find(Subst,OldPos)) != string::npos)
    {

-      Temp += string(Str,OldPos,Pos) + Contents;
-      OldPos = Pos + Subst.length();      
+      if (OldPos != Pos)
+        Temp.append(Str, OldPos, Pos - OldPos);
+      if (Contents.empty() == false)
+        Temp.append(Contents);
+      OldPos = Pos + Subst.length();

    }
    }

-   
+

    if (OldPos == 0)
       return Str;
    if (OldPos == 0)
       return Str;

-   
+
+   if (OldPos >= Str.length())
+      return Temp;

    return Temp + string(Str,OldPos);
 }
    return Temp + string(Str,OldPos);
 }

-

 string SubstVar(string Str,const struct SubstVar *Vars)
 {
    for (; Vars->Subst != 0; Vars++)
 string SubstVar(string Str,const struct SubstVar *Vars)
 {
    for (; Vars->Subst != 0; Vars++)


@@ -669,9 +723,12 @@ string LookupTag(const string &Message,const char *Tag,const char *Default)
    then returns the result. Several varients on true/false are checked. */
 int StringToBool(const string &Text,int Default)
 {
    then returns the result. Several varients on true/false are checked. */
 int StringToBool(const string &Text,int Default)
 {

-   char *End;
-   int Res = strtol(Text.c_str(),&End,0);   
-   if (End != Text.c_str() && Res >= 0 && Res <= 1)
+   char *ParseEnd;
+   int Res = strtol(Text.c_str(),&ParseEnd,0);
+   // ensure that the entire string was converted by strtol to avoid
+   // failures on "apt-cache show -a 0ad" where the "0" is converted
+   const char *TextEnd = Text.c_str()+Text.size();
+   if (ParseEnd == TextEnd && Res >= 0 && Res <= 1)

       return Res;
    
    // Check for positives
       return Res;
    
    // Check for positives


@@ -903,7 +960,7 @@ bool FTPMDTMStrToTime(const char* const str,time_t &time)
                                                                        /*}}}*/
 // StrToTime - Converts a string into a time_t                         /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // StrToTime - Converts a string into a time_t                         /*{{{*/
 // ---------------------------------------------------------------------

-/* This handles all 3 populare time formats including RFC 1123, RFC 1036
+/* This handles all 3 popular time formats including RFC 1123, RFC 1036

    and the C library asctime format. It requires the GNU library function
    'timegm' to convert a struct tm in UTC to a time_t. For some bizzar
    reason the C library does not provide any such function :< This also
    and the C library asctime format. It requires the GNU library function
    'timegm' to convert a struct tm in UTC to a time_t. For some bizzar
    reason the C library does not provide any such function :< This also


@@ -1011,7 +1068,7 @@ bool StrToNum(const char *Str,unsigned long long &Res,unsigned Len,unsigned Base
 // ---------------------------------------------------------------------
 /* This is used in decoding the 256bit encoded fixed length fields in
    tar files */
 // ---------------------------------------------------------------------
 /* This is used in decoding the 256bit encoded fixed length fields in
    tar files */

-bool Base256ToNum(const char *Str,unsigned long &Res,unsigned int Len)
+bool Base256ToNum(const char *Str,unsigned long long &Res,unsigned int Len)

 {
    if ((Str[0] & 0x80) == 0)
       return false;
 {
    if ((Str[0] & 0x80) == 0)
       return false;


@@ -1024,6 +1081,23 @@ bool Base256ToNum(const char *Str,unsigned long &Res,unsigned int Len)
    }
 }
                                                                        /*}}}*/
    }
 }
                                                                        /*}}}*/

+// Base256ToNum - Convert a fixed length binary to a number             /*{{{*/
+// ---------------------------------------------------------------------
+/* This is used in decoding the 256bit encoded fixed length fields in
+   tar files */
+bool Base256ToNum(const char *Str,unsigned long &Res,unsigned int Len)
+{
+   unsigned long long Num;
+   bool rc;
+
+   rc = Base256ToNum(Str, Num, Len);
+   Res = Num;
+   if (Res != Num)
+      return false;
+
+   return rc;
+}
+                                                                       /*}}}*/

 // HexDigit - Convert a hex character into an integer                  /*{{{*/
 // ---------------------------------------------------------------------
 /* Helper for Hex2Num */
 // HexDigit - Convert a hex character into an integer                  /*{{{*/
 // ---------------------------------------------------------------------
 /* Helper for Hex2Num */


@@ -1107,9 +1181,11 @@ bool TokSplitString(char Tok,char *Input,char **List,
    also, but the advantage is that we have an iteratable vector */
 vector<string> VectorizeString(string const &haystack, char const &split)
 {
    also, but the advantage is that we have an iteratable vector */
 vector<string> VectorizeString(string const &haystack, char const &split)
 {

+   vector<string> exploded;
+   if (haystack.empty() == true)
+      return exploded;

    string::const_iterator start = haystack.begin();
    string::const_iterator end = start;
    string::const_iterator start = haystack.begin();
    string::const_iterator end = start;

-   vector<string> exploded;

    do {
       for (; end != haystack.end() && *end != split; ++end);
       exploded.push_back(string(start, end));
    do {
       for (; end != haystack.end() && *end != split; ++end);
       exploded.push_back(string(start, end));


@@ -1118,6 +1194,37 @@ vector<string> VectorizeString(string const &haystack, char const &split)
    return exploded;
 }
                                                                        /*}}}*/
    return exploded;
 }
                                                                        /*}}}*/

+// StringSplit - split a string into a string vector by token          /*{{{*/
+// ---------------------------------------------------------------------
+/* See header for details.
+ */
+vector<string> StringSplit(std::string const &s, std::string const &sep,
+                           unsigned int maxsplit)
+{
+   vector<string> split;
+   size_t start, pos;
+
+   // no seperator given, this is bogus
+   if(sep.size() == 0)
+      return split;
+
+   start = pos = 0;
+   while (pos != string::npos)
+   {
+      pos = s.find(sep, start);
+      split.push_back(s.substr(start, pos-start));
+      
+      // if maxsplit is reached, the remaining string is the last item
+      if(split.size() >= maxsplit)
+      {
+         split[split.size()-1] = s.substr(start);
+         break;
+      }
+      start = pos+sep.size();
+   }
+   return split;
+}
+                                                                       /*}}}*/

 // RegexChoice - Simple regex list/list matcher                                /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // RegexChoice - Simple regex list/list matcher                                /*{{{*/
 // ---------------------------------------------------------------------
 /* */


@@ -1128,7 +1235,7 @@ unsigned long RegexChoice(RxChoiceList *Rxs,const char **ListBegin,
       R->Hit = false;
 
    unsigned long Hits = 0;
       R->Hit = false;
 
    unsigned long Hits = 0;

-   for (; ListBegin != ListEnd; ListBegin++)
+   for (; ListBegin < ListEnd; ++ListBegin)

    {
       // Check if the name is a regex
       const char *I;
    {
       // Check if the name is a regex
       const char *I;


@@ -1259,7 +1366,7 @@ string StripEpoch(const string &VerStr)
 // tolower_ascii - tolower() function that ignores the locale          /*{{{*/
 // ---------------------------------------------------------------------
 /* This little function is the most called method we have and tries
 // tolower_ascii - tolower() function that ignores the locale          /*{{{*/
 // ---------------------------------------------------------------------
 /* This little function is the most called method we have and tries

-   therefore to do the absolut minimum - and is noteable faster than
+   therefore to do the absolut minimum - and is notable faster than

    standard tolower/toupper and as a bonus avoids problems with different
    locales - we only operate on ascii chars anyway. */
 int tolower_ascii(int const c)
    standard tolower/toupper and as a bonus avoids problems with different
    locales - we only operate on ascii chars anyway. */
 int tolower_ascii(int const c)


@@ -1270,9 +1377,9 @@ int tolower_ascii(int const c)
 }
                                                                        /*}}}*/
 
 }
                                                                        /*}}}*/
 

-// CheckDomainList - See if Host is in a , seperate list               /*{{{*/
+// CheckDomainList - See if Host is in a , separate list               /*{{{*/

 // ---------------------------------------------------------------------
 // ---------------------------------------------------------------------

-/* The domain list is a comma seperate list of domains that are suffix
+/* The domain list is a comma separate list of domains that are suffix

    matched against the argument */
 bool CheckDomainList(const string &Host,const string &List)
 {
    matched against the argument */
 bool CheckDomainList(const string &Host,const string &List)
 {