/usr/include/KF5/KMime/kmime/kmime_header_parsing.h is in libkf5mime-dev 15.12.3-0ubuntu1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 | /* -*- c++ -*-
kmime_header_parsing.h
KMime, the KDE Internet mail/usenet news message library.
Copyright (c) 2001-2002 Marc Mutz <mutz@kde.org>
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#ifndef __KMIME_HEADER_PARSING_H__
#define __KMIME_HEADER_PARSING_H__
#include "kmime_export.h"
#include "kmime_types.h"
#include <QtCore/QString>
#include <QtCore/QPair>
#include <QtCore/QVector>
#include <qdatetime.h>
template <typename K, typename V> class QMap;
class QStringList;
namespace KMime
{
namespace Headers
{
class Base;
}
namespace Types
{
// for when we can't make up our mind what to use...
// FIXME: Remove this thing, we should _always_ know whether we are handling a
// byte array or a string.
// In most places where this is used, it should simply be replaced by QByteArray
struct KMIME_EXPORT QStringOrQPair {
QStringOrQPair() : qstring(), qpair(0, 0) {}
QString qstring;
QPair<const char *, int> qpair;
};
} // namespace KMime::Types
namespace HeaderParsing
{
/**
Parses the encoded word.
@param scursor pointer to the first character beyond the initial '=' of
the input string.
@param send pointer to end of input buffer.
@param result the decoded string the encoded work represented.
@param language The language parameter according to RFC 2231, section 5.
@param usedCS the used charset is returned here
@param defaultCS the charset to use in case the detected
one isn't known to us.
@param forceCS force the use of the default charset.
@return true if the input string was successfully decode; false otherwise.
*/
KMIME_EXPORT bool parseEncodedWord(const char *&scursor,
const char *const send,
QString &result, QByteArray &language,
QByteArray &usedCS, const QByteArray &defaultCS = QByteArray(),
bool forceCS = false);
//
// The parsing squad:
//
/** You may or may not have already started parsing into the
atom. This function will go on where you left off. */
KMIME_EXPORT bool parseAtom(const char *&scursor, const char *const send,
QString &result, bool allow8Bit = false);
KMIME_EXPORT bool parseAtom(const char *&scursor, const char *const send,
QPair<const char *, int> &result,
bool allow8Bit = false);
/** You may or may not have already started parsing into the
token. This function will go on where you left off. */
KMIME_EXPORT bool parseToken(const char *&scursor, const char *const send,
QString &result, bool allow8Bit = false);
KMIME_EXPORT bool parseToken(const char *&scursor, const char *const send,
QPair<const char *, int> &result,
bool allow8Bit = false);
/** @p scursor must be positioned after the opening openChar. */
KMIME_EXPORT bool parseGenericQuotedString(const char *&scursor,
const char *const send,
QString &result, bool isCRLF,
const char openChar = '"',
const char closeChar = '"');
/** @p scursor must be positioned right after the opening '(' */
KMIME_EXPORT bool parseComment(const char *&scursor, const char *const send,
QString &result, bool isCRLF = false,
bool reallySave = true);
/**
Parses a phrase.
You may or may not have already started parsing into the phrase, but
only if it starts with atext. If you setup this function to parse a
phrase starting with an encoded-word or quoted-string, @p scursor has
to point to the char introducing the encoded-word or quoted-string, resp.
@param scursor pointer to the first character beyond the initial '=' of
the input string.
@param send pointer to end of input buffer.
@param result the parsed string.
@return true if the input phrase was successfully parsed; false otherwise.
*/
KMIME_EXPORT bool parsePhrase(const char *&scursor, const char *const send,
QString &result, bool isCRLF = false);
/**
Parses into the initial atom.
You may or may not have already started parsing into the initial
atom, but not up to it's end.
@param scursor pointer to the first character beyond the initial '=' of
the input string.
@param send pointer to end of input buffer.
@param result the parsed string.
@return true if the input phrase was successfully parsed; false otherwise.
*/
KMIME_EXPORT bool parseDotAtom(const char *&scursor, const char *const send,
QString &result, bool isCRLF = false);
/**
Eats comment-folding-white-space, skips whitespace, folding and comments
(even nested ones) and stops at the next non-CFWS character. After
calling this function, you should check whether @p scursor == @p send
(end of header reached).
If a comment with unbalanced parantheses is encountered, @p scursor
is being positioned on the opening '(' of the outmost comment.
@param scursor pointer to the first character beyond the initial '=' of
the input string.
@param send pointer to end of input buffer.
@param isCRLF true if input string is terminated with a CRLF.
*/
KMIME_EXPORT void eatCFWS(const char *&scursor, const char *const send,
bool isCRLF);
KMIME_EXPORT bool parseDomain(const char *&scursor, const char *const send,
QString &result, bool isCRLF = false);
KMIME_EXPORT bool parseObsRoute(const char *&scursor, const char *const send,
QStringList &result, bool isCRLF = false,
bool save = false);
KMIME_EXPORT bool parseAddrSpec(const char *&scursor, const char *const send,
Types::AddrSpec &result, bool isCRLF = false);
KMIME_EXPORT bool parseAngleAddr(const char *&scursor, const char *const send,
Types::AddrSpec &result, bool isCRLF = false);
/**
Parses a single mailbox.
RFC 2822, section 3.4 defines a mailbox as follows:
<pre>mailbox := addr-spec / ([ display-name ] angle-addr)</pre>
KMime also accepts the legacy format of specifying display names:
<pre>mailbox := (addr-spec [ "(" display-name ")" ])
/ ([ display-name ] angle-addr)
/ (angle-addr "(" display-name ")")</pre>
@param scursor pointer to the first character of the input string
@param send pointer to end of input buffer
@param result the parsing result
@param isCRLF true if input string is terminated with a CRLF.
*/
KMIME_EXPORT bool parseMailbox(const char *&scursor, const char *const send,
Types::Mailbox &result, bool isCRLF = false);
KMIME_EXPORT bool parseGroup(const char *&scursor, const char *const send,
Types::Address &result, bool isCRLF = false);
KMIME_EXPORT bool parseAddress(const char *&scursor, const char *const send,
Types::Address &result, bool isCRLF = false);
KMIME_EXPORT bool parseAddressList(const char *&scursor,
const char *const send,
Types::AddressList &result,
bool isCRLF = false);
KMIME_EXPORT bool parseParameter(const char *&scursor, const char *const send,
QPair<QString, Types::QStringOrQPair> &result,
bool isCRLF = false);
KMIME_EXPORT bool parseParameterList(const char *&scursor,
const char *const send,
QMap<QString, QString> &result,
bool isCRLF = false);
KMIME_EXPORT bool parseRawParameterList(const char *&scursor,
const char *const send,
QMap<QString, Types::QStringOrQPair> &result,
bool isCRLF = false);
/**
* Extract the charset embedded in the parameter list if there is one.
*
* @since 4.5
*/
KMIME_EXPORT bool parseParameterListWithCharset(const char *&scursor,
const char *const send,
QMap<QString, QString> &result,
QByteArray &charset, bool isCRLF = false);
/**
Parses an integer number.
@param scursor pointer to the first character of the input string
@param send pointer to end of input buffer
@param result the parsing result
@returns The number of parsed digits (don't confuse with @p result!)
*/
KMIME_EXPORT int parseDigits(const char *&scursor, const char *const send, int &result);
KMIME_EXPORT bool parseTime(const char *&scursor, const char *const send,
int &hour, int &min, int &sec,
long int &secsEastOfGMT,
bool &timeZoneKnown, bool isCRLF = false);
KMIME_EXPORT bool parseDateTime(const char *&scursor, const char *const send,
QDateTime &result, bool isCRLF = false);
/**
* Extracts and returns the first header that is contained in the given byte array.
* The header will also be removed from the passed-in byte array head.
*
* @since 4.4
*/
KMIME_EXPORT KMime::Headers::Base *extractFirstHeader(QByteArray &head);
/**
* Extract the header header and the body from a complete content.
* Internally, it will simply look for the first newline and use that as a
* separator between the header and the body.
*
* @param content the complete mail
* @param header return value for the extracted header
* @param body return value for the extracted body
* @since 4.6
*/
KMIME_EXPORT void extractHeaderAndBody(const QByteArray &content,
QByteArray &header, QByteArray &body);
} // namespace HeaderParsing
} // namespace KMime
#endif // __KMIME_HEADER_PARSING_H__
|