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
|
// Copyright 2022 The ChromiumOS Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef LIBIPP_VALIDATOR_H_
#define LIBIPP_VALIDATOR_H_
#include <cstddef>
#include <cstdint>
#include <set>
#include <string>
#include <string_view>
#include <vector>
#include "errors.h"
#include "frame.h"
#include "ipp_export.h"
namespace ipp {
// Maximum size of 'text' value (rfc8011, section 5.1.2).
constexpr size_t kMaxLengthOfText = 1023;
// Maximum size of 'name' value (rfc8011, section 5.1.3).
constexpr size_t kMaxLengthOfName = 255;
// Maximum size of 'keyword' value (rfc8011, section 5.1.4).
constexpr size_t kMaxLengthOfKeyword = 255;
// Maximum size of 'uri' value (rfc8011, section 5.1.6).
constexpr size_t kMaxLengthOfUri = 1023;
// Maximum size of 'uriScheme' value (rfc8011, section 5.1.7).
constexpr size_t kMaxLengthOfUriScheme = 63;
// Maximum size of 'charset' value (rfc8011, section 5.1.8).
constexpr size_t kMaxLengthOfCharset = 63;
// Maximum size of 'naturalLanguage' value (rfc8011, section 5.1.9).
constexpr size_t kMaxLengthOfNaturalLanguage = 63;
// Maximum size of 'mimeMediaType' value (rfc8011, section 5.1.10).
constexpr size_t kMaxLengthOfMimeMediaType = 255;
// Maximum size of 'octetString' value (rfc8011, section 5.1.11).
constexpr size_t kMaxLengthOfOctetString = 1023;
// Describes types of validation errors in a single value.
enum class ValidatorCode : uint8_t {
// The string value is empty when it is not allowed.
kStringEmpty = 0,
// The string value is too long.
kStringTooLong,
// The string value is supposed to start with a lowercase letter and it
// doesn't.
kStringMustStartLowercaseLetter,
// The string value contains invalid character.
kStringInvalidCharacter,
// The value of type textWithLanguage or nameWithLanguage has invalid language
// part.
kStringWithLangInvalidLanguage,
// The dateTime value has invalid date.
kDateTimeInvalidDate,
// The dateTime value has invalid time of day.
kDateTimeInvalidTimeOfDay,
// The dateTime value has invalid timezone.
kDateTimeInvalidZone,
// The resolution value has invalid units.
kResolutionInvalidUnit,
// The resolution value has at least one invalid dimension.
kResolutionInvalidDimension,
// The rangeOfIntegers value has min threshold larger than max threshold.
kRangeOfIntegerMaxLessMin,
// The integer value is out of allowed range.
kIntegerOutOfRange
};
// Returns a string representation of `code`. Returned string contains a name
// of corresponding enum's value and has no whitespaces.
LIBIPP_EXPORT std::string_view ToStrView(ValidatorCode code);
// Represents information about invalid value or name of an attribute.
class LIBIPP_EXPORT AttrError {
public:
// `errors` contains validation errors of an attribute's name.
explicit AttrError(std::set<ValidatorCode>&& errors)
: index_(0xffffu), errors_(errors) {}
// `errors` contains validation errors for the value at `index`.
AttrError(uint16_t index, std::set<ValidatorCode>&& errors)
: index_(index), errors_(errors) {}
// Returns true if it is about the attribute's name.
bool IsInTheName() const { return Index() == 0xffffu; }
// Returns the index of the incorrect value or 0xffff if it is about
// the attribute's name.
uint16_t Index() const { return index_; }
// Returns errors as SetOfErrors.
const std::set<ValidatorCode> Errors() const { return errors_; }
// Returns errors as vector. Codes in the vector are sorted and unique.
std::vector<ValidatorCode> ErrorsAsVector() const;
private:
uint16_t index_;
std::set<ValidatorCode> errors_;
};
// The structure represents an `error` for the attribute at `path`.
struct ValidatorError {
AttrPath path;
AttrError error;
};
// Returns one-line string representation of the `error`. There is no EOL
// characters in the returned message.
LIBIPP_EXPORT std::string ToString(const ValidatorError& error);
// The interface of validator log.
class ValidatorLog {
public:
ValidatorLog() = default;
ValidatorLog(const ValidatorLog&) = delete;
ValidatorLog& operator=(const ValidatorLog&) = delete;
virtual ~ValidatorLog() = default;
// Reports an `error` found by the validator. The errors are reported in
// the same order as they occurred in the frame. Return false if you do not
// want to get any more AddValidationError() calls.
virtual bool AddValidatorError(const ValidatorError& error) = 0;
};
// Simple implementation of the ValidatorLog interface. It just saves the first
// `max_entries_count` (see the constructor) errors in the frame.
class LIBIPP_EXPORT SimpleValidatorLog : public ValidatorLog {
public:
explicit SimpleValidatorLog(size_t max_entries_count = 100)
: max_entries_count_(max_entries_count) {}
bool AddValidatorError(const ValidatorError& error) override;
const std::vector<ValidatorError>& Entries() const { return entries_; }
private:
const size_t max_entries_count_;
std::vector<ValidatorError> entries_;
};
// Validates all groups in the `frame`. All detected errors are saved in `log`
// in the order they occur in the original frame. The function returns true <=>
// no errors were detected.
// For string types only the basic features are validated, there is no UTF-8
// parsing or type-specific parsing like URL or MIME types.
bool LIBIPP_EXPORT Validate(const Frame& frame, ValidatorLog& log);
} // namespace ipp
#endif // LIBIPP_VALIDATOR_H_
|
