* add --dsc-only option, thanks to K. Richard Pixley

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

diff --git a/apt-pkg/contrib/strutl.cc b/apt-pkg/contrib/strutl.cc
index dc5e508a6f7362b5eed31fcc7b4fdabeee58ac92..6e549bedd539be1ef50fe5cf3e4757f8fdc35ad4 100644 (file)
--- a/apt-pkg/contrib/strutl.cc
+++ b/apt-pkg/contrib/strutl.cc
@@ -1,6 +1,6 @@
 // -*- mode: cpp; mode: fold -*-
 // Description                                                         /*{{{*/
 // -*- mode: cpp; mode: fold -*-
 // Description                                                         /*{{{*/

-// $Id: strutl.cc,v 1.41 2001/05/27 23:30:45 jgg Exp $
+// $Id: strutl.cc,v 1.48 2003/07/18 14:15:11 mdz Exp $

 /* ######################################################################
 
    String Util - Some useful string functions.
 /* ######################################################################
 
    String Util - Some useful string functions.


@@ -28,11 +28,14 @@
 #include <ctype.h>
 #include <string.h>
 #include <stdio.h>
 #include <ctype.h>
 #include <string.h>
 #include <stdio.h>

+#include <algorithm>

 #include <unistd.h>
 #include <regex.h>
 #include <errno.h>
 #include <stdarg.h>
 
 #include <unistd.h>
 #include <regex.h>
 #include <errno.h>
 #include <stdarg.h>
 

+#include "config.h"
+

 using namespace std;
                                                                        /*}}}*/
 
 using namespace std;
                                                                        /*}}}*/
 


@@ -197,10 +200,10 @@ bool ParseCWord(const char *&String,string &Res)
 // QuoteString - Convert a string into quoted from                     /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // QuoteString - Convert a string into quoted from                     /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-string QuoteString(string Str,const char *Bad)
