Line data Source code
1 : /*
2 : *
3 : * Copyright (c) 2020 Project CHIP Authors
4 : *
5 : * Licensed under the Apache License, Version 2.0 (the "License");
6 : * you may not use this file except in compliance with the License.
7 : * You may obtain a copy of the License at
8 : *
9 : * http://www.apache.org/licenses/LICENSE-2.0
10 : *
11 : * Unless required by applicable law or agreed to in writing, software
12 : * distributed under the License is distributed on an "AS IS" BASIS,
13 : * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 : * See the License for the specific language governing permissions and
15 : * limitations under the License.
16 : */
17 :
18 : /**
19 : * @file
20 : * This file defines constant enumerations for all public (or
21 : * common) protocols.
22 : *
23 : */
24 :
25 : #pragma once
26 :
27 : #include <lib/core/CHIPVendorIdentifiers.hpp>
28 : #include <lib/support/TypeTraits.h>
29 :
30 : namespace chip {
31 : namespace Protocols {
32 :
33 : //
34 : // CHIP Protocol Ids (32-bits max)
35 : //
36 : class Id
37 : {
38 : public:
39 9755 : constexpr Id(VendorId aVendorId, uint16_t aProtocolId) : mVendorId(aVendorId), mProtocolId(aProtocolId) {}
40 :
41 19825 : constexpr bool operator==(const Id & aOther) const
42 : {
43 19825 : return mVendorId == aOther.mVendorId && mProtocolId == aOther.mProtocolId;
44 : }
45 :
46 : constexpr bool operator!=(const Id & aOther) const { return !(*this == aOther); }
47 :
48 : // Convert the Protocols::Id to a TLV profile id.
49 : // NOTE: We may want to change the TLV reader/writer to take Protocols::Id
50 : // directly later on and get rid of this method.
51 : constexpr uint32_t ToTLVProfileId() const { return ToUint32(); }
52 :
53 : // Convert the protocol id to a 32-bit unsigned integer "fully qualified"
54 : // form as defined in the spec. This should only be used in the places
55 : // where the spec defines a 32-bit unsigned in as a wire representation of
56 : // protocol id.
57 72 : constexpr uint32_t ToFullyQualifiedSpecForm() const { return ToUint32(); }
58 :
59 63394 : constexpr VendorId GetVendorId() const { return mVendorId; }
60 68428 : constexpr uint16_t GetProtocolId() const { return mProtocolId; }
61 :
62 : static constexpr uint32_t kVendorIdShift = 16;
63 :
64 23 : static Id FromFullyQualifiedSpecForm(uint32_t aSpecForm)
65 : {
66 23 : return Id(static_cast<VendorId>(aSpecForm >> kVendorIdShift),
67 23 : static_cast<uint16_t>(aSpecForm & ((1 << kVendorIdShift) - 1)));
68 : }
69 :
70 : private:
71 72 : constexpr uint32_t ToUint32() const { return (static_cast<uint32_t>(mVendorId) << kVendorIdShift) | mProtocolId; }
72 :
73 : chip::VendorId mVendorId;
74 : uint16_t mProtocolId;
75 : };
76 :
77 : // Common Protocols
78 : //
79 : // NOTE: Do not attempt to allocate these values yourself.
80 : #define CHIP_STANDARD_PROTOCOL(name, id) \
81 : namespace name { \
82 : static constexpr Protocols::Id Id(VendorId::Common, id); \
83 : } // namespace name.
84 :
85 : CHIP_STANDARD_PROTOCOL(SecureChannel, 0x0000) // Secure Channel Protocol
86 : CHIP_STANDARD_PROTOCOL(InteractionModel, 0x0001) // Interaction Model Protocol
87 : CHIP_STANDARD_PROTOCOL(BDX, 0x0002) // Bulk Data Exchange Protocol
88 : CHIP_STANDARD_PROTOCOL(UserDirectedCommissioning, 0x0003) // User Directed Commissioning Protocol
89 : CHIP_STANDARD_PROTOCOL(Echo, 0x0004) // Echo Protocol. To be removed or standardized.
90 :
91 : #undef CHIP_STANDARD_PROTOCOL
92 :
93 : // Protocols reserved for internal protocol use
94 : static constexpr Id NotSpecified(VendorId::NotSpecified, 0xFFFF); // The profile ID is either not specified or a wildcard
95 :
96 : //
97 : // Pre-declaration of type traits that protocol headers are expected to define.
98 : //
99 : // A protocol header should first define an enumeration that lists the various message types as enum classes.
100 : //
101 : // It should then define MessageTypeTraits as a template specialization of that enumeration containing two methods:
102 : // 1. static constexpr const Protocols::Id & ProtocolId() that returns the Protocol ID
103 : // 2. static auto GetTypeToNameTable() that returns a pointer to std::array<MessageTypeNameLookup, N> where N = number of
104 : // messages in protocol.
105 : //
106 : template <typename T>
107 : struct MessageTypeTraits;
108 :
109 : //
110 : // Encapsulates a tuple of message type ID and its associated name.
111 : //
112 : struct MessageTypeNameLookup
113 : {
114 : //
115 : // Constructor that takes an enumeration value for a specific message ID and its associated name.
116 : //
117 : template <typename T>
118 : constexpr MessageTypeNameLookup(T id, const char * name) : mId(to_underlying(id)), mName(name)
119 : {}
120 :
121 : const uint8_t mId;
122 : const char * mName;
123 : };
124 :
125 : //
126 : // Given a protocol ID and a message type ID, retrieve the logical name of that message.
127 : //
128 : // This will not return a nullptr.
129 : //
130 : const char * GetMessageTypeName(Id protocolId, uint8_t msgType);
131 :
132 : //
133 : // Given a protool ID, retrieve the logical name for that protocol.
134 : //
135 : // This will not return a nullptr.
136 : //
137 : const char * GetProtocolName(Id protocolId);
138 :
139 : } // namespace Protocols
140 : } // namespace chip
|
