1 /*
2 *
3 * Copyright (C) 2023 The Android Open Source Project
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 #include <android-base/strings.h>
20 #include <assert.h>
21 #include <gflags/gflags.h>
22 #include <grpcpp/ext/proto_server_reflection_plugin.h>
23 #include <grpcpp/grpcpp.h>
24 #include <grpcpp/health_check_service_interface.h>
25 #include <sys/msg.h>
26 #include <unistd.h>
27
28 #include <algorithm>
29 #include <array>
30 #include <cstdio>
31 #include <iomanip>
32 #include <iostream>
33 #include <memory>
34 #include <string>
35
36 #include "wmediumd.grpc.pb.h"
37 #include "wmediumd/api.h"
38 #include "wmediumd/grpc.h"
39 #include "wmediumd/wmediumd.h"
40
41 using google::protobuf::Empty;
42 using grpc::Server;
43 using grpc::ServerBuilder;
44 using grpc::ServerContext;
45 using grpc::Status;
46 using grpc::StatusCode;
47 using wmediumdserver::ListStationsResponse;
48 using wmediumdserver::LoadConfigRequest;
49 using wmediumdserver::SetCiviclocRequest;
50 using wmediumdserver::SetLciRequest;
51 using wmediumdserver::SetPositionRequest;
52 using wmediumdserver::SetSnrRequest;
53 using wmediumdserver::SetTxpowerRequest;
54 using wmediumdserver::StartPcapRequest;
55 using wmediumdserver::WmediumdService;
56
57 #define MAC_ADDR_LEN 6
58 #define STR_MAC_ADDR_LEN 17
59
60 static std::atomic<long> msg_type_response_increment{MSG_TYPE_RESPONSE_BASE};
61
62 template <class T>
AppendBinaryRepresentation(std::string & buf,const T & data)63 static void AppendBinaryRepresentation(std::string& buf, const T& data) {
64 std::copy(reinterpret_cast<const char*>(&data),
65 reinterpret_cast<const char*>(&data) + sizeof(T),
66 std::back_inserter(buf));
67 }
68
IsValidMacAddr(const std::string & mac_address)69 bool IsValidMacAddr(const std::string& mac_address) {
70 if (mac_address.size() != STR_MAC_ADDR_LEN) {
71 return false;
72 }
73
74 if (mac_address[2] != ':' || mac_address[5] != ':' || mac_address[8] != ':' ||
75 mac_address[11] != ':' || mac_address[14] != ':') {
76 return false;
77 }
78
79 for (int i = 0; i < STR_MAC_ADDR_LEN; ++i) {
80 if ((i - 2) % 3 == 0) continue;
81 char c = mac_address[i];
82
83 if (isupper(c)) {
84 c = tolower(c);
85 }
86
87 if ((c < '0' || c > '9') && (c < 'a' || c > 'f')) return false;
88 }
89
90 return true;
91 }
92
ParseMacAddress(const std::string & mac_address)93 static std::array<uint8_t, 6> ParseMacAddress(const std::string& mac_address) {
94 auto split_mac = android::base::Split(mac_address, ":");
95 std::array<uint8_t, 6> mac;
96 for (int i = 0; i < 6; i++) {
97 char* end_ptr;
98 mac[i] = (uint8_t)strtol(split_mac[i].c_str(), &end_ptr, 16);
99 }
100
101 return mac;
102 }
103
MacToString(const char * mac_address)104 std::string MacToString(const char* mac_address) {
105 char ret[STR_MAC_ADDR_LEN + 1];
106 sprintf(ret, MAC_FMT, MAC_ARGS(mac_address));
107 return ret;
108 }
109
110 class WmediumdServiceImpl final : public WmediumdService::Service {
111 public:
WmediumdServiceImpl(int event_fd,int msq_id)112 WmediumdServiceImpl(int event_fd, int msq_id)
113 : event_fd_(event_fd), msq_id_(msq_id) {}
114
ListStations(ServerContext * context,const Empty * request,ListStationsResponse * response)115 Status ListStations(ServerContext* context, const Empty* request,
116 ListStationsResponse* response) override {
117 struct wmediumd_grpc_response_message response_message;
118 SendAndReceiveGrpcMessage(REQUEST_LIST_STATIONS, &response_message);
119 if (response_message.data_type != RESPONSE_ACK_LIST_STATIONS) {
120 return Status(StatusCode::FAILED_PRECONDITION,
121 "Failed to execute ListStations");
122 }
123 if (response_message.data_size < sizeof(struct wmediumd_station_infos)) {
124 return Status(StatusCode::FAILED_PRECONDITION,
125 "Invalid size of wmediumd_station_infos");
126 }
127
128 // Construct response message
129 const auto* response_data_payload =
130 reinterpret_cast<const wmediumd_station_infos*>(
131 &response_message.data_payload);
132 response->set_station_count(response_data_payload->count);
133 for (uint32_t i = 0; i < response_data_payload->count; ++i) {
134 const auto* station = reinterpret_cast<const wmediumd_station_info*>(
135 &response_data_payload->stations[i]);
136 auto* response_station = response->add_stations();
137 response_station->set_mac_address(MacToString(station->addr));
138 response_station->set_mac_hw_address(MacToString(station->hwaddr));
139 response_station->set_x_pos(station->x);
140 response_station->set_y_pos(station->y);
141 response_station->set_tx_power(station->tx_power);
142 response_station->set_lci((char*)station + station->lci_offset);
143 response_station->set_civicloc((char*)station + station->civicloc_offset);
144 }
145 return Status::OK;
146 }
147
LoadConfig(ServerContext * context,const LoadConfigRequest * request,Empty * reply)148 Status LoadConfig(ServerContext* context, const LoadConfigRequest* request,
149 Empty* reply) override {
150 // Construct request payload
151 ssize_t size =
152 sizeof(struct wmediumd_load_config) + (request->path().length() + 1);
153 struct wmediumd_load_config* request_data_payload =
154 (struct wmediumd_load_config*)malloc(size);
155 strcpy(request_data_payload->config_path, request->path().c_str());
156
157 struct wmediumd_grpc_response_message response_message;
158 SendAndReceiveGrpcMessage(REQUEST_LOAD_CONFIG, size, request_data_payload,
159 &response_message);
160 free(request_data_payload);
161 if (response_message.data_type != RESPONSE_ACK) {
162 return Status(StatusCode::FAILED_PRECONDITION,
163 "Failed to execute LoadConfig");
164 }
165 return Status::OK;
166 }
167
ReloadConfig(ServerContext * context,const Empty * request,Empty * reply)168 Status ReloadConfig(ServerContext* context, const Empty* request,
169 Empty* reply) override {
170 struct wmediumd_grpc_response_message response_message;
171 SendAndReceiveGrpcMessage(REQUEST_RELOAD_CONFIG, &response_message);
172 if (response_message.data_type != RESPONSE_ACK) {
173 return Status(StatusCode::FAILED_PRECONDITION,
174 "Failed to execute ReloadConfig");
175 }
176 return Status::OK;
177 }
178
SetCivicloc(ServerContext * context,const SetCiviclocRequest * request,Empty * reply)179 Status SetCivicloc(ServerContext* context, const SetCiviclocRequest* request,
180 Empty* reply) override {
181 // Validate parameters
182 if (!IsValidMacAddr(request->mac_address())) {
183 return Status(StatusCode::INVALID_ARGUMENT, "Got invalid mac address");
184 }
185 auto mac = ParseMacAddress(request->mac_address());
186
187 // Construct request payload
188 ssize_t size = sizeof(struct wmediumd_set_civicloc) +
189 (request->civicloc().length() + 1);
190 struct wmediumd_set_civicloc* request_data_payload =
191 (struct wmediumd_set_civicloc*)malloc(size);
192 memcpy(request_data_payload->mac, &mac, sizeof(mac));
193 strcpy(request_data_payload->civicloc, request->civicloc().c_str());
194
195 struct wmediumd_grpc_response_message response_message;
196 SendAndReceiveGrpcMessage(REQUEST_SET_CIVICLOC, size, request_data_payload,
197 &response_message);
198 free(request_data_payload);
199 if (response_message.data_type != RESPONSE_ACK) {
200 return Status(StatusCode::FAILED_PRECONDITION,
201 "Failed to execute SetCivicloc");
202 }
203 return Status::OK;
204 }
205
SetLci(ServerContext * context,const SetLciRequest * request,Empty * reply)206 Status SetLci(ServerContext* context, const SetLciRequest* request,
207 Empty* reply) override {
208 // Validate parameters
209 if (!IsValidMacAddr(request->mac_address())) {
210 return Status(StatusCode::INVALID_ARGUMENT, "Got invalid mac address");
211 }
212 auto mac = ParseMacAddress(request->mac_address());
213
214 // Construct request payload
215 ssize_t size =
216 sizeof(struct wmediumd_set_lci) + (request->lci().length() + 1);
217 struct wmediumd_set_lci* request_data_payload =
218 (struct wmediumd_set_lci*)malloc(size);
219 memcpy(request_data_payload->mac, &mac, sizeof(mac));
220 strcpy(request_data_payload->lci, request->lci().c_str());
221
222 struct wmediumd_grpc_response_message response_message;
223 SendAndReceiveGrpcMessage(REQUEST_SET_LCI, size, request_data_payload,
224 &response_message);
225 free(request_data_payload);
226 if (response_message.data_type != RESPONSE_ACK) {
227 return Status(StatusCode::FAILED_PRECONDITION,
228 "Failed to execute SetLci");
229 }
230 return Status::OK;
231 }
232
SetPosition(ServerContext * context,const SetPositionRequest * request,Empty * reply)233 Status SetPosition(ServerContext* context, const SetPositionRequest* request,
234 Empty* reply) override {
235 // Validate parameters
236 if (!IsValidMacAddr(request->mac_address())) {
237 return Status(StatusCode::INVALID_ARGUMENT, "Got invalid mac address");
238 }
239 auto mac = ParseMacAddress(request->mac_address());
240
241 // Construct request payload
242 struct wmediumd_set_position request_data_payload;
243 memcpy(request_data_payload.mac, &mac, sizeof(mac));
244 request_data_payload.x = request->x_pos();
245 request_data_payload.y = request->y_pos();
246
247 struct wmediumd_grpc_response_message response_message;
248 SendAndReceiveGrpcMessage(REQUEST_SET_POSITION,
249 sizeof(request_data_payload),
250 &request_data_payload, &response_message);
251 if (response_message.data_type != RESPONSE_ACK) {
252 return Status(StatusCode::FAILED_PRECONDITION,
253 "Failed to execute SetPosition");
254 }
255 return Status::OK;
256 }
257
SetSnr(ServerContext * context,const SetSnrRequest * request,Empty * reply)258 Status SetSnr(ServerContext* context, const SetSnrRequest* request,
259 Empty* reply) override {
260 // Validate parameters
261 if (!IsValidMacAddr(request->mac_address_1()) ||
262 !IsValidMacAddr(request->mac_address_2())) {
263 return Status(StatusCode::INVALID_ARGUMENT, "Got invalid mac address");
264 }
265 auto mac_1 = ParseMacAddress(request->mac_address_1());
266 auto mac_2 = ParseMacAddress(request->mac_address_2());
267
268 // Construct request payload
269 struct wmediumd_set_snr request_data_payload;
270 memcpy(request_data_payload.node1_mac, &mac_1, sizeof(mac_1));
271 memcpy(request_data_payload.node2_mac, &mac_2, sizeof(mac_2));
272 request_data_payload.snr = request->snr();
273
274 struct wmediumd_grpc_response_message response_message;
275 SendAndReceiveGrpcMessage(REQUEST_SET_SNR, sizeof(request_data_payload),
276 &request_data_payload, &response_message);
277 if (response_message.data_type != RESPONSE_ACK) {
278 return Status(StatusCode::FAILED_PRECONDITION,
279 "Failed to execute SetSnr");
280 }
281 return Status::OK;
282 }
283
SetTxpower(ServerContext * context,const SetTxpowerRequest * request,Empty * reply)284 Status SetTxpower(ServerContext* context, const SetTxpowerRequest* request,
285 Empty* reply) override {
286 // Validate parameters
287 if (!IsValidMacAddr(request->mac_address())) {
288 return Status(StatusCode::INVALID_ARGUMENT, "Got invalid mac address");
289 }
290 auto mac = ParseMacAddress(request->mac_address());
291
292 // Construct request payload
293 struct wmediumd_set_tx_power request_data_payload;
294 memcpy(request_data_payload.mac, &mac, sizeof(mac));
295 request_data_payload.tx_power = request->tx_power();
296
297 struct wmediumd_grpc_response_message response_message;
298 SendAndReceiveGrpcMessage(REQUEST_SET_TX_POWER,
299 sizeof(request_data_payload),
300 &request_data_payload, &response_message);
301 if (response_message.data_type != RESPONSE_ACK) {
302 return Status(StatusCode::FAILED_PRECONDITION,
303 "Failed to execute SetTxpower");
304 }
305 return Status::OK;
306 }
307
StartPcap(ServerContext * context,const StartPcapRequest * request,Empty * reply)308 Status StartPcap(ServerContext* context, const StartPcapRequest* request,
309 Empty* reply) override {
310 // Construct request payload
311 ssize_t size =
312 sizeof(struct wmediumd_start_pcap) + (request->path().length() + 1);
313 struct wmediumd_start_pcap* request_data_payload =
314 (struct wmediumd_start_pcap*)malloc(size);
315 strcpy(request_data_payload->pcap_path, request->path().c_str());
316
317 struct wmediumd_grpc_response_message response_message;
318 SendAndReceiveGrpcMessage(REQUEST_START_PCAP, size, request_data_payload,
319 &response_message);
320 free(request_data_payload);
321 if (response_message.data_type != RESPONSE_ACK) {
322 return Status(StatusCode::FAILED_PRECONDITION,
323 "Failed to execute StartPcap");
324 }
325 return Status::OK;
326 }
327
StopPcap(ServerContext * context,const Empty * request,Empty * reply)328 Status StopPcap(ServerContext* context, const Empty* request,
329 Empty* reply) override {
330 struct wmediumd_grpc_response_message response_message;
331 SendAndReceiveGrpcMessage(REQUEST_STOP_PCAP, &response_message);
332 if (response_message.data_type != RESPONSE_ACK) {
333 return Status(StatusCode::FAILED_PRECONDITION,
334 "Failed to execute StopPcap");
335 }
336 return Status::OK;
337 }
338
339 private:
SendAndReceiveGrpcMessage(enum wmediumd_grpc_request_data_type data_type,ssize_t data_size,void * request_data_payload,struct wmediumd_grpc_response_message * response_message)340 void SendAndReceiveGrpcMessage(
341 enum wmediumd_grpc_request_data_type data_type, ssize_t data_size,
342 void* request_data_payload,
343 struct wmediumd_grpc_response_message* response_message) {
344 long msg_type_response = msg_type_response_increment.fetch_add(1);
345
346 // Send Request Message
347 struct wmediumd_grpc_request_message request_message;
348 request_message.msg_type_request = MSG_TYPE_REQUEST;
349 request_message.msg_type_response = msg_type_response;
350 request_message.data_type = data_type;
351 request_message.data_size = data_size;
352 assert(data_size <= GRPC_MSG_BUF_MAX);
353 if (data_size > 0) {
354 memcpy(request_message.data_payload, request_data_payload, data_size);
355 }
356 msgsnd(msq_id_, &request_message, MSG_TYPE_REQUEST_SIZE, 0);
357
358 // Trigger Event
359 uint64_t evt = 1;
360 write(event_fd_, &evt, sizeof(evt));
361
362 msgrcv(msq_id_, response_message, MSG_TYPE_RESPONSE_SIZE, msg_type_response,
363 0);
364 }
365
SendAndReceiveGrpcMessage(enum wmediumd_grpc_request_data_type data_type,struct wmediumd_grpc_response_message * response_message)366 void SendAndReceiveGrpcMessage(
367 enum wmediumd_grpc_request_data_type data_type,
368 struct wmediumd_grpc_response_message* response_message) {
369 SendAndReceiveGrpcMessage(data_type, 0, NULL, response_message);
370 }
371
372 int event_fd_;
373 int msq_id_;
374 };
375
RunWmediumdServer(std::string grpc_uds_path,int event_fd,int msq_id)376 void RunWmediumdServer(std::string grpc_uds_path, int event_fd, int msq_id) {
377 std::string server_address("unix:" + grpc_uds_path);
378 WmediumdServiceImpl service(event_fd, msq_id);
379
380 grpc::EnableDefaultHealthCheckService(true);
381 grpc::reflection::InitProtoReflectionServerBuilderPlugin();
382 ServerBuilder builder;
383 // Listen on the given address without any authentication mechanism.
384 builder.AddListeningPort(server_address, grpc::InsecureServerCredentials());
385 // Register "service" as the instance through which we'll communicate with
386 // clients. In this case it corresponds to an *synchronous* service.
387 builder.RegisterService(&service);
388 // Finally assemble the server.
389 std::unique_ptr<Server> server(builder.BuildAndStart());
390 std::cout << "Server listening on " << server_address << std::endl;
391
392 // Wait for the server to shutdown. Note that some other thread must be
393 // responsible for shutting down the server for this call to ever return.
394 server->Wait();
395 }
396