+string QuoteString(const string &Str, const char *Bad)

 {
    string Res;
 {
    string Res;

-   for (string::iterator I = Str.begin(); I != Str.end(); I++)
+   for (string::const_iterator I = Str.begin(); I != Str.end(); I++)

    {
       if (strchr(Bad,*I) != 0 || isprint(*I) == 0 || 
          *I <= 0x20 || *I >= 0x7F)
    {
       if (strchr(Bad,*I) != 0 || isprint(*I) == 0 || 
          *I <= 0x20 || *I >= 0x7F)


@@ -218,7 +221,7 @@ string QuoteString(string Str,const char *Bad)
 // DeQuoteString - Convert a string from quoted from                    /*{{{*/
 // ---------------------------------------------------------------------
 /* This undoes QuoteString */
 // DeQuoteString - Convert a string from quoted from                    /*{{{*/
 // ---------------------------------------------------------------------
 /* This undoes QuoteString */

-string DeQuoteString(string Str)
+string DeQuoteString(const string &Str)

 {
    string Res;
    for (string::const_iterator I = Str.begin(); I != Str.end(); I++)
 {
    string Res;
    for (string::const_iterator I = Str.begin(); I != Str.end(); I++)


@@ -315,7 +318,7 @@ string TimeToStr(unsigned long Sec)
 // SubstVar - Substitute a string for another string                   /*{{{*/
 // ---------------------------------------------------------------------
 /* This replaces all occurances of Subst with Contents in Str. */
 // SubstVar - Substitute a string for another string                   /*{{{*/
 // ---------------------------------------------------------------------
 /* This replaces all occurances of Subst with Contents in Str. */

-string SubstVar(string Str,string Subst,string Contents)
+string SubstVar(const string &Str,const string &Subst,const string &Contents)

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


@@ -346,21 +349,18 @@ string SubstVar(string Str,const struct SubstVar *Vars)
 /* This converts a URI into a safe filename. It quotes all unsafe characters
    and converts / to _ and removes the scheme identifier. The resulting
    file name should be unique and never occur again for a different file */
 /* This converts a URI into a safe filename. It quotes all unsafe characters
    and converts / to _ and removes the scheme identifier. The resulting
    file name should be unique and never occur again for a different file */

-string URItoFileName(string URI)
+string URItoFileName(const string &URI)

 {
    // Nuke 'sensitive' items
    ::URI U(URI);
 {
    // Nuke 'sensitive' items
    ::URI U(URI);

-   U.User = string();
-   U.Password = string();
-   U.Access = "";
+   U.User.clear();
+   U.Password.clear();
+   U.Access.clear();

    
    // "\x00-\x20{}|\\\\^\\[\\]<>\"\x7F-\xFF";
    
    // "\x00-\x20{}|\\\\^\\[\\]<>\"\x7F-\xFF";

-   URI = QuoteString(U,"\\|{}[]<>\"^~_=!@#$%^&*");
-   string::iterator J = URI.begin();
-   for (; J != URI.end(); J++)
-      if (*J == '/') 
-        *J = '_';
-   return URI;
+   string NewURI = QuoteString(U,"\\|{}[]<>\"^~_=!@#$%^&*");
+   replace(NewURI.begin(),NewURI.end(),'/','_');
+   return NewURI;

 }
                                                                        /*}}}*/
 // Base64Encode - Base64 Encoding routine for short strings            /*{{{*/
 }
                                                                        /*}}}*/
 // Base64Encode - Base64 Encoding routine for short strings            /*{{{*/


@@ -369,7 +369,7 @@ string URItoFileName(string URI)
    from wget and then patched and bug fixed.
  
    This spec can be found in rfc2045 */
    from wget and then patched and bug fixed.
  
    This spec can be found in rfc2045 */

-string Base64Encode(string S)
+string Base64Encode(const string &S)

 {
    // Conversion table.
    static char tbl[64] = {'A','B','C','D','E','F','G','H',
 {
    // Conversion table.
    static char tbl[64] = {'A','B','C','D','E','F','G','H',


@@ -440,6 +440,43 @@ int stringcmp(const char *A,const char *AEnd,const char *B,const char *BEnd)
       return -1;
    return 1;
 }
       return -1;
    return 1;
 }

+
+#if __GNUC__ >= 3
+int stringcmp(string::const_iterator A,string::const_iterator AEnd,
+             const char *B,const char *BEnd)
+{
+   for (; A != AEnd && B != BEnd; A++, B++)
+      if (*A != *B)
+        break;
+   
+   if (A == AEnd && B == BEnd)
+      return 0;
+   if (A == AEnd)
+      return 1;
+   if (B == BEnd)
+      return -1;
+   if (*A < *B)
+      return -1;
+   return 1;
+}
+int stringcmp(string::const_iterator A,string::const_iterator AEnd,
+             string::const_iterator B,string::const_iterator BEnd)
+{
+   for (; A != AEnd && B != BEnd; A++, B++)
+      if (*A != *B)
+        break;
+   
+   if (A == AEnd && B == BEnd)
+      return 0;
+   if (A == AEnd)
+      return 1;
+   if (B == BEnd)
+      return -1;
+   if (*A < *B)
+      return -1;
+   return 1;
+}
+#endif

                                                                        /*}}}*/
 // stringcasecmp - Arbitary case insensitive string compare            /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // stringcasecmp - Arbitary case insensitive string compare            /*{{{*/
 // ---------------------------------------------------------------------


@@ -460,31 +497,67 @@ int stringcasecmp(const char *A,const char *AEnd,const char *B,const char *BEnd)
       return -1;
    return 1;
 }
       return -1;
    return 1;
 }

+#if __GNUC__ >= 3
+int stringcasecmp(string::const_iterator A,string::const_iterator AEnd,
+                 const char *B,const char *BEnd)
+{
+   for (; A != AEnd && B != BEnd; A++, B++)
+      if (toupper(*A) != toupper(*B))
+        break;
+
+   if (A == AEnd && B == BEnd)
+      return 0;
+   if (A == AEnd)
+      return 1;
+   if (B == BEnd)
+      return -1;
+   if (toupper(*A) < toupper(*B))
+      return -1;
+   return 1;
+}
+int stringcasecmp(string::const_iterator A,string::const_iterator AEnd,
+                 string::const_iterator B,string::const_iterator BEnd)
+{
+   for (; A != AEnd && B != BEnd; A++, B++)
+      if (toupper(*A) != toupper(*B))
+        break;
+
+   if (A == AEnd && B == BEnd)
+      return 0;
+   if (A == AEnd)
+      return 1;
+   if (B == BEnd)
+      return -1;
+   if (toupper(*A) < toupper(*B))
+      return -1;
+   return 1;
+}
+#endif

                                                                        /*}}}*/
 // LookupTag - Lookup the value of a tag in a taged string             /*{{{*/
 // ---------------------------------------------------------------------
 /* The format is like those used in package files and the method 
    communication system */
                                                                        /*}}}*/
 // LookupTag - Lookup the value of a tag in a taged string             /*{{{*/
 // ---------------------------------------------------------------------
 /* The format is like those used in package files and the method 
    communication system */

-string LookupTag(string Message,const char *Tag,const char *Default)
+string LookupTag(const string &Message,const char *Tag,const char *Default)

 {
    // Look for a matching tag.
    int Length = strlen(Tag);
 {
    // Look for a matching tag.
    int Length = strlen(Tag);

-   for (const char *I = Message.c_str(); I + Length < Message.c_str() + Message.length(); I++)
+   for (string::const_iterator I = Message.begin(); I + Length < Message.end(); I++)

    {
       // Found the tag
       if (I[Length] == ':' && stringcasecmp(I,I+Length,Tag) == 0)
       {
         // Find the end of line and strip the leading/trailing spaces
    {
       // Found the tag
       if (I[Length] == ':' && stringcasecmp(I,I+Length,Tag) == 0)
       {
         // Find the end of line and strip the leading/trailing spaces

-        const char *J;
+        string::const_iterator J;

         I += Length + 1;
         I += Length + 1;

-        for (; isspace(*I) != 0 && *I != 0; I++);
-        for (J = I; *J != '\n' && *J != 0; J++);
+        for (; isspace(*I) != 0 && I < Message.end(); I++);
+        for (J = I; *J != '\n' && J < Message.end(); J++);

         for (; J > I && isspace(J[-1]) != 0; J--);
         
         return string(I,J);
       }
       
         for (; J > I && isspace(J[-1]) != 0; J--);
         
         return string(I,J);
       }
       

-      for (; *I != '\n' && *I != 0; I++);
+      for (; *I != '\n' && I < Message.end(); I++);

    }   
    
    // Failed to find a match
    }   
    
    // Failed to find a match


@@ -497,7 +570,7 @@ string LookupTag(string Message,const char *Tag,const char *Default)
 // ---------------------------------------------------------------------
 /* This inspects the string to see if it is true or if it is false and
    then returns the result. Several varients on true/false are checked. */
 // ---------------------------------------------------------------------
 /* This inspects the string to see if it is true or if it is false and
    then returns the result. Several varients on true/false are checked. */

-int StringToBool(string Text,int Default)
+int StringToBool(const string &Text,int Default)

 {
    char *End;
    int Res = strtol(Text.c_str(),&End,0);   
 {
    char *End;
    int Res = strtol(Text.c_str(),&End,0);   


@@ -549,7 +622,7 @@ string TimeRFC1123(time_t Date)
    fancy buffering is used. */
 bool ReadMessages(int Fd, vector<string> &List)
 {
    fancy buffering is used. */
 bool ReadMessages(int Fd, vector<string> &List)
 {

-   char Buffer[4000];
+   char Buffer[64000];

    char *End = Buffer;
    
    while (1)
    char *End = Buffer;
    
    while (1)


@@ -577,7 +650,7 @@ bool ReadMessages(int Fd, vector<string> &List)
            continue;
         
         // Pull the message out
            continue;
         
         // Pull the message out

-        string Message(Buffer,0,I-Buffer);
+        string Message(Buffer,I-Buffer);

 
         // Fix up the buffer
         for (; I < End && *I == '\n'; I++);
 
         // Fix up the buffer
         for (; I < End && *I == '\n'; I++);


@@ -639,7 +712,11 @@ static int MonthConv(char *Month)
    
    Contributed by Roger Beeman <beeman@cisco.com>, with the help of
    Mark Baushke <mdb@cisco.com> and the rest of the Gurus at CISCO. */
    
    Contributed by Roger Beeman <beeman@cisco.com>, with the help of
    Mark Baushke <mdb@cisco.com> and the rest of the Gurus at CISCO. */

-#ifndef __USE_MISC        // glib sets this
+
+/* Turned it into an autoconf check, because GNU is not the only thing which
+   can provide timegm. -- 2002-09-22, Joel Baker */
+
+#ifndef HAVE_TIMEGM // Now with autoconf!

 static time_t timegm(struct tm *t)
 {
    time_t tl, tb;
 static time_t timegm(struct tm *t)
 {
    time_t tl, tb;


@@ -659,7 +736,7 @@ static time_t timegm(struct tm *t)
    '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
    handles the weird, but unambiguous FTP time format*/
    '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
    handles the weird, but unambiguous FTP time format*/

-bool StrToTime(string Val,time_t &Result)
+bool StrToTime(const string &Val,time_t &Result)

 {
    struct tm Tm;
    char Month[10];
 {
    struct tm Tm;
    char Month[10];


@@ -746,7 +823,7 @@ static int HexDigit(int c)
 // Hex2Num - Convert a long hex number into a buffer                   /*{{{*/
 // ---------------------------------------------------------------------
 /* The length of the buffer must be exactly 1/2 the length of the string. */
 // Hex2Num - Convert a long hex number into a buffer                   /*{{{*/
 // ---------------------------------------------------------------------
 /* The length of the buffer must be exactly 1/2 the length of the string. */

-bool Hex2Num(string Str,unsigned char *Num,unsigned int Length)
+bool Hex2Num(const string &Str,unsigned char *Num,unsigned int Length)

 {
    if (Str.length() != Length*2)
       return false;
 {
    if (Str.length() != Length*2)
       return false;


@@ -867,8 +944,8 @@ unsigned long RegexChoice(RxChoiceList *Rxs,const char **ListBegin,
                                                                        /*}}}*/
 // ioprintf - C format string outputter to C++ iostreams               /*{{{*/
 // ---------------------------------------------------------------------
                                                                        /*}}}*/
 // ioprintf - C format string outputter to C++ iostreams               /*{{{*/
 // ---------------------------------------------------------------------

-/* This is used to make the internationalization strinc easier to translate
- and to allow reordering of parameters */
+/* This is used to make the internationalization strings easier to translate
+   and to allow reordering of parameters */

 void ioprintf(ostream &out,const char *format,...) 
 {
    va_list args;
 void ioprintf(ostream &out,const char *format,...) 
 {
    va_list args;


@@ -880,23 +957,45 @@ void ioprintf(ostream &out,const char *format,...)
    out << S;
 }
                                                                        /*}}}*/
    out << S;
 }
                                                                        /*}}}*/

+// safe_snprintf - Safer snprintf                                      /*{{{*/
+// ---------------------------------------------------------------------
+/* This is a snprintf that will never (ever) go past 'End' and returns a
+   pointer to the end of the new string. The returned string is always null
+   terminated unless Buffer == end. This is a better alterantive to using
+   consecutive snprintfs. */
+char *safe_snprintf(char *Buffer,char *End,const char *Format,...)
+{
+   va_list args;
+   unsigned long Did;
+
+   va_start(args,Format);
+
+   if (End <= Buffer)
+      return End;
+
+   Did = vsnprintf(Buffer,End - Buffer,Format,args);
+   if (Did < 0 || Buffer + Did > End)
+      return End;
+   return Buffer + Did;
+}
+                                                                       /*}}}*/

 
 // CheckDomainList - See if Host is in a , seperate list               /*{{{*/
 // ---------------------------------------------------------------------
 /* The domain list is a comma seperate list of domains that are suffix
    matched against the argument */
 
 // CheckDomainList - See if Host is in a , seperate list               /*{{{*/
 // ---------------------------------------------------------------------
 /* The domain list is a comma seperate list of domains that are suffix
    matched against the argument */

-bool CheckDomainList(string Host,string List)
+bool CheckDomainList(const string &Host,const string &List)

 {
 {

-   const char *Start = List.c_str();
-   for (const char *Cur = List.c_str(); *Cur != 0; Cur++)
+   string::const_iterator Start = List.begin();
+   for (string::const_iterator Cur = List.begin(); Cur <= List.end(); Cur++)

    {
    {

-      if (*Cur != ',')
+      if (Cur < List.end() && *Cur != ',')

         continue;
       
       // Match the end of the string..
         continue;
       
       // Match the end of the string..

-      if ((Host.size() >= (unsigned)(Cur - List.c_str())) &&
+      if ((Host.size() >= (unsigned)(Cur - Start)) &&

          Cur - Start != 0 &&
          Cur - Start != 0 &&

-         stringcasecmp(Host.c_str() + Host.length() - (Cur - Start),Host.c_str()+Host.length(),Start,Cur) == 0)
+         stringcasecmp(Host.end() - (Cur - Start),Host.end(),Start,Cur) == 0)

         return true;
       
       Start = Cur + 1;
         return true;
       
       Start = Cur + 1;


@@ -908,7 +1007,7 @@ bool CheckDomainList(string Host,string List)
 // URI::CopyFrom - Copy from an object                                 /*{{{*/
 // ---------------------------------------------------------------------
 /* This parses the URI into all of its components */
 // URI::CopyFrom - Copy from an object                                 /*{{{*/
 // ---------------------------------------------------------------------
 /* This parses the URI into all of its components */

-void URI::CopyFrom(string U)
+void URI::CopyFrom(const string &U)

 {
    string::const_iterator I = U.begin();
 
 {
    string::const_iterator I = U.begin();
 


@@ -937,14 +1036,14 @@ void URI::CopyFrom(string U)
       SingleSlash = U.end();
 
    // We can now write the access and path specifiers
       SingleSlash = U.end();
 
    // We can now write the access and path specifiers

-   Access = string(U,0,FirstColon - U.begin());
+   Access.assign(U.begin(),FirstColon);

    if (SingleSlash != U.end())
    if (SingleSlash != U.end())

-      Path = string(U,SingleSlash - U.begin());
+      Path.assign(SingleSlash,U.end());

    if (Path.empty() == true)
       Path = "/";
 
    // Now we attempt to locate a user:pass@host fragment
    if (Path.empty() == true)
       Path = "/";
 
    // Now we attempt to locate a user:pass@host fragment

-   if (FirstColon[1] == '/' && FirstColon[2] == '/')
+   if (FirstColon + 2 <= U.end() && FirstColon[1] == '/' && FirstColon[2] == '/')

       FirstColon += 3;
    else
       FirstColon += 1;
       FirstColon += 3;
    else
       FirstColon += 1;


@@ -969,14 +1068,14 @@ void URI::CopyFrom(string U)
    if (At == SingleSlash)
    {
       if (FirstColon < SingleSlash)
    if (At == SingleSlash)
    {
       if (FirstColon < SingleSlash)

-        Host = string(U,FirstColon - U.begin(),SingleSlash - FirstColon);
+        Host.assign(FirstColon,SingleSlash);

    }
    else
    {
    }
    else
    {

-      Host = string(U,At - U.begin() + 1,SingleSlash - At - 1);
-      User = string(U,FirstColon - U.begin(),SecondColon - FirstColon);
+      Host.assign(At+1,SingleSlash);
+      User.assign(FirstColon,SecondColon);

       if (SecondColon < At)
       if (SecondColon < At)

-        Password = string(U,SecondColon - U.begin() + 1,At - SecondColon - 1);
+        Password.assign(SecondColon+1,At);

    }   
    
    // Now we parse the RFC 2732 [] hostnames.
    }   
    
    // Now we parse the RFC 2732 [] hostnames.


@@ -1004,7 +1103,7 @@ void URI::CopyFrom(string U)
    // Tsk, weird.
    if (InBracket == true)
    {
    // Tsk, weird.
    if (InBracket == true)
    {

-      Host = string();
+      Host.clear();

       return;
    }
    
       return;
    }
    


@@ -1015,7 +1114,7 @@ void URI::CopyFrom(string U)
       return;
    
    Port = atoi(string(Host,Pos+1).c_str());
       return;
    
    Port = atoi(string(Host,Pos+1).c_str());

-   Host = string(Host,0,Pos);
+   Host.assign(Host,0,Pos);

 }
                                                                        /*}}}*/
 // URI::operator string - Convert the URI to a string                  /*{{{*/
 }
                                                                        /*}}}*/
 // URI::operator string - Convert the URI to a string                  /*{{{*/


@@ -1070,12 +1169,12 @@ URI::operator string()
 // URI::SiteOnly - Return the schema and site for the URI              /*{{{*/
 // ---------------------------------------------------------------------
 /* */
 // URI::SiteOnly - Return the schema and site for the URI              /*{{{*/
 // ---------------------------------------------------------------------
 /* */

-string URI::SiteOnly(string URI)
+string URI::SiteOnly(const string &URI)

 {
    ::URI U(URI);
 {
    ::URI U(URI);

-   U.User = string();
-   U.Password = string();
-   U.Path = string();
+   U.User.clear();
+   U.Password.clear();
+   U.Path.clear();

    U.Port = 0;
    return U;
 }
    U.Port = 0;
    return U;
 }