← Back to branch summary

~ubuntu-branches/debian/experimental/kopete/experimental

« back to all changes in this revision

Viewing changes to protocols/jabber/libjingle/talk/base/base64.h

  • Committer: Package Import Robot
  • Author(s): Maximiliano Curia
  • Date: 2015-02-24 11:32:57 UTC
  • mfrom: (1.1.41 vivid)
  • Revision ID: package-import@ubuntu.com-20150224113257-gnupg4v7lzz18ij0
Tags: 4:14.12.2-1
* New upstream release (14.12.2).
* Bump Standards-Version to 3.9.6, no changes needed.

Show diffs side-by-side

added added

removed removed

Lines of Context:
protocols/jabber/libjingle/talk/base/base64.h
 
1
 
 
2
//*********************************************************************
 
3
//* C_Base64 - a simple base64 encoder and decoder.
 
4
//*
 
5
//*     Copyright (c) 1999, Bob Withers - bwit@pobox.com
 
6
//*
 
7
//* This code may be freely used for any purpose, either personal
 
8
//* or commercial, provided the authors copyright notice remains
 
9
//* intact.
 
10
//*********************************************************************
 
11
 
 
12
#ifndef TALK_BASE_BASE64_H__
 
13
#define TALK_BASE_BASE64_H__
 
14
 
 
15
#include <string>
 
16
#include <vector>
 
17
 
 
18
namespace talk_base {
 
19
 
 
20
class Base64
 
21
{
 
22
public:
 
23
  enum DecodeOption {
 
24
    DO_PARSE_STRICT =  1,  // Parse only base64 characters
 
25
    DO_PARSE_WHITE  =  2,  // Parse only base64 and whitespace characters
 
26
    DO_PARSE_ANY    =  3,  // Parse all characters
 
27
    DO_PARSE_MASK   =  3,
 
28
 
 
29
    DO_PAD_YES      =  4,  // Padding is required
 
30
    DO_PAD_ANY      =  8,  // Padding is optional
 
31
    DO_PAD_NO       = 12,  // Padding is disallowed
 
32
    DO_PAD_MASK     = 12,
 
33
 
 
34
    DO_TERM_BUFFER  = 16,  // Must termiante at end of buffer
 
35
    DO_TERM_CHAR    = 32,  // May terminate at any character boundary
 
36
    DO_TERM_ANY     = 48,  // May terminate at a sub-character bit offset
 
37
    DO_TERM_MASK    = 48,
 
38
 
 
39
    // Strictest interpretation
 
40
    DO_STRICT = DO_PARSE_STRICT | DO_PAD_YES | DO_TERM_BUFFER,
 
41
 
 
42
    DO_LAX    = DO_PARSE_ANY | DO_PAD_ANY | DO_TERM_CHAR,
 
43
  };
 
44
  typedef int DecodeFlags;
 
45
 
 
46
  static bool IsBase64Char(char ch);
 
47
 
 
48
  // Determines whether the given string consists entirely of valid base64
 
49
  // encoded characters.
 
50
  static bool IsBase64Encoded(const std::string& str);
 
51
 
 
52
  static void EncodeFromArray(const void* data, size_t len,
 
53
                              std::string* result);
 
54
  static bool DecodeFromArray(const char* data, size_t len, DecodeFlags flags,
 
55
                              std::string* result, size_t* data_used);
 
56
  static bool DecodeFromArray(const char* data, size_t len, DecodeFlags flags,
 
57
                              std::vector<char>* result, size_t* data_used);
 
58
 
 
59
  // Convenience Methods
 
60
  static inline std::string Encode(const std::string& data) {
 
61
    std::string result;
 
62
    EncodeFromArray(data.data(), data.size(), &result);
 
63
    return result;
 
64
  }
 
65
  static inline std::string Decode(const std::string& data, DecodeFlags flags) {
 
66
    std::string result;
 
67
    DecodeFromArray(data.data(), data.size(), flags, &result, NULL);
 
68
    return result;
 
69
  }
 
70
  static inline bool Decode(const std::string& data, DecodeFlags flags,
 
71
                            std::string* result, size_t* data_used)
 
72
  {
 
73
    return DecodeFromArray(data.data(), data.size(), flags, result, data_used);
 
74
  }
 
75
  static inline bool Decode(const std::string& data, DecodeFlags flags,
 
76
                            std::vector<char>* result, size_t* data_used)
 
77
  {
 
78
    return DecodeFromArray(data.data(), data.size(), flags, result, data_used);
 
79
  }
 
80
 
 
81
private:
 
82
  static const char Base64Table[];
 
83
  static const unsigned char DecodeTable[];
 
84
 
 
85
  static size_t GetNextQuantum(DecodeFlags parse_flags, bool illegal_pads,
 
86
                               const char* data, size_t len, size_t* dpos,
 
87
                               unsigned char qbuf[4], bool* padded);
 
88
  template<typename T>
 
89
  static bool DecodeFromArrayTemplate(const char* data, size_t len,
 
90
                                      DecodeFlags flags, T* result,
 
91
                                      size_t* data_used);
 
92
};
 
93
 
 
94
} // namespace talk_base
 
95
 
 
96
#endif // TALK_BASE_BASE64_H__