developer.intra2net.com Git - libi2ncommon/blob - src/stringfunc.cpp

   1 /*
   2 The software in this package is distributed under the GNU General
   3 Public License version 2 (with a special exception described below).
   4
   5 A copy of GNU General Public License (GPL) is included in this distribution,
   6 in the file COPYING.GPL.
   7
   8 As a special exception, if other files instantiate templates or use macros
   9 or inline functions from this file, or you compile this file and link it
  10 with other works to produce a work based on this file, this file
  11 does not by itself cause the resulting work to be covered
  12 by the GNU General Public License.
  13
  14 However the source code for this file must still be made available
  15 in accordance with section (3) of the GNU General Public License.
  16
  17 This exception does not invalidate any other reasons why a work based
  18 on this file might be covered by the GNU General Public License.
  19 */
  20 /** @file
  21  *
  22  * (c) Copyright 2007-2008 by Intra2net AG
  23  */
  24
  25 #include <iostream>
  26 #include <string>
  27 #include <sstream>
  28 #include <stdexcept>
  29 #include <algorithm>
  30 #include <cmath>    // for round()
  31 #include <climits>
  32
  33 #include <wchar.h>
  34 #include <stdlib.h>
  35 #include <iconv.h>
  36 #include <i18n.h>
  37
  38 #include <boost/numeric/conversion/cast.hpp>
  39 #include <boost/foreach.hpp>
  40
  41 #include <boost/assert.hpp>
  42 #include <boost/shared_ptr.hpp>
  43 #include <openssl/bio.h>
  44 #include <openssl/evp.h>
  45
  46 #include <stringfunc.hxx>
  47
  48 using namespace std;
  49
  50 namespace I2n
  51 {
  52
  53
  54 namespace
  55 {
  56
  57 const std::string hexDigitsLower("0123456789abcdef");
  58 const std::string hexDigitsUpper("0123456789ABCDEF");
  59
  60
  61 struct UpperFunc
  62 {
  63    char operator() (char c)
  64    {
  65       return std::toupper(c);
  66    }
  67 }; // eo struct UpperFunc
  68
  69
  70 struct LowerFunc
  71 {
  72    char operator() (char c)
  73    {
  74       return std::tolower(c);
  75    }
  76 }; // eo struct LowerFunc
  77
  78
  79 } // eo namespace <anonymous>
  80
  81
  82
  83 /**
  84  * default list of Whitespaces (" \t\r\n");
  85  */
  86 const std::string Whitespaces = " \t\r\n";
  87
  88 /**
  89  * default list of lineendings ("\r\n");
  90  */
  91 const std::string LineEndings= "\r\n";
  92
  93
  94
  95 /**
  96  * @brief checks if a string begins with a given prefix.
  97  * @param[in,out] str the string which is tested
  98  * @param prefix the prefix which should be tested for.
  99  * @return @a true iff the prefix is not empty and the string begins with that prefix.
 100  */
 101 bool has_prefix(const std::string& str, const std::string& prefix)
 102 {
 103    if (prefix.empty() || str.empty() || str.size() < prefix.size() )
 104    {
 105       return false;
 106    }
 107    return str.compare(0, prefix.size(), prefix) == 0;
 108 } // eo has_prefix(const std::string&,const std::string&)
 109
 110
 111 /**
 112  * @brief checks if a string ends with a given suffix.
 113  * @param[in,out] str the string which is tested
 114  * @param suffix the suffix which should be tested for.
 115  * @return @a true iff the suffix is not empty and the string ends with that suffix.
 116  */
 117 bool has_suffix(const std::string& str, const std::string& suffix)
 118 {
 119    if (suffix.empty() || str.empty() || str.size() < suffix.size() )
 120    {
 121       return false;
 122    }
 123    return str.compare(str.size() - suffix.size(), suffix.size(), suffix) == 0;
 124 } // eo has_suffix(const std::string&,const std::string&)
 125
 126
 127 /**
 128  * cut off characters from a given list from front and end of a string.
 129  * @param[in,out] str the string which should be trimmed.
 130  * @param charlist the list of characters to remove from beginning and end of string
 131  * @return the result string.
 132  */
 133 std::string trim_mod(std::string& str, const std::string& charlist)
 134 {
 135    // first: trim the beginning:
 136    std::string::size_type pos= str.find_first_not_of (charlist);
 137    if (pos == std::string::npos)
 138    {
 139       // whole string consists of charlist (or is already empty)
 140       str.clear();
 141       return str;
 142    }
 143    else if (pos>0)
 144    {
 145       // str starts with charlist
 146       str.erase(0,pos);
 147    }
 148    // now let's look at the tail:
 149    pos= str.find_last_not_of(charlist) +1;  // note: we already know there is at least one other char!
 150    if ( pos < str.size() )
 151    {
 152       str.erase(pos, str.size()-pos);
 153    }
 154    return str;
 155 } // eo trim_mod(std::string&,const std::string&)
 156
 157
 158
 159 /**
 160  * removes last character from a string when it is in a list of chars to be removed.
 161  * @param[in,out] str the string.
 162  * @param what the list of chars which will be tested for.
 163  * @return the resulting string with last char removed (if applicable)
 164  */
 165 std::string chomp_mod(std::string& str, const std::string& what)
 166 {
 167    if (str.empty() || what.empty() )
 168    {
 169       return str;
 170    }
 171    if (what.find(str.at (str.size()-1) ) != std::string::npos)
 172    {
 173       str.erase(str.size() - 1);
 174    }
 175    return str;
 176 } // eo chomp_mod(std::string&,const std::string&)
 177
 178
 179 /**
 180  * @brief converts a string to lower case.
 181  * @param[in,out] str the string to modify.
 182  * @return the string
 183  */
 184 std::string to_lower_mod(std::string& str)
 185 {
 186    std::transform(str.begin(), str.end(), str.begin(), LowerFunc() );
 187    return str;
 188 } // eo to_lower_mod(std::string&)
 189
 190
 191 /**
 192  * @brief converts a string to upper case.
 193  * @param[in,out] str the string to modify.
 194  * @return the string
 195  */
 196 std::string to_upper_mod(std::string& str)
 197 {
 198    std::transform( str.begin(), str.end(), str.begin(), UpperFunc() );
 199    return str;
 200 } // eo to_upper_mod(std::string&)
 201
 202
 203
 204 /**
 205  * cut off characters from a given list from front and end of a string.
 206  * @param str the string which should be trimmed.
 207  * @param charlist the list of characters to remove from beginning and end of string
 208  * @return the result string.
 209  */
 210 std::string trim (const std::string& str, const std::string& charlist)
 211 {
 212    // first: trim the beginning:
 213    std::string::size_type pos0= str.find_first_not_of(charlist);
 214    if (pos0 == std::string::npos)
 215    {
 216       // whole string consists of charlist (or is already empty)
 217       return std::string();
 218    }
 219    // now let's look at the end:
 220    std::string::size_type pos1= str.find_last_not_of(charlist);
 221    return str.substr(pos0, pos1 - pos0 + 1);
 222 } // eo trim(const std:.string&,const std::string&)
 223
 224
 225 /**
 226  * removes last character from a string when it is in a list of chars to be removed.
 227  * @param str the string.
 228  * @param what the list of chars which will be tested for.
 229  * @return the resulting string with last char removed (if applicable)
 230  */
 231 std::string chomp (const std::string& str, const std::string& what)
 232 {
 233    if (str.empty() || what.empty() )
 234    {
 235       return str;
 236    }
 237    if (what.find(str.at (str.size()-1) ) != std::string::npos)
 238    {
 239       return str.substr(0, str.size()-1);
 240    }
 241    return str;
 242 } // eo chomp(const std:.string&,const std::string&)
 243
 244
 245 /**
 246  * @brief returns a lower case version of a given string.
 247  * @param str the string
 248  * @return the lower case version of the string
 249  */
 250 std::string to_lower (const std::string& str)
 251 {
 252    std::string result(str);
 253    return to_lower_mod(result);
 254 } // eo to_lower(const std::string&)
 255
 256
 257 /**
 258  * @brief returns a upper case version of a given string.
 259  * @param str the string
 260  * @return the upper case version of the string
 261  */
 262 std::string to_upper(const std::string& str)
 263 {
 264    std::string result(str);
 265    return to_upper_mod(result);
 266 } // eo to_upper(const std::string&)
 267
 268
 269
 270 /**
 271  * @brief removes a given suffix from a string.
 272  * @param str the string.
 273  * @param suffix the suffix which should be removed if the string ends with it.
 274  * @return the string without the suffix.
 275  *
 276  * If the string ends with the suffix, it is removed. If the the string doesn't end
 277  * with the suffix the original string is returned.
 278  */
 279 std::string remove_suffix(const std::string& str, const std::string& suffix)
 280 {
 281    if (has_suffix(str,suffix) )
 282    {
 283       return str.substr(0, str.size()-suffix.size() );
 284    }
 285    return str;
 286 } // eo remove_suffix(const std::string&,const std::string&)
 287
 288
 289
 290 /**
 291  * @brief removes a given prefix from a string.
 292  * @param str the string.
 293  * @param prefix the prefix which should be removed if the string begins with it.
 294  * @return the string without the prefix.
 295  *
 296  * If the string begins with the prefix, it is removed. If the the string doesn't begin
 297  * with the prefix the original string is returned.
 298  */
 299 std::string remove_prefix(const std::string& str, const std::string& prefix)
 300 {
 301    if (has_prefix(str,prefix) )
 302    {
 303       return str.substr( prefix.size() );
 304    }
 305    return str;
 306 } // eo remove_prefix(const std::string&,const std::string&)
 307
 308
 309 /**
 310  * split a string to key and value delimited by a given delimiter.
 311  * The resulting key and value strings are trimmed (Whitespaces removed at beginning and end).
 312  * @param str the string which should be splitted.
 313  * @param[out] key the resulting key
 314  * @param[out] value the resulting value
 315  * @param delimiter the delimiter between key and value; default is '='.
 316  * @return @a true if the split was successful.
 317  */
 318 bool pair_split(
 319    const std::string& str,
 320    std::string& key,
 321    std::string& value,
 322    char delimiter)
 323 {
 324    std::string::size_type pos = str.find (delimiter);
 325    if (pos == std::string::npos) return false;
 326    key= str.substr(0,pos);
 327    value= str.substr(pos+1);
 328    trim_mod(key);
 329    trim_mod(value);
 330    return true;
 331 } // eo pair_split(const std::string&,std::string&,std::string&,char)
 332
 333
 334 /**
 335  * splits a string by given delimiter
 336  *
 337  * @param[in] str the string which should be splitted.
 338  * @param[out] result the list resulting from splitting  @a str.
 339  * @param[in] delimiter the delimiter (word/phrase) at which @a str should be splitted.
 340  * @param[in] omit_empty should empty parts not be stored?
 341  * @param[in] trim_list list of characters the parts should be trimmed by.
 342  *  (empty string results in no trim)
 343  */
 344 void split_string(
 345    const std::string& str,
 346    std::list<std::string>& result,
 347    const std::string& delimiter,
 348    bool omit_empty,
 349    const std::string& trim_list
 350 )
 351 {
 352    std::string::size_type pos, last_pos=0;
 353    bool delimiter_found= false;
 354    while ( last_pos < str.size()  && last_pos != std::string::npos)
 355    {
 356       pos= str.find(delimiter, last_pos);
 357       std::string part;
 358       if (pos == std::string::npos)
 359       {
 360          part= str.substr(last_pos);
 361          delimiter_found= false;
 362       }
 363       else
 364       {
 365          part= str.substr(last_pos, pos-last_pos);
 366          delimiter_found=true;
 367       }
 368       if (pos != std::string::npos)
 369       {
 370          last_pos= pos+ delimiter.size();
 371       }
 372       else
 373       {
 374          last_pos= std::string::npos;
 375       }
 376       if (!trim_list.empty() ) trim_mod (part, trim_list);
 377       if (omit_empty && part.empty() ) continue;
 378       result.push_back( part );
 379    }
 380    // if the string ends with a delimiter we need to append an empty string if no omit_empty
 381    // was given.
 382    // (this way we keep the split result consistent to a join operation)
 383    if (delimiter_found && !omit_empty)
 384    {
 385       result.push_back("");
 386    }
 387 } // eo split_string(const std::string&,std::list< std::string >&,const std::string&,bool,const std::string&)
 388
 389
 390 /** call split_string with list<string>, converts result to vector; vector is clear()-ed first
 391  *
 392  * Note: Uses 3 O(n)-operations: list.size, vector.resize and std::swap_ranges;
 393  *       not sure whether there is a better way to do this
 394  * */
 395 void split_string(
 396    const std::string& str,
 397    std::vector<std::string>& result,
 398    const std::string& delimiter,
 399    bool omit_empty,
 400    const std::string& trim_list
 401 )
 402 {
 403     std::list<std::string> tmp;
 404     split_string(str, tmp, delimiter, omit_empty, trim_list);
 405     std::size_t size = tmp.size();   // this is O(n)
 406     result.clear();
 407     result.resize(size);             // also O(n)
 408     std::swap_ranges(tmp.begin(), tmp.end(), result.begin());   // also O(n)
 409 }
 410
 411 /**
 412  * splits a string by a given delimiter
 413  * @param str the string which should be splitted.
 414  * @param delimiter delimiter the delimiter (word/phrase) at which @a str should be splitted.
 415  * @param[in] omit_empty should empty parts not be stored?
 416  * @param[in] trim_list list of characters the parts should be trimmed by.
 417  *  (empty string results in no trim)
 418  * @return the list resulting from splitting @a str.
 419  */
 420 std::list<std::string> split_string(
 421    const std::string& str,
 422    const std::string& delimiter,
 423    bool omit_empty,
 424    const std::string& trim_list
 425 )
 426 {
 427    std::list<std::string> result;
 428    split_string(str, result, delimiter, omit_empty, trim_list);
 429    return result;
 430 } // eo split_string(const std::string&,const std::string&,bool,const std::string&)
 431
 432
 433 /**
 434  * @brief joins a list of strings into a single string.
 435  *
 436  * This funtion is (basically) the reverse operation of @a split_string.
 437  *
 438  * @param parts the list of strings.
 439  * @param delimiter the delimiter which is inserted between the strings.
 440  * @return the joined string.
 441  */
 442 std::string join_string(
 443    const std::list< std::string >& parts,
 444    const std::string& delimiter
 445 )
 446 {
 447    std::string result;
 448    if (! parts.empty() )
 449    {
 450       std::list< std::string >::const_iterator it= parts.begin();
 451       result = *it;
 452       while ( ++it != parts.end() )
 453       {
 454          result+= delimiter;
 455          result+= *it;
 456       }
 457    }
 458    return result;
 459 } // eo join_string(const std::list< std::string >&,const std::string&)
 460
 461
 462 /** @brief same as join_string for list, except uses a vector */
 463 std::string join_string(
 464    const std::vector< std::string >& parts,
 465    const std::string& delimiter
 466 )
 467 {
 468    std::string result;
 469    if (! parts.empty() )
 470    {
 471       std::vector< std::string >::const_iterator it= parts.begin();
 472       result = *it;
 473       while ( ++it != parts.end() )
 474       {
 475          result+= delimiter;
 476          result+= *it;
 477       }
 478    }
 479    return result;
 480 } // eo join_string(const std::vector< std::string >&,const std::string&)
 481
 482
 483
 484 /*
 485 ** conversions
 486 */
 487
 488
 489 /**
 490  * @brief returns a hex string from a binary string.
 491  * @param str the (binary) string
 492  * @param upper_case_digits determine whether to use upper case characters for digits A-F.
 493  * @return the string in hex notation.
 494  */
 495 std::string convert_binary_to_hex(
 496    const std::string& str,
 497    bool upper_case_digits
 498 )
 499 {
 500    std::string result;
 501    std::string hexDigits(upper_case_digits ? hexDigitsUpper : hexDigitsLower);
 502    for ( std::string::const_iterator it= str.begin();
 503          it != str.end();
 504          ++it)
 505    {
 506       result.push_back( hexDigits[ ( (*it) >> 4) & 0x0f ] );
 507       result.push_back( hexDigits[ (*it) & 0x0f ] );
 508    }
 509    return result;
 510 } // eo convert_binary_to_hex(const std::string&,bool)
 511
 512
 513 /**
 514  * @brief converts a hex digit string to binary string.
 515  * @param str hex digit string
 516  * @return the binary string.
 517  *
 518  * The hex digit string may contains white spaces or colons which are treated
 519  * as delimiters between hex digit groups.
 520  *
 521  * @todo rework the handling of half nibbles (consistency)!
 522  */
 523 std::string convert_hex_to_binary(
 524    const std::string& str
 525 )
 526 throw (std::runtime_error)
 527 {
 528    std::string result;
 529    char c= 0;
 530    bool hasNibble= false;
 531    bool lastWasWS= true;
 532    for ( std::string::const_iterator it= str.begin();
 533          it != str.end();
 534          ++it)
 535    {
 536       std::string::size_type p = hexDigitsLower.find( *it );
 537       if (p== std::string::npos)
 538       {
 539          p= hexDigitsUpper.find( *it );
 540       }
 541       if (p == std::string::npos)
 542       {
 543          if (   ( Whitespaces.find( *it ) != std::string::npos) // is it a whitespace?
 544                 or ( *it == ':') // or a colon?
 545             )
 546          {
 547             // we treat that as a valid delimiter:
 548             if (hasNibble)
 549             {
 550                // 1 nibble before WS is treate as lower part:
 551                result.push_back(c);
 552                // reset state:
 553                hasNibble= false;
 554             }
 555             lastWasWS= true;
 556             continue;
 557          }
 558       }
 559       if (p == std::string::npos )
 560       {
 561          throw runtime_error("illegal character in hex digit string: " + str);
 562       }
 563       lastWasWS= false;
 564       if (hasNibble)
 565       {
 566          c<<=4;
 567       }
 568       else
 569       {
 570          c=0;
 571       }
 572       c+= (p & 0x0f);
 573       if (hasNibble)
 574       {
 575          //we already had a nibble, so a char is complete now:
 576          result.push_back( c );
 577          hasNibble=false;
 578       }
 579       else
 580       {
 581          // this is the first nibble of a new char:
 582          hasNibble=true;
 583       }
 584    }
 585    if (hasNibble)
 586    {
 587       //well, there is one nibble left
 588       // let's do some heuristics:
 589       if (lastWasWS)
 590       {
 591          // if the preceeding character was a white space (or a colon)
 592          // we treat the nibble as lower part:
 593          //( this is consistent with shortened hex notations where leading zeros are not noted)
 594          result.push_back( c );
 595       }
 596       else
 597       {
 598          // if it was part of a hex digit chain, we treat it as UPPER part (!!)
 599          result.push_back( c << 4 );
 600       }
 601    }
 602    return result;
 603 } // eo convert_hex_to_binary(const std::string&)
 604
 605
 606 static list<string>& alloc_template_starts()
 607 {
 608     static list<string> result;
 609     if (result.empty())
 610     {
 611         result.push_back("std::list");
 612         result.push_back("std::vector");
 613     }
 614     return result;
 615 }
 616
 617 string shorten_stl_types(const string &input)
 618 {
 619     string output = input;
 620
 621     // first: replace fixed string for std::string
 622     replace_all(output, "std::basic_string<char, std::char_traits<char>, std::allocator<char> >",
 623                         "std::string");
 624
 625     // loop over list/vector/... that have an allocator, e.g.
 626     // std::list< some_type_here, std::allocator<some_type_here> >
 627     string::size_type start, comma, end, len, start_text_len;
 628     int n_open_brackets;
 629     string allocator_text;
 630     BOOST_FOREACH(const string &start_text, alloc_template_starts())
 631     {
 632         start = 0;
 633         comma = 0;
 634         end = 0;
 635         start_text_len = start_text.length();
 636         while( (start=output.find(start_text+"<", start)) != string::npos )
 637         {
 638             len = output.length();
 639             start += start_text_len+1;   // start next iter and tests here after opening bracket
 640
 641             // now comes the tricky part: find matching ',' and the closing '>' even if "subtype" is template again
 642             comma = start;
 643             n_open_brackets = 1;    // the bracket right after start_text counts as first
 644             while (comma < len && n_open_brackets > 0)
 645             {
 646                 if (output[comma] == ',' && n_open_brackets == 1)
 647                     break;
 648                 else if (output[comma] == '<')
 649                     ++n_open_brackets;
 650                 else if (output[comma] == '>')
 651                     --n_open_brackets;
 652                 ++comma;
 653             }
 654             end = comma+1;
 655             while (end < len && n_open_brackets > 0)
 656             {
 657                 if (output[end] == '<')
 658                     ++n_open_brackets;
 659                 else if (output[end] == '>')
 660                 {
 661                     --n_open_brackets;
 662                     if (n_open_brackets == 0)
 663                         break;  // do not increment end
 664                 }
 665                 ++end;
 666             }
 667
 668             // check that start < comma < end < len && n_open_brackets == 0
 669             if (start >= comma || comma >= end || end >= len || n_open_brackets != 0)
 670                 continue;   // input seems to be of unexpected form
 671
 672             // check that type in allocator is same as until comma
 673             string type = output.substr(start, comma-start);
 674             if (type[type.length()-1] == '>')
 675                 allocator_text = string("std::allocator<") + type + " > ";
 676             else
 677                 allocator_text = string("std::allocator<") + type + "> ";
 678             if (output.substr(comma+2, end-comma-2) == allocator_text)
 679                 output.replace(comma+2, end-comma-2, "_alloc_");
 680         }
 681     }
 682
 683     return output;
 684 }
 685
 686 typedef boost::shared_ptr<BIO> BIO_Ptr;
 687
 688 /**
 689 * @brief Converts openssl generic input/output to std::string
 690 *
 691 * Code adapted from keymakerd.
 692 *
 693 * @param bio Openssl's generic input/output
 694 * @return :string STL string
 695 **/
 696 static std::string _convert_BIO_to_string(BIO *input)
 697 {
 698     std::string rtn;
 699
 700     char *output = NULL;
 701     long written = BIO_get_mem_data(input, &output);
 702     if (written <= 0 || output == NULL)
 703         return rtn;
 704
 705     rtn.assign(output, written);                                                                    //lint !e534 !e732
 706     return rtn;
 707 }                                                                                                   //lint !e1764
 708
 709 /**
 710     * @brief base64 encode a string using OpenSSL base64 functions
 711     *
 712     * Data size limit is 2GB on 32 bit (LONG_MAX)
 713     *
 714     * @param input String to encode
 715     * @return base64 encoded string
 716     */
 717 std::string base64_encode(const std::string &input)
 718 {
 719     // check for empty buffer
 720     if (input.empty())
 721         return input;
 722
 723     // safety check to ensure our check afer BIO_write() works
 724     if (input.size() >= LONG_MAX)
 725         throw runtime_error("base64 encode: Too much data");
 726
 727     // setup encoder. Note: BIO_free_all frees both BIOs.
 728     BIO_Ptr base64_encoder(BIO_new(BIO_f_base64()), BIO_free_all);
 729     BIO *encoder_bio = base64_encoder.get();
 730     BIO_set_flags(encoder_bio, BIO_FLAGS_BASE64_NO_NL);
 731
 732     // chain output buffer and encoder together
 733     BIO *encoded_result = BIO_new(BIO_s_mem());
 734     BIO_push(encoder_bio, encoded_result);
 735
 736     // encode
 737     long written = BIO_write(encoder_bio, input.c_str(), input.size());
 738     if ((unsigned)written != input.size())
 739     {
 740         ostringstream out;
 741         out << "base64 encoding failed: input size: "
 742             << input.size() << " vs. output size: " << written;
 743         throw runtime_error(out.str());
 744     }
 745     if (BIO_flush(encoder_bio) != 1)
 746         throw runtime_error("base64 encode: BIO_flush() failed");
 747
 748     return _convert_BIO_to_string(encoded_result);
 749 }
 750
 751 /**
 752     * @brief base64 decode a string using OpenSSL base64 functions
 753     *
 754     * @param input String to decode
 755     * @return base64 decoded string
 756     */
 757 std::string base64_decode(const std::string &input)
 758 {
 759     // check for empty buffer
 760     if (input.empty())
 761         return input;
 762
 763     // safety check for BIO_new_mem_buf()
 764     if (input.size() >= INT_MAX)
 765         throw runtime_error("base64 decode: Too much data");
 766
 767     // setup encoder. Note: BIO_free_all frees both BIOs.
 768     BIO_Ptr base64_decoder(BIO_new(BIO_f_base64()), BIO_free_all);
 769     BIO *bio_base64 = base64_decoder.get();
 770     BIO_set_flags(bio_base64, BIO_FLAGS_BASE64_NO_NL);
 771
 772     // chain input buffer and decoder together
 773     BIO *bio_input = BIO_new_mem_buf((void*)input.c_str(), input.size());
 774     bio_input = BIO_push(bio_base64, bio_input);
 775
 776     BIO_Ptr decoded_result(BIO_new(BIO_s_mem()), BIO_free_all);
 777     BIO *bio_decoded = decoded_result.get();
 778     const int convbuf_size = 512;
 779     char convbuf[convbuf_size];
 780
 781     long read_bytes = 0;
 782     while((read_bytes = BIO_read(bio_input, convbuf, convbuf_size)) > 0)
 783     {
 784         BOOST_ASSERT(read_bytes <= convbuf_size);
 785         long written_bytes = BIO_write(bio_decoded, convbuf, read_bytes);
 786         if (written_bytes != read_bytes)
 787         {
 788             ostringstream out;
 789             out << "base64 decoding failed: read_bytes: "
 790                 << read_bytes << " vs. written_bytes: " << written_bytes;
 791             throw runtime_error(out.str());
 792         }
 793     }
 794     if (read_bytes == -2 || read_bytes == -1)
 795         throw runtime_error("base64 decode: Error during decoding");
 796
 797     return _convert_BIO_to_string(bio_decoded);
 798 }
 799
 800 } // eo namespace I2n
 801
 802
 803
 804
 805 std::string iso_to_utf8(const std::string& isostring)
 806 {
 807    string result;
 808
 809    iconv_t i2utf8 = iconv_open("UTF-8", "ISO-8859-1");
 810
 811    if (iso_to_utf8 == (iconv_t)-1)
 812       throw runtime_error("iconv can't convert from ISO-8859-1 to UTF-8");
 813
 814    size_t in_size=isostring.size();
 815    size_t out_size=in_size*4;
 816
 817    char *buf = (char *)malloc(out_size+1);
 818    if (buf == NULL)
 819       throw runtime_error("out of memory for iconv buffer");
 820
 821    char *in = (char *)isostring.c_str();
 822    char *out = buf;
 823    iconv(i2utf8, &in, &in_size, &out, &out_size);
 824
 825    buf[isostring.size()*4-out_size]=0;
 826
 827    result=buf;
 828
 829    free(buf);
 830    iconv_close(i2utf8);
 831
 832    return result;
 833 }
 834
 835 std::string utf8_to_iso(const std::string& utf8string)
 836 {
 837    string result;
 838
 839    iconv_t utf82iso = iconv_open("ISO-8859-1","UTF-8");
 840
 841    if (utf82iso == (iconv_t)-1)
 842       throw runtime_error("iconv can't convert from UTF-8 to ISO-8859-1");
 843
 844    size_t in_size=utf8string.size();
 845    size_t out_size=in_size;
 846
 847    char *buf = (char *)malloc(out_size+1);
 848    if (buf == NULL)
 849       throw runtime_error("out of memory for iconv buffer");
 850
 851    char *in = (char *)utf8string.c_str();
 852    char *out = buf;
 853    iconv(utf82iso, &in, &in_size, &out, &out_size);
 854
 855    buf[utf8string.size()-out_size]=0;
 856
 857    result=buf;
 858
 859    free(buf);
 860    iconv_close(utf82iso);
 861
 862    return result;
 863 }
 864
 865 wchar_t* utf8_to_wbuf(const std::string& utf8string)
 866 {
 867    iconv_t utf82wstr = iconv_open("UCS-4LE","UTF-8");
 868
 869    if (utf82wstr == (iconv_t)-1)
 870       throw runtime_error("iconv can't convert from UTF-8 to UCS-4");
 871
 872    size_t in_size=utf8string.size();
 873    size_t out_size= (in_size+1)*sizeof(wchar_t);
 874
 875    wchar_t *buf = (wchar_t *)malloc(out_size);
 876    if (buf == NULL)
 877       throw runtime_error("out of memory for iconv buffer");
 878
 879    char *in = (char *)utf8string.c_str();
 880    char *out = (char*) buf;
 881    if (iconv(utf82wstr, &in, &in_size, &out, &out_size) == (size_t)-1)
 882       throw runtime_error("error converting char encodings");
 883
 884    buf[ ( (utf8string.size()+1)*sizeof(wchar_t)-out_size) /sizeof(wchar_t) ]=0;
 885
 886    iconv_close(utf82wstr);
 887
 888    return buf;
 889 }
 890
 891 std::string utf7imap_to_utf8(const std::string& utf7imapstring)
 892 {
 893    string result;
 894
 895    iconv_t utf7imap2utf8 = iconv_open("UTF-8","UTF-7-IMAP");
 896
 897    if (utf7imap2utf8 == (iconv_t)-1)
 898       throw runtime_error("iconv can't convert from UTF-7-IMAP to UTF-8");
 899
 900    size_t in_size=utf7imapstring.size();
 901    size_t out_size=in_size*4;
 902
 903    char *buf = (char *)malloc(out_size+1);
 904    if (buf == NULL)
 905       throw runtime_error("out of memory for iconv buffer");
 906
 907    char *in = (char *)utf7imapstring.c_str();
 908    char *out = buf;
 909    iconv(utf7imap2utf8, &in, &in_size, &out, &out_size);
 910
 911    buf[utf7imapstring.size()*4-out_size]=0;
 912
 913    result=buf;
 914
 915    free(buf);
 916    iconv_close(utf7imap2utf8);
 917
 918    return result;
 919 }
 920
 921 std::string utf8_to_utf7imap(const std::string& utf8string)
 922 {
 923    string result;
 924
 925    iconv_t utf82utf7imap = iconv_open("UTF-7-IMAP", "UTF-8");
 926
 927    if (utf82utf7imap == (iconv_t)-1)
 928       throw runtime_error("iconv can't convert from UTF-7-IMAP to UTF-8");
 929
 930    // UTF-7 is base64 encoded, a buffer 10x as large
 931    // as the utf-8 buffer should be enough. If not the string will be truncated.
 932    size_t in_size=utf8string.size();
 933    size_t out_size=in_size*10;
 934
 935    char *buf = (char *)malloc(out_size+1);
 936    if (buf == NULL)
 937       throw runtime_error("out of memory for iconv buffer");
 938
 939    char *in = (char *)utf8string.c_str();
 940    char *out = buf;
 941    iconv(utf82utf7imap, &in, &in_size, &out, &out_size);
 942
 943    buf[utf8string.size()*10-out_size]= 0;
 944
 945    result=buf;
 946
 947    free(buf);
 948    iconv_close(utf82utf7imap);
 949
 950    return result;
 951 }
 952
 953 // Tokenize string by (html) tags
 954 void tokenize_by_tag(vector<pair<string,bool> > &tokenized, const std::string &input)
 955 {
 956    string::size_type pos, len = input.size();
 957    bool inside_tag = false;
 958    string current;
 959
 960    for (pos = 0; pos < len; pos++)
 961    {
 962       if (input[pos] == '<')
 963       {
 964          inside_tag = true;
 965
 966          if (!current.empty() )
 967          {
 968             tokenized.push_back( make_pair(current, false) );
 969             current = "";
 970          }
 971
 972          current += input[pos];
 973       }
 974       else if (input[pos] == '>' && inside_tag)
 975       {
 976          current += input[pos];
 977          inside_tag = false;
 978          if (!current.empty() )
 979          {
 980             tokenized.push_back( make_pair(current, true) );
 981             current = "";
 982          }
 983       }
 984       else
 985          current += input[pos];
 986    }
 987
 988    // String left over in buffer?
 989    if (!current.empty() )
 990       tokenized.push_back( make_pair(current, false) );
 991 } // eo tokenize_by_tag
 992
 993
 994 std::string strip_html_tags(const std::string &input)
 995 {
 996    // Pair first: string, second: isTag
 997    vector<pair<string,bool> > tokenized;
 998    tokenize_by_tag (tokenized, input);
 999
1000    string output;
1001    vector<pair<string,bool> >::const_iterator token, tokens_end = tokenized.end();
1002    for (token = tokenized.begin(); token != tokens_end; ++token)
1003       if (!token->second)
1004          output += token->first;
1005
1006    return output;
1007 } // eo strip_html_tags
1008
1009
1010 // Smart-encode HTML en
1011 string smart_html_entities(const std::string &input)
1012 {
1013    // Pair first: string, second: isTag
1014    vector<pair<string,bool> > tokenized;
1015    tokenize_by_tag (tokenized, input);
1016
1017    string output;
1018    vector<pair<string,bool> >::const_iterator token, tokens_end = tokenized.end();
1019    for (token = tokenized.begin(); token != tokens_end; ++token)
1020    {
1021       // keep HTML tags as they are
1022       if (token->second)
1023          output += token->first;
1024       else
1025          output += html_entities(token->first);
1026    }
1027
1028    return output;
1029 }
1030
1031
1032 string::size_type find_8bit(const std::string &str)
1033 {
1034    string::size_type l=str.size();
1035    for (string::size_type p=0; p < l; p++)
1036       if (static_cast<unsigned char>(str[p]) > 127)
1037          return p;
1038
1039    return string::npos;
1040 }
1041
1042 // encoded UTF-8 chars into HTML entities
1043 string html_entities(std::string str)
1044 {
1045    // Normal chars
1046    replace_all (str, "&", "&amp;");
1047    replace_all (str, "<", "&lt;");
1048    replace_all (str, ">", "&gt;");
1049    replace_all (str, "\"", "&quot;");
1050    replace_all (str, "'", "&#x27;");
1051    replace_all (str, "/", "&#x2F;");
1052
1053    // Umlauts
1054    replace_all (str, "\xC3\xA4", "&auml;");
1055    replace_all (str, "\xC3\xB6", "&ouml;");
1056    replace_all (str, "\xC3\xBC", "&uuml;");
1057    replace_all (str, "\xC3\x84", "&Auml;");
1058    replace_all (str, "\xC3\x96", "&Ouml;");
1059    replace_all (str, "\xC3\x9C", "&Uuml;");
1060
1061    // Misc
1062    replace_all (str, "\xC3\x9F", "&szlig;");
1063
1064    // conversion of remaining non-ASCII chars needed?
1065    // just do if needed because of performance
1066    if (find_8bit(str) != string::npos)
1067    {
1068       // convert to fixed-size encoding UTF-32
1069       wchar_t* wbuf=utf8_to_wbuf(str);
1070       ostringstream target;
1071
1072       // replace all non-ASCII chars with HTML representation
1073       for (int p=0; wbuf[p] != 0; p++)
1074       {
1075          unsigned int c=wbuf[p];
1076
1077          if (c <= 127)
1078             target << static_cast<unsigned char>(c);
1079          else
1080             target << "&#" << c << ';';
1081       }
1082
1083       free(wbuf);
1084
1085       str=target.str();
1086    }
1087
1088    return str;
1089 } // eo html_entities(std::string)
1090
1091 // convert HTML entities to something that can be viewed on a basic text console (restricted to ASCII-7)
1092 string html_entities_to_console(std::string str)
1093 {
1094    // Normal chars
1095    replace_all (str, "&amp;", "&");
1096    replace_all (str, "&lt;", "<");
1097    replace_all (str, "&gt;", ">");
1098    replace_all (str, "&quot;", "\"");
1099    replace_all (str, "&#x27;", "'");
1100    replace_all (str, "&#x2F;", "/");
1101
1102    // Umlauts
1103    replace_all (str, "&auml;", "ae");
1104    replace_all (str, "&ouml;", "oe");
1105    replace_all (str, "&uuml;", "ue");
1106    replace_all (str, "&Auml;", "Ae");
1107    replace_all (str, "&Ouml;", "Oe");
1108    replace_all (str, "&Uuml;", "Ue");
1109
1110    // Misc
1111    replace_all (str, "&szlig;", "ss");
1112
1113    return str;
1114 }
1115
1116 // find_html_comments + remove_html_comments(str, comments)
1117 void remove_html_comments(string &str)
1118 {
1119     vector<CommentZone> comments = find_html_comments(str);
1120     remove_html_comments(str, comments);
1121 }
1122
1123 // find all html comments, behaving correctly if they are nested; ignores comment tags ("<!--FOO .... BAR-->")
1124 // If there are invalid comments ("-->" before "<!--" or different number of closing and opening tags),
1125 // then the unknown index of corresponding start/end tag will be represented by a string::npos
1126 // Indices are from start of start tag until first index after closing tag
1127 vector<CommentZone> find_html_comments(const std::string &str)
1128 {
1129     static const string START = "<!--";
1130     static const string CLOSE = "-->";
1131     static const string::size_type START_LEN = START.length();
1132     static const string::size_type CLOSE_LEN = CLOSE.length();
1133
1134     vector<CommentZone> comments;
1135
1136     // in order to find nested comments, need either recursion or a stack
1137     vector<string::size_type> starts;      // stack of start tags
1138
1139     string::size_type pos = 0;
1140     string::size_type len = str.length();
1141     string::size_type next_start, next_close;
1142
1143     while (pos < len)     // not really needed but just in case
1144     {
1145         next_start = str.find(START, pos);
1146         next_close = str.find(CLOSE, pos);
1147
1148         if ( (next_start == string::npos) && (next_close == string::npos) )
1149             break;   // we are done
1150
1151         else if ( (next_start == string::npos) || (next_close < next_start) )  // close one comment (pop)
1152         {
1153             if (starts.empty())    // closing tag without a start
1154                 comments.push_back(CommentZone(string::npos, next_close+CLOSE_LEN));
1155             else
1156             {
1157                 comments.push_back(CommentZone(starts.back(), next_close+CLOSE_LEN));
1158                 starts.pop_back();
1159             }
1160             pos = next_close + CLOSE_LEN;
1161         }
1162
1163         else if ( (next_close == string::npos) || (next_start < next_close) )  // start a new comment (push)
1164         {
1165             starts.push_back(next_start);
1166             pos = next_start + START_LEN;
1167         }
1168     }
1169
1170     // add comments that have no closing tag from back to front (important for remove_html_comments!)
1171     while (!starts.empty())
1172     {
1173         comments.push_back(CommentZone(starts.back(), string::npos));
1174         starts.pop_back();
1175     }
1176
1177     return comments;
1178 }
1179
1180 // remove all html comments foundby find_html_comments
1181 void remove_html_comments(std::string &str, const vector<CommentZone> &comments)
1182 {
1183     // remember position where last removal started
1184     string::size_type last_removal_start = str.length();
1185
1186     // Go from back to front to not mess up indices.
1187     // This requires that bigger comments, that contain smaller comments, come AFTER
1188     // the small contained comments in the comments vector (i.e. comments are ordered by
1189     // their closing tag, not their opening tag). This is true for results from find_html_comments
1190     BOOST_REVERSE_FOREACH(const CommentZone &comment, comments)
1191     {
1192         if (comment.first == string::npos)
1193         {
1194             str = str.replace(0, comment.second, "");   // comment starts "before" str --> delete from start
1195             break;   // there can be no more
1196         }
1197         else if (comment.first >= last_removal_start)
1198         {
1199             continue;    // this comment is inside another comment that we have removed already
1200         }
1201         else if (comment.second == string::npos)   // comment ends "after" str --> delete until end
1202         {
1203             str = str.replace(comment.first, string::npos, "");
1204             last_removal_start = comment.first;
1205         }
1206         else
1207         {
1208             str = str.replace(comment.first, comment.second-comment.first, "");
1209             last_removal_start = comment.first;
1210         }
1211     }
1212 }
1213
1214 bool replace_all(string &base, const char *ist, const char *soll)
1215 {
1216    string i=ist;
1217    string s=soll;
1218    return replace_all(base,&i,&s);
1219 }
1220
1221 bool replace_all(string &base, const string &ist, const char *soll)
1222 {
1223    string s=soll;
1224    return replace_all(base,&ist,&s);
1225 }
1226
1227 bool replace_all(string &base, const string *ist, const string *soll)
1228 {
1229    return replace_all(base,*ist,*soll);
1230 }
1231
1232 bool replace_all(string &base, const char *ist, const string *soll)
1233 {
1234    string i=ist;
1235    return replace_all(base,&i,soll);
1236 }
1237
1238 bool replace_all(string &base, const string &ist, const string &soll)
1239 {
1240    bool found_ist = false;
1241    string::size_type a=0;
1242
1243    if (ist.empty() )
1244       throw runtime_error ("replace_all called with empty search string");
1245
1246    while ( (a=base.find(ist,a) ) != string::npos)
1247    {
1248       base.replace(a,ist.size(),soll);
1249       a=a+soll.size();
1250       found_ist = true;
1251    }
1252
1253    return found_ist;
1254 }
1255
1256 /**
1257  * @brief replaces all characters that could be problematic or impose a security risk when being logged
1258  * @param str the original string
1259  * @param replace_with the character to replace the unsafe chars with
1260  * @return a string that is safe to send to syslog or other logfiles
1261  *
1262  * All chars between 0x20 (space) and 0x7E (~) (including) are considered safe for logging.
1263  * See e.g. RFC 5424, section 8.2 or the posix character class "printable".
1264  * This eliminates all possible problems with NUL, control characters, 8 bit chars, UTF8.
1265  *
1266  */
1267 std::string sanitize_for_logging(const std::string &str, const char replace_with)
1268 {
1269     std::string output=str;
1270
1271     const string::size_type len = output.size();
1272     for (std::string::size_type p=0; p < len; p++)
1273         if (output[p] < 0x20 || output[p] > 0x7E)
1274             output[p]=replace_with;
1275
1276     return output;
1277 }
1278
1279 #if 0
1280 string to_lower(const string &src)
1281 {
1282    string dst = src;
1283
1284    string::size_type pos, end = dst.size();
1285    for (pos = 0; pos < end; pos++)
1286       dst[pos] = tolower(dst[pos]);
1287
1288    return dst;
1289 }
1290
1291 string to_upper(const string &src)
1292 {
1293    string dst = src;
1294
1295    string::size_type pos, end = dst.size();
1296    for (pos = 0; pos < end; pos++)
1297       dst[pos] = toupper(dst[pos]);
1298
1299    return dst;
1300 }
1301 #endif
1302
1303 const int MAX_UNIT_FORMAT_SYMBOLS = 6;
1304
1305 const string shortUnitFormatSymbols[MAX_UNIT_FORMAT_SYMBOLS] = {
1306         " B",
1307         " KB",
1308         " MB",
1309         " GB",
1310         " TB",
1311         " PB"
1312 };
1313
1314 const string longUnitFormatSymbols[MAX_UNIT_FORMAT_SYMBOLS] = {
1315         i18n_noop(" Bytes"),
1316         i18n_noop(" KBytes"),
1317         i18n_noop(" MBytes"),
1318         i18n_noop(" GBytes"),
1319         i18n_noop(" TBytes"),
1320         i18n_noop(" PBytes")
1321 };
1322
1323
1324 static long double rounding_upwards(
1325         const long double number,
1326         const int rounding_multiplier
1327 )
1328 {
1329     long double rounded_number;
1330     rounded_number = number * rounding_multiplier;
1331     rounded_number += 0.5;
1332     rounded_number = (int64_t) (rounded_number);
1333     rounded_number = (long double) (rounded_number) / (long double) (rounding_multiplier);
1334
1335     return rounded_number;
1336 }
1337
1338
1339 string nice_unit_format(
1340         const int64_t input,
1341         const UnitFormat format,
1342         const UnitBase base
1343 )
1344 {
1345    // select the system of units (decimal or binary)
1346    int multiple = 0;
1347    if (base == UnitBase1000)
1348    {
1349        multiple = 1000;
1350    }
1351    else
1352    {
1353        multiple = 1024;
1354    }
1355
1356    long double size = input;
1357
1358    // check the size of the input number to fit in the appropriate symbol
1359    int sizecount = 0;
1360    while (size > multiple)
1361    {
1362        size = size / multiple;
1363        sizecount++;
1364
1365        // rollback to the previous values and stop the loop when cannot
1366        // represent the number length.
1367        if (sizecount >= MAX_UNIT_FORMAT_SYMBOLS)
1368        {
1369            size = size * multiple;
1370            sizecount--;
1371            break;
1372        }
1373    }
1374
1375    // round the input number "half up" to multiples of 10
1376    const int rounding_multiplier = 10;
1377    size = rounding_upwards(size, rounding_multiplier);
1378
1379    // format the input number, placing the appropriate symbol
1380    ostringstream out;
1381    out.setf (ios::fixed);
1382    if (format == ShortUnitFormat)
1383    {
1384        out.precision(1);
1385        out << size << i18n( shortUnitFormatSymbols[sizecount].c_str() );
1386    }
1387    else
1388    {
1389        out.precision (2);
1390        out << size << i18n( longUnitFormatSymbols[sizecount].c_str() );
1391    }
1392
1393    return out.str();
1394 } // eo nice_unit_format(int input)
1395
1396
1397 string nice_unit_format(
1398         const double input,
1399         const UnitFormat format,
1400         const UnitBase base
1401 )
1402 {
1403     // round as double and cast to int64_t
1404     // cast raised overflow error near max val of int64_t (~9.2e18, see unittest)
1405     int64_t input_casted_and_rounded =
1406         boost::numeric_cast<int64_t>( round(input) );
1407
1408     // now call other
1409     return nice_unit_format( input_casted_and_rounded, format, base );
1410 } // eo nice_unit_format(double input)
1411
1412
1413 string escape(const string &s)
1414 {
1415    string out(s);
1416    string::size_type p;
1417
1418    p=0;
1419    while ( (p=out.find_first_of("\"\\",p) ) !=out.npos)
1420    {
1421       out.insert (p,"\\");
1422       p+=2;
1423    }
1424
1425    p=0;
1426    while ( (p=out.find_first_of("\r",p) ) !=out.npos)
1427    {
1428       out.replace (p,1,"\\r");
1429       p+=2;
1430    }
1431
1432    p=0;
1433    while ( (p=out.find_first_of("\n",p) ) !=out.npos)
1434    {
1435       out.replace (p,1,"\\n");
1436       p+=2;
1437    }
1438
1439    out='"'+out+'"';
1440
1441    return out;
1442 } // eo scape(const std::string&)
1443
1444
1445 string descape(const string &s, int startpos, int &endpos)
1446 {
1447    string out;
1448
1449    if (s.at(startpos) != '"')
1450       throw out_of_range("value not type escaped string");
1451
1452    out=s.substr(startpos+1);
1453    string::size_type p=0;
1454
1455    // search for the end of the string
1456    while ( (p=out.find("\"",p) ) !=out.npos)
1457    {
1458       int e=p-1;
1459       bool escaped=false;
1460
1461       // the " might be escaped with a backslash
1462       while (e>=0 && out.at (e) =='\\')
1463       {
1464          if (escaped == false)
1465             escaped=true;
1466          else
1467             escaped=false;
1468
1469          e--;
1470       }
1471
1472       if (escaped==false)
1473          break;
1474       else
1475          p++;
1476    }
1477
1478    // we now have the end of the string
1479    out=out.substr(0,p);
1480
1481    // tell calling prog about the endposition
1482    endpos=startpos+p+1;
1483
1484    // descape all \ stuff inside the string now
1485    p=0;
1486    while ( (p=out.find_first_of("\\",p) ) !=out.npos)
1487    {
1488       switch (out.at(p+1) )
1489       {
1490          case 'r':
1491             out.replace(p,2,"\r");
1492             break;
1493          case 'n':
1494             out.replace(p,2,"\n");
1495             break;
1496          default:
1497             out.erase(p,1);
1498       }
1499       p++;
1500    }
1501
1502    return out;
1503 } // eo descape(const std::string&,int,int&)
1504
1505
1506 string escape_shellarg(const string &input)
1507 {
1508    string output = "'";
1509    string::const_iterator it, it_end = input.end();
1510    for (it = input.begin(); it != it_end; ++it)
1511    {
1512       if ( (*it) == '\'')
1513          output += "'\\'";
1514
1515       output += *it;
1516    }
1517
1518    output += "'";
1519    return output;
1520 }