1 //
2 // Copyright 2016 The Android Open Source Project
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16 
17 #include <cutils/properties.h>
18 #include <fcntl.h>
19 #include <gtest/gtest.h>
20 
21 #include <string>
22 #include <vector>
23 using std::vector;
24 
25 #include "bluetooth_address.h"
26 
27 namespace android {
28 namespace hardware {
29 namespace bluetooth {
30 namespace V1_0 {
31 namespace implementation {
32 
33 constexpr char kTestAddr1[BluetoothAddress::kStringLength + 1] =
34     "12:34:56:78:9a:bc";
35 constexpr uint8_t kTestAddr1_bytes[BluetoothAddress::kBytes] = {
36     0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc};
37 constexpr char kZeros[BluetoothAddress::kStringLength + 1] =
38     "00:00:00:00:00:00";
39 constexpr uint8_t kZeros_bytes[BluetoothAddress::kBytes] = {0x00, 0x00, 0x00,
40                                                             0x00, 0x00, 0x00};
41 constexpr char kTestAddrBad1[BluetoothAddress::kStringLength + 1] =
42     "bb:aa:dd:00:00:01";
43 constexpr uint8_t kTestAddrBad1_bytes[BluetoothAddress::kBytes] = {
44     0xbb, 0xaa, 0xdd, 0x00, 0x00, 0x01};
45 
46 constexpr char kAddrPath[] = "/tmp/my_address_in_a_file.txt";
47 
48 class BluetoothAddressTest : public ::testing::Test {
49  public:
BluetoothAddressTest()50   BluetoothAddressTest() {}
~BluetoothAddressTest()51   ~BluetoothAddressTest() {}
52 
53   void FileWriteString(const char* path, const char* string);
54 };
55 
FileWriteString(const char * path,const char * string)56 void BluetoothAddressTest::FileWriteString(const char* path,
57                                            const char* string) {
58   int fd = open(path, O_CREAT | O_RDWR);
59   EXPECT_TRUE(fd > 0) << "err = " << strerror(errno);
60 
61   size_t length = strlen(string);
62   size_t bytes_written = write(fd, string, length);
63 
64   EXPECT_EQ(length, bytes_written) << strerror(errno);
65 
66   close(fd);
67 }
68 
TEST_F(BluetoothAddressTest,string_to_bytes)69 TEST_F(BluetoothAddressTest, string_to_bytes) {
70   uint8_t addr[BluetoothAddress::kBytes];
71 
72   // Malformed addresses
73   EXPECT_FALSE(BluetoothAddress::string_to_bytes("", addr));
74   EXPECT_FALSE(BluetoothAddress::string_to_bytes("000000000000", addr));
75   EXPECT_FALSE(BluetoothAddress::string_to_bytes("00:00:00:00:0000", addr));
76   EXPECT_FALSE(BluetoothAddress::string_to_bytes("00:00:00:00:00:0", addr));
77   EXPECT_FALSE(BluetoothAddress::string_to_bytes("00:00:00:00:00:0;", addr));
78   EXPECT_FALSE(BluetoothAddress::string_to_bytes("aB:cD:eF:Gh:iJ:Kl", addr));
79   EXPECT_FALSE(BluetoothAddress::string_to_bytes("00:00:000:00:00:0;", addr));
80   EXPECT_FALSE(BluetoothAddress::string_to_bytes("12:34:56:78:90:12;", addr));
81   EXPECT_FALSE(BluetoothAddress::string_to_bytes("12:34:56:78:90:123", addr));
82 
83   // Reasonable addresses
84   EXPECT_TRUE(BluetoothAddress::string_to_bytes("00:00:00:00:00:00", addr));
85   EXPECT_TRUE(BluetoothAddress::string_to_bytes("a5:a5:a5:a5:a5:a5", addr));
86   EXPECT_TRUE(BluetoothAddress::string_to_bytes("5A:5A:5A:5A:5A:5A", addr));
87   EXPECT_TRUE(BluetoothAddress::string_to_bytes("AA:BB:CC:DD:EE:FF", addr));
88   EXPECT_TRUE(BluetoothAddress::string_to_bytes("aa:bb:cc:dd:ee:ff", addr));
89 
90   // Compare the output to known bytes
91   uint8_t addrA[BluetoothAddress::kBytes];
92   uint8_t addrB[BluetoothAddress::kBytes];
93 
94   // kTestAddr1
95   EXPECT_TRUE(BluetoothAddress::string_to_bytes(kTestAddr1, addrA));
96   EXPECT_TRUE(memcmp(addrA, kTestAddr1_bytes, BluetoothAddress::kBytes) == 0);
97 
98   // kZeros
99   EXPECT_TRUE(BluetoothAddress::string_to_bytes(kZeros, addrB));
100   EXPECT_TRUE(memcmp(addrB, kZeros_bytes, BluetoothAddress::kBytes) == 0);
101 
102   // kTestAddr1 != kZeros
103   EXPECT_FALSE(memcmp(addrA, addrB, BluetoothAddress::kBytes) == 0);
104 }
105 
TEST_F(BluetoothAddressTest,bytes_to_string)106 TEST_F(BluetoothAddressTest, bytes_to_string) {
107   char addrA[BluetoothAddress::kStringLength + 1] = "";
108   char addrB[BluetoothAddress::kStringLength + 1] = "";
109 
110   // kTestAddr1
111   BluetoothAddress::bytes_to_string(kTestAddr1_bytes, addrA);
112   EXPECT_TRUE(memcmp(addrA, kTestAddr1, BluetoothAddress::kStringLength) == 0);
113 
114   // kZeros
115   BluetoothAddress::bytes_to_string(kZeros_bytes, addrB);
116   EXPECT_TRUE(memcmp(addrB, kZeros, BluetoothAddress::kStringLength) == 0);
117 
118   // kTestAddr1 != kZeros
119   EXPECT_FALSE(memcmp(addrA, addrB, BluetoothAddress::kStringLength) == 0);
120 }
121 
TEST_F(BluetoothAddressTest,property_set)122 TEST_F(BluetoothAddressTest, property_set) {
123   // Set the properties to empty strings.
124   property_set(PERSIST_BDADDR_PROPERTY, "");
125   property_set(PROPERTY_BT_BDADDR_PATH, "");
126   property_set(FACTORY_BDADDR_PROPERTY, "");
127 
128   // Get returns 0.
129   char prop[PROP_VALUE_MAX] = "";
130   EXPECT_TRUE(property_get(PERSIST_BDADDR_PROPERTY, prop, NULL) == 0);
131   EXPECT_TRUE(property_get(PROPERTY_BT_BDADDR_PATH, prop, NULL) == 0);
132   EXPECT_TRUE(property_get(FACTORY_BDADDR_PROPERTY, prop, NULL) == 0);
133 
134   // Set the properties to known strings.
135   property_set(PERSIST_BDADDR_PROPERTY, "1");
136   property_set(PROPERTY_BT_BDADDR_PATH, "22");
137   property_set(FACTORY_BDADDR_PROPERTY, "333");
138 
139   // Get returns the correct length.
140   EXPECT_TRUE(property_get(PERSIST_BDADDR_PROPERTY, prop, NULL) == 1);
141   EXPECT_TRUE(property_get(PROPERTY_BT_BDADDR_PATH, prop, NULL) == 2);
142   EXPECT_TRUE(property_get(FACTORY_BDADDR_PROPERTY, prop, NULL) == 3);
143 
144   // Set the properties to empty strings again.
145   property_set(PERSIST_BDADDR_PROPERTY, "");
146   property_set(PROPERTY_BT_BDADDR_PATH, "");
147   property_set(FACTORY_BDADDR_PROPERTY, "");
148 
149   // Get returns 0.
150   EXPECT_TRUE(property_get(PERSIST_BDADDR_PROPERTY, prop, NULL) == 0);
151   EXPECT_TRUE(property_get(PROPERTY_BT_BDADDR_PATH, prop, NULL) == 0);
152   EXPECT_TRUE(property_get(FACTORY_BDADDR_PROPERTY, prop, NULL) == 0);
153 }
154 
TEST_F(BluetoothAddressTest,property_get)155 TEST_F(BluetoothAddressTest, property_get) {
156   // Set the properties to known strings.
157   property_set(PERSIST_BDADDR_PROPERTY, PERSIST_BDADDR_PROPERTY);
158   property_set(PROPERTY_BT_BDADDR_PATH, PROPERTY_BT_BDADDR_PATH);
159   property_set(FACTORY_BDADDR_PROPERTY, FACTORY_BDADDR_PROPERTY);
160 
161   // Get returns the same strings.
162   char prop[PROP_VALUE_MAX] = "";
163   EXPECT_TRUE(property_get(PERSIST_BDADDR_PROPERTY, prop, NULL) > 0);
164   EXPECT_TRUE(strcmp(PERSIST_BDADDR_PROPERTY, prop) == 0);
165 
166   EXPECT_TRUE(property_get(PROPERTY_BT_BDADDR_PATH, prop, NULL) > 0);
167   EXPECT_TRUE(strcmp(PROPERTY_BT_BDADDR_PATH, prop) == 0);
168 
169   EXPECT_TRUE(property_get(FACTORY_BDADDR_PROPERTY, prop, NULL) > 0);
170   EXPECT_TRUE(strcmp(FACTORY_BDADDR_PROPERTY, prop) == 0);
171 
172   // Set a property to a different known string.
173   char prop2[PROP_VALUE_MAX] = "Erased";
174   property_set(PERSIST_BDADDR_PROPERTY, prop2);
175 
176   // Get returns the correct strings.
177   EXPECT_TRUE(property_get(PERSIST_BDADDR_PROPERTY, prop, NULL) > 0);
178   EXPECT_TRUE(strcmp(prop2, prop) == 0);
179 
180   EXPECT_TRUE(property_get(PROPERTY_BT_BDADDR_PATH, prop, NULL) > 0);
181   EXPECT_TRUE(strcmp(PROPERTY_BT_BDADDR_PATH, prop) == 0);
182 
183   EXPECT_TRUE(property_get(FACTORY_BDADDR_PROPERTY, prop, NULL) > 0);
184   EXPECT_TRUE(strcmp(FACTORY_BDADDR_PROPERTY, prop) == 0);
185 
186   // Set another property to prop2.
187   property_set(PROPERTY_BT_BDADDR_PATH, prop2);
188 
189   EXPECT_TRUE(property_get(PERSIST_BDADDR_PROPERTY, prop, NULL) > 0);
190   EXPECT_TRUE(strcmp(prop2, prop) == 0);
191 
192   EXPECT_TRUE(property_get(PROPERTY_BT_BDADDR_PATH, prop, NULL) > 0);
193   EXPECT_TRUE(strcmp(prop2, prop) == 0);
194 
195   EXPECT_TRUE(property_get(FACTORY_BDADDR_PROPERTY, prop, NULL) > 0);
196   EXPECT_TRUE(strcmp(FACTORY_BDADDR_PROPERTY, prop) == 0);
197 
198   // Set the third property to prop2.
199   property_set(FACTORY_BDADDR_PROPERTY, prop2);
200 
201   EXPECT_TRUE(property_get(PERSIST_BDADDR_PROPERTY, prop, NULL) > 0);
202   EXPECT_TRUE(strcmp(prop2, prop) == 0);
203 
204   EXPECT_TRUE(property_get(PROPERTY_BT_BDADDR_PATH, prop, NULL) > 0);
205   EXPECT_TRUE(strcmp(prop2, prop) == 0);
206 
207   EXPECT_TRUE(property_get(FACTORY_BDADDR_PROPERTY, prop, NULL) > 0);
208   EXPECT_TRUE(strcmp(prop2, prop) == 0);
209 }
210 
TEST_F(BluetoothAddressTest,get_local_address)211 TEST_F(BluetoothAddressTest, get_local_address) {
212   EXPECT_TRUE(property_set(PERSIST_BDADDR_PROPERTY, "") == 0);
213   EXPECT_TRUE(property_set(FACTORY_BDADDR_PROPERTY, "") == 0);
214   uint8_t address[BluetoothAddress::kBytes];
215 
216   // File contains a non-zero Address.
217   FileWriteString(kAddrPath, kTestAddr1);
218   EXPECT_TRUE(property_set(PROPERTY_BT_BDADDR_PATH, kAddrPath) == 0);
219   EXPECT_TRUE(BluetoothAddress::get_local_address(address));
220   EXPECT_TRUE(memcmp(address, kTestAddr1_bytes, BluetoothAddress::kBytes) == 0);
221 
222   // File contains a zero address.  A random address will be generated.
223   FileWriteString(kAddrPath, kZeros);
224   EXPECT_TRUE(property_set(PROPERTY_BT_BDADDR_PATH, kAddrPath) == 0);
225   EXPECT_TRUE(property_set(PERSIST_BDADDR_PROPERTY, kTestAddrBad1) == 0);
226   EXPECT_TRUE(BluetoothAddress::get_local_address(address));
227   EXPECT_TRUE(memcmp(address, kZeros_bytes, BluetoothAddress::kBytes) != 0);
228   char prop[PROP_VALUE_MAX] = "Before reading";
229   EXPECT_TRUE(property_get(PERSIST_BDADDR_PROPERTY, prop, NULL) ==
230               BluetoothAddress::kStringLength);
231   char address_str[BluetoothAddress::kStringLength + 1];
232   BluetoothAddress::bytes_to_string(address, address_str);
233   EXPECT_TRUE(memcmp(address_str, prop, BluetoothAddress::kStringLength) == 0);
234 
235   // Factory property contains an address.
236   EXPECT_TRUE(property_set(PERSIST_BDADDR_PROPERTY, kTestAddrBad1) == 0);
237   EXPECT_TRUE(property_set(FACTORY_BDADDR_PROPERTY, kTestAddr1) == 0);
238   EXPECT_TRUE(BluetoothAddress::get_local_address(address));
239   EXPECT_TRUE(memcmp(address, kTestAddr1_bytes, BluetoothAddress::kBytes) == 0);
240 
241   // Persistent property contains an address.
242   memcpy(address, kTestAddrBad1_bytes, BluetoothAddress::kBytes);
243   EXPECT_TRUE(property_set(PERSIST_BDADDR_PROPERTY, kTestAddr1) == 0);
244   EXPECT_TRUE(property_set(FACTORY_BDADDR_PROPERTY, "") == 0);
245   EXPECT_TRUE(property_set(PROPERTY_BT_BDADDR_PATH, "") == 0);
246   EXPECT_TRUE(BluetoothAddress::get_local_address(address));
247   EXPECT_TRUE(memcmp(address, kTestAddr1_bytes, BluetoothAddress::kBytes) == 0);
248 }
249 
250 }  // namespace implementation
251 }  // namespace V1_0
252 }  // namespace bluetooth
253 }  // namespace hardware
254 }  // namespace android
255