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
|
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set sw=2 ts=8 et tw=80 : */
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#ifndef mozilla_net_capsule_parser_h
#define mozilla_net_capsule_parser_h
#include "Capsule.h"
#include "mozilla/Maybe.h"
#include "mozilla/Result.h"
#include "mozilla/Span.h"
namespace mozilla::net {
class CapsuleDecoder;
class CapsuleParser final {
public:
class Listener {
public:
NS_INLINE_DECL_PURE_VIRTUAL_REFCOUNTING
virtual bool OnCapsule(Capsule&& aCapsule) = 0;
virtual void OnCapsuleParseFailure(nsresult aError) = 0;
protected:
virtual ~Listener() = default;
};
explicit CapsuleParser(Listener* aListener);
~CapsuleParser() = default;
// Processes incoming data and attempts to parse complete capsules.
// For each successfully parsed capsule, Listener::OnCapsule is invoked.
// If there is insufficient data to form a complete capsule, the remaining
// data is retained in mBuffer. In case a parsing error occurs,
// OnCapsuleParseFailure is called and any remaining data in mBuffer is
// discarded.
bool ProcessCapsuleData(const uint8_t* aData, uint32_t aCount);
bool IsBufferEmpty() const { return mBuffer.IsEmpty(); }
private:
// Indicates whether ProcessCapsuleData is already running.
bool mProcessing = false;
RefPtr<Listener> mListener;
// The buffer used to store data when we don't have enough to parse one
// capsule.
nsTArray<uint8_t> mBuffer;
// Parse one capsule from |aData|.
// Returns 0 if the complete capsule is not yet available, returns an error if
// parsing fails, or returns the number of bytes consumed for the successfully
// parsed capsule.
Result<size_t, nsresult> ParseCapsuleData(Span<const uint8_t> aData);
// Parse the payload part of the capsule. Returns the parsed capsule or an
// error.
Result<Capsule, nsresult> ParseCapsulePayload(CapsuleDecoder& aDecoder,
CapsuleType aType,
size_t aPayloadLength);
};
// This is mainly used for testing.
class CapsuleParserListener : public CapsuleParser::Listener {
public:
NS_INLINE_DECL_REFCOUNTING(CapsuleParserListener, override)
CapsuleParserListener() = default;
bool OnCapsule(Capsule&& aCapsule) override;
void OnCapsuleParseFailure(nsresult aError) override;
nsTArray<Capsule> GetParsedCapsules() { return std::move(mParsedCapsules); }
Maybe<nsresult> GetErrorResult() { return mError; }
private:
virtual ~CapsuleParserListener() = default;
nsTArray<Capsule> mParsedCapsules;
Maybe<nsresult> mError = Nothing();
};
} // namespace mozilla::net
#endif
|
