1 #include <iostream> 2 #include <cassert> 3 #include <sdbusplus/message.hpp> 4 #include <sdbusplus/bus.hpp> 5 6 // Global to share the dbus type string between client and server. 7 static std::string verifyTypeString; 8 9 using verifyCallback_t = void(*)(sd_bus_message*); 10 verifyCallback_t verifyCallback = nullptr; 11 12 static constexpr auto SERVICE = "sdbusplus.test"; 13 static constexpr auto INTERFACE = SERVICE; 14 static constexpr auto TEST_METHOD = "test"; 15 static constexpr auto QUIT_METHOD = "quit"; 16 17 // Open up the sdbus and claim SERVICE name. 18 auto serverInit() 19 { 20 auto b = sdbusplus::bus::new_default(); 21 b.request_name(SERVICE); 22 23 return std::move(b); 24 } 25 26 // Thread to run the dbus server. 27 void* server(void* b) 28 { 29 auto bus = sdbusplus::bus::bus(reinterpret_cast<sdbusplus::bus::busp_t>(b)); 30 31 while(1) 32 { 33 // Wait for messages. 34 auto m = bus.process().release(); 35 36 if(m == nullptr) 37 { 38 bus.wait(); 39 continue; 40 } 41 42 if (sd_bus_message_is_method_call(m, INTERFACE, TEST_METHOD)) 43 { 44 // Verify the message type matches what the test expects. 45 assert(verifyTypeString == sd_bus_message_get_signature(m, true)); 46 if (verifyCallback) 47 { 48 verifyCallback(m); 49 verifyCallback = nullptr; 50 } 51 else 52 { 53 std::cout << "Warning: No verification for " 54 << verifyTypeString << std::endl; 55 } 56 // Reply to client. 57 sd_bus_reply_method_return(m, nullptr); 58 } 59 else if (sd_bus_message_is_method_call(m, INTERFACE, QUIT_METHOD)) 60 { 61 // Reply and exit. 62 sd_bus_reply_method_return(m, nullptr); 63 break; 64 } 65 } 66 } 67 68 auto newMethodCall__test(sdbusplus::bus::bus& b) 69 { 70 // Allocate a method-call message for INTERFACE,TEST_METHOD. 71 return b.new_method_call(SERVICE, "/", INTERFACE, TEST_METHOD); 72 } 73 74 void runTests() 75 { 76 using namespace std::literals; 77 78 auto b = sdbusplus::bus::new_default(); 79 80 // Test r-value int. 81 { 82 auto m = newMethodCall__test(b); 83 m.append(1); 84 verifyTypeString = "i"; 85 86 struct verify 87 { 88 static void op(sd_bus_message* m) 89 { 90 int32_t i = 0; 91 sd_bus_message_read_basic(m, 'i', &i); 92 assert(i == 1); 93 } 94 }; 95 verifyCallback = &verify::op; 96 97 b.call_noreply(m); 98 } 99 // Test l-value int. 100 { 101 auto m = newMethodCall__test(b); 102 int a = 1; 103 m.append(a, a); 104 verifyTypeString = "ii"; 105 106 struct verify 107 { 108 static void op(sd_bus_message* m) 109 { 110 int32_t a = 0, b = 0; 111 sd_bus_message_read(m, "ii", &a, &b); 112 assert(a == 1); 113 assert(b == 1); 114 } 115 }; 116 verifyCallback = &verify::op; 117 118 b.call_noreply(m); 119 } 120 121 // Test multiple ints. 122 { 123 auto m = newMethodCall__test(b); 124 m.append(1, 2, 3, 4, 5); 125 verifyTypeString = "iiiii"; 126 127 struct verify 128 { 129 static void op(sd_bus_message* m) 130 { 131 int32_t a = 0, b = 0, c = 0, d = 0, e = 0; 132 sd_bus_message_read(m, "iiiii", &a, &b, &c, &d, &e); 133 assert(a == 1); 134 assert(b == 2); 135 assert(c == 3); 136 assert(d == 4); 137 assert(e == 5); 138 } 139 }; 140 verifyCallback = &verify::op; 141 142 b.call_noreply(m); 143 } 144 145 // Test r-value string. 146 { 147 auto m = newMethodCall__test(b); 148 m.append("asdf"s); 149 verifyTypeString = "s"; 150 151 struct verify 152 { 153 static void op(sd_bus_message* m) 154 { 155 const char* s = nullptr; 156 sd_bus_message_read_basic(m, 's', &s); 157 assert(0 == strcmp("asdf", s)); 158 } 159 }; 160 verifyCallback = &verify::op; 161 162 b.call_noreply(m); 163 } 164 165 // Test multiple strings, various forms. 166 { 167 auto m = newMethodCall__test(b); 168 auto str = "jkl;"s; 169 auto str2 = "JKL:"s; 170 m.append(1, "asdf", "ASDF"s, str, 171 std::move(str2), 5); 172 verifyTypeString = "issssi"; 173 174 struct verify 175 { 176 static void op(sd_bus_message* m) 177 { 178 int32_t a = 0, b = 0; 179 const char *s0 = nullptr, *s1 = nullptr, *s2 = nullptr, 180 *s3 = nullptr; 181 sd_bus_message_read(m, "issssi", &a, &s0, &s1, &s2, &s3, &b); 182 assert(a == 1); 183 assert(b == 5); 184 assert(0 == strcmp("asdf", s0)); 185 assert(0 == strcmp("ASDF", s1)); 186 assert(0 == strcmp("jkl;", s2)); 187 assert(0 == strcmp("JKL:", s3)); 188 } 189 }; 190 verifyCallback = &verify::op; 191 192 b.call_noreply(m); 193 } 194 195 // Test vector. 196 { 197 auto m = newMethodCall__test(b); 198 std::vector<std::string> s{ "1", "2", "3"}; 199 m.append(1, s, 2); 200 verifyTypeString = "iasi"; 201 202 struct verify 203 { 204 static void op(sd_bus_message* m) 205 { 206 int32_t a = 0; 207 sd_bus_message_read(m, "i", &a); 208 assert(a == 1); 209 210 auto rc = sd_bus_message_enter_container(m, 211 SD_BUS_TYPE_ARRAY, 212 "s"); 213 assert(0 <= rc); 214 215 const char* s = nullptr; 216 sd_bus_message_read_basic(m, 's', &s); 217 assert(0 == strcmp("1", s)); 218 sd_bus_message_read_basic(m, 's', &s); 219 assert(0 == strcmp("2", s)); 220 sd_bus_message_read_basic(m, 's', &s); 221 assert(0 == strcmp("3", s)); 222 assert(1 == sd_bus_message_at_end(m, false)); 223 224 sd_bus_message_exit_container(m); 225 226 sd_bus_message_read(m, "i", &a); 227 assert(a == 2); 228 229 } 230 }; 231 verifyCallback = &verify::op; 232 233 234 b.call_noreply(m); 235 } 236 237 // Shutdown server. 238 { 239 auto m = b.new_method_call(SERVICE, "/", INTERFACE, QUIT_METHOD); 240 b.call_noreply(m); 241 } 242 } 243 244 int main() 245 { 246 247 // Initialize and start server thread. 248 pthread_t t; 249 { 250 auto b = serverInit(); 251 pthread_create(&t, NULL, server, b.release()); 252 } 253 254 runTests(); 255 256 // Wait for server thread to exit. 257 pthread_join(t, NULL); 258 259 return 0; 260 } 261