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 : #include "SetupPayloadHelper.h"
19 : #include "ManualSetupPayloadGenerator.h"
20 : #include "QRCodeSetupPayloadGenerator.h"
21 : #include "SetupPayload.h"
22 : #include <fstream>
23 : #include <utility>
24 :
25 : #include <lib/support/CodeUtils.h>
26 : #include <lib/support/logging/CHIPLogging.h>
27 :
28 : using namespace chip;
29 :
30 : namespace chip {
31 :
32 : enum SetupPayloadKey
33 : {
34 : SetupPayloadKey_Version,
35 : SetupPayloadKey_VendorID,
36 : SetupPayloadKey_ProductID,
37 : SetupPayloadKey_CommissioningFlow,
38 : SetupPayloadKey_RendezVousInformation,
39 : SetupPayloadKey_Discriminator,
40 : SetupPayloadKey_SetupPINCode,
41 : };
42 :
43 : struct SetupPayloadParameter
44 : {
45 : SetupPayloadKey key;
46 : std::string stringValue;
47 : uint64_t uintValue;
48 : };
49 :
50 0 : static CHIP_ERROR resolveSetupPayloadParameter(SetupPayloadParameter & parameter, const std::string & key,
51 : const std::string & value)
52 : {
53 0 : bool isUnsignedInt = true;
54 0 : bool shouldHaveValue = true;
55 0 : if (key == "version")
56 : {
57 0 : parameter.key = SetupPayloadKey_Version;
58 : }
59 0 : else if (key == "vendorID")
60 : {
61 0 : parameter.key = SetupPayloadKey_VendorID;
62 : }
63 0 : else if (key == "productID")
64 : {
65 0 : parameter.key = SetupPayloadKey_ProductID;
66 : }
67 0 : else if (key == "commissioningFlow")
68 : {
69 0 : parameter.key = SetupPayloadKey_CommissioningFlow;
70 : }
71 0 : else if (key == "rendezVousInformation")
72 : {
73 0 : parameter.key = SetupPayloadKey_RendezVousInformation;
74 : }
75 0 : else if (key == "discriminator")
76 : {
77 0 : parameter.key = SetupPayloadKey_Discriminator;
78 : }
79 0 : else if (key == "setUpPINCode")
80 : {
81 0 : parameter.key = SetupPayloadKey_SetupPINCode;
82 : }
83 : else
84 : {
85 0 : return CHIP_ERROR_INVALID_ARGUMENT;
86 : }
87 0 : if (shouldHaveValue && value.length() > 0)
88 : {
89 0 : if (isUnsignedInt)
90 : {
91 0 : parameter.uintValue = stoul(value, nullptr, 10);
92 : }
93 : else
94 : {
95 0 : parameter.stringValue = value;
96 : }
97 : }
98 0 : else if (shouldHaveValue)
99 : {
100 0 : return CHIP_ERROR_INVALID_ARGUMENT;
101 : }
102 0 : return CHIP_NO_ERROR;
103 : }
104 :
105 0 : static CHIP_ERROR addParameter(SetupPayload & setupPayload, const SetupPayloadParameter & parameter)
106 : {
107 0 : switch (parameter.key)
108 : {
109 0 : case SetupPayloadKey_Version:
110 0 : ChipLogDetail(SetupPayload, "Loaded version: %u", (uint8_t) parameter.uintValue);
111 0 : setupPayload.version = static_cast<uint8_t>(parameter.uintValue);
112 0 : break;
113 0 : case SetupPayloadKey_VendorID:
114 0 : ChipLogDetail(SetupPayload, "Loaded vendorID: %u", (uint16_t) parameter.uintValue);
115 0 : setupPayload.vendorID = static_cast<uint16_t>(parameter.uintValue);
116 0 : break;
117 0 : case SetupPayloadKey_ProductID:
118 0 : ChipLogDetail(SetupPayload, "Loaded productID: %u", (uint16_t) parameter.uintValue);
119 0 : setupPayload.productID = static_cast<uint16_t>(parameter.uintValue);
120 0 : break;
121 0 : case SetupPayloadKey_CommissioningFlow:
122 0 : ChipLogDetail(SetupPayload, "Commissioning flow: %u", (uint8_t) parameter.uintValue);
123 0 : setupPayload.commissioningFlow = static_cast<CommissioningFlow>(parameter.uintValue);
124 0 : break;
125 0 : case SetupPayloadKey_RendezVousInformation:
126 0 : ChipLogDetail(SetupPayload, "Loaded rendezvousInfo: %u", (uint16_t) parameter.uintValue);
127 0 : setupPayload.rendezvousInformation.SetValue(RendezvousInformationFlags().SetRaw(
128 0 : static_cast<std::underlying_type_t<RendezvousInformationFlag>>(parameter.uintValue)));
129 0 : break;
130 0 : case SetupPayloadKey_Discriminator:
131 0 : ChipLogDetail(SetupPayload, "Loaded discriminator: %u", (uint16_t) parameter.uintValue);
132 0 : setupPayload.discriminator.SetLongValue(static_cast<uint16_t>(parameter.uintValue));
133 0 : break;
134 0 : case SetupPayloadKey_SetupPINCode:
135 0 : ChipLogDetail(SetupPayload, "Loaded setupPinCode: %lu", (unsigned long) parameter.uintValue);
136 0 : setupPayload.setUpPINCode = static_cast<uint32_t>(parameter.uintValue);
137 0 : break;
138 0 : default:
139 0 : return CHIP_ERROR_INVALID_ARGUMENT;
140 : }
141 0 : return CHIP_NO_ERROR;
142 : }
143 :
144 0 : CHIP_ERROR loadPayloadFromFile(SetupPayload & setupPayload, const std::string & filePath)
145 : {
146 0 : std::ifstream fileStream(filePath);
147 0 : VerifyOrReturnError(!fileStream.fail(), CHIP_ERROR_INVALID_ARGUMENT);
148 :
149 0 : while (fileStream)
150 : {
151 0 : std::string key;
152 0 : std::string value;
153 0 : SetupPayloadParameter parameter;
154 :
155 0 : getline(fileStream, key, ' ');
156 0 : fileStream >> value;
157 0 : fileStream.ignore();
158 :
159 0 : if (key.length() == 0)
160 : {
161 0 : continue;
162 : }
163 0 : ReturnErrorOnFailure(resolveSetupPayloadParameter(parameter, key, value));
164 :
165 0 : ReturnErrorOnFailure(addParameter(setupPayload, parameter));
166 0 : }
167 0 : return CHIP_NO_ERROR;
168 0 : }
169 :
170 0 : CHIP_ERROR generateQRCodeFromFilePath(std::string filePath, std::string & outCode)
171 : {
172 0 : SetupPayload setupPayload;
173 0 : CHIP_ERROR err = loadPayloadFromFile(setupPayload, std::move(filePath));
174 0 : if (err != CHIP_NO_ERROR)
175 : {
176 0 : return err;
177 : }
178 0 : QRCodeSetupPayloadGenerator generator(setupPayload);
179 0 : err = generator.payloadBase38Representation(outCode);
180 0 : return err;
181 0 : }
182 :
183 0 : CHIP_ERROR generateManualCodeFromFilePath(std::string filePath, std::string & outCode)
184 : {
185 0 : SetupPayload setupPayload;
186 0 : CHIP_ERROR err = loadPayloadFromFile(setupPayload, std::move(filePath));
187 0 : if (err != CHIP_NO_ERROR)
188 : {
189 0 : return err;
190 : }
191 0 : ManualSetupPayloadGenerator generator(setupPayload);
192 0 : err = generator.payloadDecimalStringRepresentation(outCode);
193 0 : return err;
194 0 : }
195 : } // namespace chip
|
