../src/busctl/busctl.c

1

/* SPDX-License-Identifier: LGPL-2.1+ */

2

3

#include <getopt.h>

4

#include <stdio_ext.h>

5

6

#include "sd-bus.h"

7

8

#include "alloc-util.h"

9

#include "bus-dump.h"

10

#include "bus-internal.h"

11

#include "bus-signature.h"

12

#include "bus-type.h"

13

#include "bus-util.h"

14

#include "busctl-introspect.h"

15

#include "escape.h"

16

#include "fd-util.h"

17

#include "fileio.h"

18

#include "locale-util.h"

19

#include "log.h"

20

#include "pager.h"

21

#include "parse-util.h"

22

#include "path-util.h"

23

#include "set.h"

24

#include "strv.h"

25

#include "terminal-util.h"

26

#include "user-util.h"

27

#include "util.h"

28

#include "verbs.h"

29

30

static bool_Bool arg_no_pager = false0;

31

static bool_Bool arg_legend = true1;

32

static char *arg_address = NULL((void*)0);

33

static bool_Bool arg_unique = false0;

34

static bool_Bool arg_acquired = false0;

35

static bool_Bool arg_activatable = false0;

36

static bool_Bool arg_show_machine = false0;

37

static char **arg_matches = NULL((void*)0);

38

static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;

39

static const char *arg_host = NULL((void*)0);

40

static bool_Bool arg_user = false0;

41

static size_t arg_snaplen = 4096;

42

static bool_Bool arg_list = false0;

43

static bool_Bool arg_quiet = false0;

44

static bool_Bool arg_verbose = false0;

45

static bool_Bool arg_expect_reply = true1;

46

static bool_Bool arg_auto_start = true1;

47

static bool_Bool arg_allow_interactive_authorization = true1;

48

static bool_Bool arg_augment_creds = true1;

49

static bool_Bool arg_watch_bind = false0;

50

static usec_t arg_timeout = 0;

51

52

#define NAME_IS_ACQUIRED((void *) ((intptr_t) (1))) INT_TO_PTR(1)((void *) ((intptr_t) (1)))

53

#define NAME_IS_ACTIVATABLE((void *) ((intptr_t) (2))) INT_TO_PTR(2)((void *) ((intptr_t) (2)))

54

55

static int acquire_bus(bool_Bool set_monitor, sd_bus **ret) {

56

_cleanup_(sd_bus_unrefp)__attribute__((cleanup(sd_bus_unrefp))) sd_bus *bus = NULL((void*)0);

57

int r;

58

59

r = sd_bus_new(&bus);

60

if (r < 0)

61

return log_error_errno(r, "Failed to allocate bus: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 61, __func__, "Failed to allocate bus: %m"
) : -abs(_e); });

62

63

if (set_monitor) {

64

r = sd_bus_set_monitor(bus, true1);

65

if (r < 0)

66

return log_error_errno(r, "Failed to set monitor mode: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 66, __func__, "Failed to set monitor mode: %m"
) : -abs(_e); });

67

68

r = sd_bus_negotiate_creds(bus, true1, _SD_BUS_CREDS_ALL);

69

if (r < 0)

70

return log_error_errno(r, "Failed to enable credentials: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 70, __func__, "Failed to enable credentials: %m"
) : -abs(_e); });

71

72

r = sd_bus_negotiate_timestamp(bus, true1);

73

if (r < 0)

74

return log_error_errno(r, "Failed to enable timestamps: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 74, __func__, "Failed to enable timestamps: %m"
) : -abs(_e); });

75

76

r = sd_bus_negotiate_fds(bus, true1);

77

if (r < 0)

78

return log_error_errno(r, "Failed to enable fds: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 78, __func__, "Failed to enable fds: %m"
) : -abs(_e); });

79

}

80

81

r = sd_bus_set_bus_client(bus, true1);

82

if (r < 0)

83

return log_error_errno(r, "Failed to set bus client: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 83, __func__, "Failed to set bus client: %m"
) : -abs(_e); });

84

85

r = sd_bus_set_watch_bind(bus, arg_watch_bind);

86

if (r < 0)

87

return log_error_errno(r, "Failed to set watch-bind setting to '%s': %m", yes_no(arg_watch_bind))({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 87, __func__, "Failed to set watch-bind setting to '%s': %m"
, yes_no(arg_watch_bind)) : -abs(_e); });

88

89

if (arg_address)

90

r = sd_bus_set_address(bus, arg_address);

91

else {

92

switch (arg_transport) {

93

94

case BUS_TRANSPORT_LOCAL:

95

if (arg_user) {

96

bus->is_user = true1;

97

r = bus_set_address_user(bus);

98

} else {

99

bus->is_system = true1;

100

r = bus_set_address_system(bus);

101

}

102

break;

103

104

case BUS_TRANSPORT_REMOTE:

105

r = bus_set_address_system_remote(bus, arg_host);

106

break;

107

108

case BUS_TRANSPORT_MACHINE:

109

r = bus_set_address_system_machine(bus, arg_host);

110

break;

111

112

default:

113

assert_not_reached("Hmm, unknown transport type.")do { log_assert_failed_unreachable_realm(LOG_REALM_SYSTEMD, (
"Hmm, unknown transport type."), "../src/busctl/busctl.c", 113
, __PRETTY_FUNCTION__); } while (0);

114

}

115

}

116

if (r < 0)

117

return log_error_errno(r, "Failed to set address: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 117, __func__, "Failed to set address: %m"
) : -abs(_e); });

118

119

r = sd_bus_start(bus);

120

if (r < 0)

121

return log_error_errno(r, "Failed to connect to bus: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 121, __func__, "Failed to connect to bus: %m"
) : -abs(_e); });

122

123

*ret = TAKE_PTR(bus)({ typeof(bus) _ptr_ = (bus); (bus) = ((void*)0); _ptr_; });

124

125

return 0;

126

}

127

128

static int list_bus_names(int argc, char **argv, void *userdata) {

129

_cleanup_(sd_bus_flush_close_unrefp)__attribute__((cleanup(sd_bus_flush_close_unrefp))) sd_bus *bus = NULL((void*)0);

130

_cleanup_strv_free___attribute__((cleanup(strv_freep))) char **acquired = NULL((void*)0), **activatable = NULL((void*)0);

131

_cleanup_free___attribute__((cleanup(freep))) char **merged = NULL((void*)0);

132

_cleanup_hashmap_free___attribute__((cleanup(hashmap_freep))) Hashmap *names = NULL((void*)0);

133

char **i;

134

int r;

135

size_t max_i = 0;

136

unsigned n = 0;

137

void *v;

138

char *k;

139

Iterator iterator;

140

141

if (!arg_unique && !arg_acquired && !arg_activatable)

142

arg_unique = arg_acquired = arg_activatable = true1;

143

144

r = acquire_bus(false0, &bus);

145

if (r < 0)

146

return r;

147

148

r = sd_bus_list_names(bus, (arg_acquired || arg_unique) ? &acquired : NULL((void*)0), arg_activatable ? &activatable : NULL((void*)0));

149

if (r < 0)

150

return log_error_errno(r, "Failed to list names: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 150, __func__, "Failed to list names: %m"
) : -abs(_e); });

151

152

(void) pager_open(arg_no_pager, false0);

153

154

names = hashmap_new(&string_hash_ops)internal_hashmap_new(&string_hash_ops );

155

if (!names)

156

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
156, __func__);

157

158

STRV_FOREACH(i, acquired)for ((i) = (acquired); (i) && *(i); (i)++) {

159

max_i = MAX(max_i, strlen(*i))__extension__ ({ const typeof((max_i)) __unique_prefix_A79 = (
(max_i)); const typeof((strlen(*i))) __unique_prefix_B80 = ((
strlen(*i))); __unique_prefix_A79 > __unique_prefix_B80 ? __unique_prefix_A79
: __unique_prefix_B80; });

160

161

r = hashmap_put(names, *i, NAME_IS_ACQUIRED((void *) ((intptr_t) (1))));

162

if (r < 0)

163

return log_error_errno(r, "Failed to add to hashmap: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 163, __func__, "Failed to add to hashmap: %m"
) : -abs(_e); });

164

}

165

166

STRV_FOREACH(i, activatable)for ((i) = (activatable); (i) && *(i); (i)++) {

167

max_i = MAX(max_i, strlen(*i))__extension__ ({ const typeof((max_i)) __unique_prefix_A81 = (
(max_i)); const typeof((strlen(*i))) __unique_prefix_B82 = ((
strlen(*i))); __unique_prefix_A81 > __unique_prefix_B82 ? __unique_prefix_A81
: __unique_prefix_B82; });

168

169

r = hashmap_put(names, *i, NAME_IS_ACTIVATABLE((void *) ((intptr_t) (2))));

170

if (r < 0 && r != -EEXIST17)

171

return log_error_errno(r, "Failed to add to hashmap: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 171, __func__, "Failed to add to hashmap: %m"
) : -abs(_e); });

172

}

173

174

merged = new(char*, hashmap_size(names) + 1)((char**) malloc_multiply(sizeof(char*), (hashmap_size(names)
+ 1)));

175

if (!merged)

176

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
176, __func__);

177

178

HASHMAP_FOREACH_KEY(v, k, names, iterator)for ((iterator) = ((Iterator) { .idx = ((2147483647 *2U +1U) -
1), .next_key = ((void*)0) }); hashmap_iterate((names), &
(iterator), (void**)&(v), (const void**) &(k)); )

179

merged[n++] = k;

180

181

merged[n] = NULL((void*)0);

182

strv_sort(merged);

183

184

if (arg_legend) {

185

printf("%-*s %*s %-*s %-*s %-*s %-*s %-*s %-*s",

186

(int) max_i, "NAME", 10, "PID", 15, "PROCESS", 16, "USER", 13, "CONNECTION", 25, "UNIT", 10, "SESSION", 19, "DESCRIPTION");

187

188

if (arg_show_machine)

189

puts(" MACHINE");

190

else

191

putchar('\n');

192

}

193

194

STRV_FOREACH(i, merged)for ((i) = (merged); (i) && *(i); (i)++) {

195

_cleanup_(sd_bus_creds_unrefp)__attribute__((cleanup(sd_bus_creds_unrefp))) sd_bus_creds *creds = NULL((void*)0);

196

sd_id128_t mid;

197

198

if (hashmap_get(names, *i) == NAME_IS_ACTIVATABLE((void *) ((intptr_t) (2)))) {

199

/* Activatable */

200

201

printf("%-*s", (int) max_i, *i);

202

printf(" - - - (activatable) - - ");

203

if (arg_show_machine)

204

puts(" -");

205

else

206

putchar('\n');

207

continue;

208

209

}

210

211

if (!arg_unique && (*i)[0] == ':')

212

continue;

213

214

if (!arg_acquired && (*i)[0] != ':')

215

continue;

216

217

printf("%-*s", (int) max_i, *i);

218

219

r = sd_bus_get_name_creds(

220

bus, *i,

221

(arg_augment_creds ? SD_BUS_CREDS_AUGMENT : 0) |

222

SD_BUS_CREDS_EUID|SD_BUS_CREDS_PID|SD_BUS_CREDS_COMM|

223

SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_SESSION|

224

SD_BUS_CREDS_DESCRIPTION, &creds);

225

if (r >= 0) {

226

const char *unique, *session, *unit, *cn;

227

pid_t pid;

228

uid_t uid;

229

230

r = sd_bus_creds_get_pid(creds, &pid);

231

if (r >= 0) {

232

const char *comm = NULL((void*)0);

233

234

sd_bus_creds_get_comm(creds, &comm);

235

236

printf(" %10lu %-15s", (unsigned long) pid, strna(comm));

237

} else

238

fputs(" - - ", stdoutstdout);

239

240

r = sd_bus_creds_get_euid(creds, &uid);

241

if (r >= 0) {

242

_cleanup_free___attribute__((cleanup(freep))) char *u = NULL((void*)0);

243

244

u = uid_to_name(uid);

245

if (!u)

246

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
246, __func__);

247

248

if (strlen(u) > 16)

249

u[16] = 0;

250

251

printf(" %-16s", u);

252

} else

253

fputs(" - ", stdoutstdout);

254

255

r = sd_bus_creds_get_unique_name(creds, &unique);

256

if (r >= 0)

257

printf(" %-13s", unique);

258

else

259

fputs(" - ", stdoutstdout);

260

261

r = sd_bus_creds_get_unit(creds, &unit);

262

if (r >= 0) {

263

_cleanup_free___attribute__((cleanup(freep))) char *e;

264

265

e = ellipsize(unit, 25, 100);

266

if (!e)

267

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
267, __func__);

268

269

printf(" %-25s", e);

270

} else

271

fputs(" - ", stdoutstdout);

272

273

r = sd_bus_creds_get_session(creds, &session);

274

if (r >= 0)

275

printf(" %-10s", session);

276

else

277

fputs(" - ", stdoutstdout);

278

279

r = sd_bus_creds_get_description(creds, &cn);

280

if (r >= 0)

281

printf(" %-19s", cn);

282

else

283

fputs(" - ", stdoutstdout);

284

285

} else

286

printf(" - - - - - - - ");

287

288

if (arg_show_machine) {

289

r = sd_bus_get_name_machine_id(bus, *i, &mid);

290

if (r >= 0) {

291

char m[SD_ID128_STRING_MAX33];

292

printf(" %s\n", sd_id128_to_string(mid, m));

293

} else

294

puts(" -");

295

} else

296

putchar('\n');

297

}

298

299

return 0;

300

}

301

302

static void print_subtree(const char *prefix, const char *path, char **l) {

303

const char *vertical, *space;

304

char **n;

305

306

/* We assume the list is sorted. Let's first skip over the

307

* entry we are looking at. */

308

for (;;) {

309

if (!*l)

310

return;

311

312

if (!streq(*l, path)(strcmp((*l),(path)) == 0))

313

break;

314

315

l++;

316

}

317

318

vertical = strjoina(prefix, special_glyph(TREE_VERTICAL))({ const char *_appendees_[] = { prefix, special_glyph(TREE_VERTICAL
) }; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for (_i_ =
0; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

319

space = strjoina(prefix, special_glyph(TREE_SPACE))({ const char *_appendees_[] = { prefix, special_glyph(TREE_SPACE
) }; char *_d_, *_p_; size_t _len_ = 0; size_t _i_; for (_i_ =
0; _i_ < __extension__ (__builtin_choose_expr( !__builtin_types_compatible_p
(typeof(_appendees_), typeof(&*(_appendees_))), sizeof(_appendees_
)/sizeof((_appendees_)[0]), ((void)0))) && _appendees_
[_i_]; _i_++) _len_ += strlen(_appendees_[_i_]); _p_ = _d_ = __builtin_alloca
(_len_ + 1); for (_i_ = 0; _i_ < __extension__ (__builtin_choose_expr
( !__builtin_types_compatible_p(typeof(_appendees_), typeof(&
*(_appendees_))), sizeof(_appendees_)/sizeof((_appendees_)[0]
), ((void)0))) && _appendees_[_i_]; _i_++) _p_ = stpcpy
(_p_, _appendees_[_i_]); *_p_ = 0; _d_; });

320

321

for (;;) {

322

bool_Bool has_more = false0;

323

324

if (!*l || !path_startswith(*l, path))

325

break;

326

327

n = l + 1;

328

for (;;) {

329

if (!*n || !path_startswith(*n, path))

330

break;

331

332

if (!path_startswith(*n, *l)) {

333

has_more = true1;

334

break;

335

}

336

337

n++;

338

}

339

340

printf("%s%s%s\n", prefix, special_glyph(has_more ? TREE_BRANCH : TREE_RIGHT), *l);

341

342

print_subtree(has_more ? vertical : space, *l, l);

343

l = n;

344

}

345

}

346

347

static void print_tree(const char *prefix, char **l) {

348

349

prefix = strempty(prefix);

350

351

if (arg_list) {

352

char **i;

353

354

STRV_FOREACH(i, l)for ((i) = (l); (i) && *(i); (i)++)

355

printf("%s%s\n", prefix, *i);

356

return;

357

}

358

359

if (strv_isempty(l)) {

360

printf("No objects discovered.\n");

361

return;

362

}

363

364

if (streq(l[0], "/")(strcmp((l[0]),("/")) == 0) && !l[1]) {

365

printf("Only root object discovered.\n");

366

return;

367

}

368

369

print_subtree(prefix, "/", l);

370

}

371

372

static int on_path(const char *path, void *userdata) {

373

Set *paths = userdata;

374

int r;

375

376

assert(paths)do { if ((__builtin_expect(!!(!(paths)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("paths"), "../src/busctl/busctl.c", 376,
__PRETTY_FUNCTION__); } while (0);

377

378

r = set_put_strdup(paths, path);

379

if (r < 0)

380

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
380, __func__);

381

382

return 0;

383

}

384

385

static int find_nodes(sd_bus *bus, const char *service, const char *path, Set *paths, bool_Bool many) {

386

static const XMLIntrospectOps ops = {

387

.on_path = on_path,

388

};

389

390

_cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *reply = NULL((void*)0);

391

_cleanup_(sd_bus_error_free)__attribute__((cleanup(sd_bus_error_free))) sd_bus_error error = SD_BUS_ERROR_NULL((const sd_bus_error) {(((void*)0)), (((void*)0)), 0});

392

const char *xml;

393

int r;

394

395

r = sd_bus_call_method(bus, service, path, "org.freedesktop.DBus.Introspectable", "Introspect", &error, &reply, "");

396

if (r < 0) {

397

if (many)

398

printf("Failed to introspect object %s of service %s: %s\n", path, service, bus_error_message(&error, r));

399

else

400

log_error_errno(r, "Failed to introspect object %s of service %s: %s", path, service, bus_error_message(&error, r))({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 400, __func__, "Failed to introspect object %s of service %s: %s"
, path, service, bus_error_message(&error, r)) : -abs(_e)
; });

401

return r;

402

}

403

404

r = sd_bus_message_read(reply, "s", &xml);

405

if (r < 0)

406

return bus_log_parse_error(r);

407

408

return parse_xml_introspect(path, xml, &ops, paths);

409

}

410

411

static int tree_one(sd_bus *bus, const char *service, const char *prefix, bool_Bool many) {

412

_cleanup_set_free_free___attribute__((cleanup(set_free_freep))) Set *paths = NULL((void*)0), *done = NULL((void*)0), *failed = NULL((void*)0);

413

_cleanup_free___attribute__((cleanup(freep))) char **l = NULL((void*)0);

414

char *m;

415

int r;

416

417

paths = set_new(&string_hash_ops)internal_set_new(&string_hash_ops );

418

if (!paths)

419

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
419, __func__);

420

421

done = set_new(&string_hash_ops)internal_set_new(&string_hash_ops );

422

if (!done)

423

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
423, __func__);

424

425

failed = set_new(&string_hash_ops)internal_set_new(&string_hash_ops );

426

if (!failed)

427

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
427, __func__);

428

429

m = strdup("/");

430

if (!m)

431

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
431, __func__);

432

433

r = set_put(paths, m);

434

if (r < 0) {

435

free(m);

436

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
436, __func__);

437

}

438

439

for (;;) {

440

_cleanup_free___attribute__((cleanup(freep))) char *p = NULL((void*)0);

441

int q;

442

443

p = set_steal_first(paths);

444

if (!p)

445

break;

446

447

if (set_contains(done, p) ||

448

set_contains(failed, p))

449

continue;

450

451

q = find_nodes(bus, service, p, paths, many);

452

if (q < 0) {

453

if (r >= 0)

454

r = q;

455

456

q = set_put(failed, p);

457

} else

458

q = set_put(done, p);

459

460

if (q < 0)

461

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
461, __func__);

462

463

assert(q != 0)do { if ((__builtin_expect(!!(!(q != 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("q != 0"), "../src/busctl/busctl.c", 463
, __PRETTY_FUNCTION__); } while (0);

464

p = NULL((void*)0);

465

}

466

467

(void) pager_open(arg_no_pager, false0);

468

469

l = set_get_strv(done);

470

if (!l)

471

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
471, __func__);

472

473

strv_sort(l);

474

print_tree(prefix, l);

475

476

fflush(stdoutstdout);

477

478

return r;

479

}

480

481

static int tree(int argc, char **argv, void *userdata) {

482

_cleanup_(sd_bus_flush_close_unrefp)__attribute__((cleanup(sd_bus_flush_close_unrefp))) sd_bus *bus = NULL((void*)0);

483

char **i;

484

int r = 0;

485

486

if (!arg_unique && !arg_acquired)

487

arg_acquired = true1;

488

489

r = acquire_bus(false0, &bus);

490

if (r < 0)

491

return r;

492

493

if (argc <= 1) {

494

_cleanup_strv_free___attribute__((cleanup(strv_freep))) char **names = NULL((void*)0);

495

bool_Bool not_first = false0;

496

497

r = sd_bus_list_names(bus, &names, NULL((void*)0));

498

if (r < 0)

499

return log_error_errno(r, "Failed to get name list: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 499, __func__, "Failed to get name list: %m"
) : -abs(_e); });

500

501

(void) pager_open(arg_no_pager, false0);

502

503

STRV_FOREACH(i, names)for ((i) = (names); (i) && *(i); (i)++) {

504

int q;

505

506

if (!arg_unique && (*i)[0] == ':')

507

continue;

508

509

if (!arg_acquired && (*i)[0] == ':')

510

continue;

511

512

if (not_first)

513

printf("\n");

514

515

printf("Service %s%s%s:\n", ansi_highlight(), *i, ansi_normal());

516

517

q = tree_one(bus, *i, NULL((void*)0), true1);

518

if (q < 0 && r >= 0)

519

r = q;

520

521

not_first = true1;

522

}

523

} else {

524

STRV_FOREACH(i, argv+1)for ((i) = (argv+1); (i) && *(i); (i)++) {

525

int q;

526

527

if (i > argv+1)

528

printf("\n");

529

530

if (argv[2]) {

531

(void) pager_open(arg_no_pager, false0);

532

printf("Service %s%s%s:\n", ansi_highlight(), *i, ansi_normal());

533

}

534

535

q = tree_one(bus, *i, NULL((void*)0), !!argv[2]);

536

if (q < 0 && r >= 0)

537

r = q;

538

}

539

}

540

541

return r;

542

}

543

544

static int format_cmdline(sd_bus_message *m, FILE *f, bool_Bool needs_space) {

545

int r;

546

547

for (;;) {

548

const char *contents = NULL((void*)0);

549

char type;

550

union {

551

uint8_t u8;

552

uint16_t u16;

553

int16_t s16;

554

uint32_t u32;

555

int32_t s32;

556

uint64_t u64;

557

int64_t s64;

558

double d64;

559

const char *string;

560

int i;

561

} basic;

562

563

r = sd_bus_message_peek_type(m, &type, &contents);

564

if (r < 0)

565

return r;

566

if (r == 0)

567

return needs_space;

568

569

if (bus_type_is_container(type) > 0) {

570

571

r = sd_bus_message_enter_container(m, type, contents);

572

if (r < 0)

573

return r;

574

575

if (type == SD_BUS_TYPE_ARRAY) {

576

unsigned n = 0;

577

578

/* count array entries */

579

for (;;) {

580

581

r = sd_bus_message_skip(m, contents);

582

if (r < 0)

583

return r;

584

if (r == 0)

585

break;

586

587

n++;

588

}

589

590

r = sd_bus_message_rewind(m, false0);

591

if (r < 0)

592

return r;

593

594

if (needs_space)

595

fputc(' ', f);

596

597

fprintf(f, "%u", n);

598

needs_space = true1;

599

600

} else if (type == SD_BUS_TYPE_VARIANT) {

601

602

if (needs_space)

603

fputc(' ', f);

604

605

fprintf(f, "%s", contents);

606

needs_space = true1;

607

}

608

609

r = format_cmdline(m, f, needs_space);

610

if (r < 0)

611

return r;

612

613

needs_space = r > 0;

614

615

r = sd_bus_message_exit_container(m);

616

if (r < 0)

617

return r;

618

619

continue;

620

}

621

622

r = sd_bus_message_read_basic(m, type, &basic);

623

if (r < 0)

624

return r;

625

626

if (needs_space)

627

fputc(' ', f);

628

629

switch (type) {

630

case SD_BUS_TYPE_BYTE:

631

fprintf(f, "%u", basic.u8);

632

break;

633

634

case SD_BUS_TYPE_BOOLEAN:

635

fputs(true_false(basic.i), f);

636

break;

637

638

case SD_BUS_TYPE_INT16:

639

fprintf(f, "%i", basic.s16);

640

break;

641

642

case SD_BUS_TYPE_UINT16:

643

fprintf(f, "%u", basic.u16);

644

break;

645

646

case SD_BUS_TYPE_INT32:

647

fprintf(f, "%i", basic.s32);

648

break;

649

650

case SD_BUS_TYPE_UINT32:

651

fprintf(f, "%u", basic.u32);

652

break;

653

654

case SD_BUS_TYPE_INT64:

655

fprintf(f, "%" PRIi64"l" "i", basic.s64);

656

break;

657

658

case SD_BUS_TYPE_UINT64:

659

fprintf(f, "%" PRIu64"l" "u", basic.u64);

660

break;

661

662

case SD_BUS_TYPE_DOUBLE:

663

fprintf(f, "%g", basic.d64);

664

break;

665

666

case SD_BUS_TYPE_STRING:

667

case SD_BUS_TYPE_OBJECT_PATH:

668

case SD_BUS_TYPE_SIGNATURE: {

669

_cleanup_free___attribute__((cleanup(freep))) char *b = NULL((void*)0);

670

671

b = cescape(basic.string);

672

if (!b)

673

return -ENOMEM12;

674

675

fprintf(f, "\"%s\"", b);

676

break;

677

}

678

679

case SD_BUS_TYPE_UNIX_FD:

680

fprintf(f, "%i", basic.i);

681

break;

682

683

default:

684

assert_not_reached("Unknown basic type.")do { log_assert_failed_unreachable_realm(LOG_REALM_SYSTEMD, (
"Unknown basic type."), "../src/busctl/busctl.c", 684, __PRETTY_FUNCTION__
); } while (0);

685

}

686

687

needs_space = true1;

688

}

689

}

690

691

typedef struct Member {

692

const char *type;

693

char *interface;

694

char *name;

695

char *signature;

696

char *result;

697

char *value;

698

bool_Bool writable;

699

uint64_t flags;

700

} Member;

701

702

static void member_hash_func(const void *p, struct siphash *state) {

703

const Member *m = p;

704

uint64_t arity = 1;

705

706

assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/busctl/busctl.c", 706, __PRETTY_FUNCTION__
); } while (0);

707

assert(m->type)do { if ((__builtin_expect(!!(!(m->type)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m->type"), "../src/busctl/busctl.c",
707, __PRETTY_FUNCTION__); } while (0);

708

709

string_hash_func(m->type, state);

710

711

arity += !!m->name + !!m->interface;

712

713

uint64_hash_func(&arity, state);

714

715

if (m->name)

716

string_hash_func(m->name, state);

717

718

if (m->interface)

719

string_hash_func(m->interface, state);

720

}

721

722

static int member_compare_func(const void *a, const void *b) {

723

const Member *x = a, *y = b;

724

int d;

725

726

assert(x)do { if ((__builtin_expect(!!(!(x)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("x"), "../src/busctl/busctl.c", 726, __PRETTY_FUNCTION__
); } while (0);

727

assert(y)do { if ((__builtin_expect(!!(!(y)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("y"), "../src/busctl/busctl.c", 727, __PRETTY_FUNCTION__
); } while (0);

728

assert(x->type)do { if ((__builtin_expect(!!(!(x->type)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("x->type"), "../src/busctl/busctl.c",
728, __PRETTY_FUNCTION__); } while (0);

729

assert(y->type)do { if ((__builtin_expect(!!(!(y->type)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("y->type"), "../src/busctl/busctl.c",
729, __PRETTY_FUNCTION__); } while (0);

730

731

d = strcmp_ptr(x->interface, y->interface);

732

if (d != 0)

733

return d;

734

735

d = strcmp(x->type, y->type);

736

if (d != 0)

737

return d;

738

739

return strcmp_ptr(x->name, y->name);

740

}

741

742

static int member_compare_funcp(const void *a, const void *b) {

743

const Member *const * x = (const Member *const *) a, * const *y = (const Member *const *) b;

744

745

return member_compare_func(*x, *y);

746

}

747

748

static void member_free(Member *m) {

749

if (!m)

750

return;

751

752

free(m->interface);

753

free(m->name);

754

free(m->signature);

755

free(m->result);

756

free(m->value);

757

free(m);

758

}

759

760

DEFINE_TRIVIAL_CLEANUP_FUNC(Member*, member_free)static inline void member_freep(Member* *p) { if (*p) member_free
(*p); };

761

762

static void member_set_free(Set *s) {

763

set_free_with_destructor(s, member_free)({ ({ void *_item; while ((_item = set_steal_first(s))) member_free
(_item); }); set_free(s); });

764

}

765

766

DEFINE_TRIVIAL_CLEANUP_FUNC(Set*, member_set_free)static inline void member_set_freep(Set* *p) { if (*p) member_set_free
(*p); };

767

768

static int on_interface(const char *interface, uint64_t flags, void *userdata) {

769

_cleanup_(member_freep)__attribute__((cleanup(member_freep))) Member *m;

770

Set *members = userdata;

771

int r;

772

773

assert(interface)do { if ((__builtin_expect(!!(!(interface)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("interface"), "../src/busctl/busctl.c", 773
, __PRETTY_FUNCTION__); } while (0);

774

assert(members)do { if ((__builtin_expect(!!(!(members)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("members"), "../src/busctl/busctl.c", 774
, __PRETTY_FUNCTION__); } while (0);

775

776

m = new0(Member, 1)((Member*) calloc((1), sizeof(Member)));

777

if (!m)

778

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
778, __func__);

779

780

m->type = "interface";

781

m->flags = flags;

782

783

r = free_and_strdup(&m->interface, interface);

784

if (r < 0)

785

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
785, __func__);

786

787

r = set_put(members, m);

788

if (r <= 0) {

789

log_error("Duplicate interface")({ int _level = (((3))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 789, __func__, "Duplicate interface"
) : -abs(_e); });

790

return -EINVAL22;

791

}

792

793

m = NULL((void*)0);

794

return 0;

795

}

796

797

static int on_method(const char *interface, const char *name, const char *signature, const char *result, uint64_t flags, void *userdata) {

798

_cleanup_(member_freep)__attribute__((cleanup(member_freep))) Member *m;

799

Set *members = userdata;

800

int r;

801

802

assert(interface)do { if ((__builtin_expect(!!(!(interface)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("interface"), "../src/busctl/busctl.c", 802
, __PRETTY_FUNCTION__); } while (0);

803

assert(name)do { if ((__builtin_expect(!!(!(name)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("name"), "../src/busctl/busctl.c", 803, __PRETTY_FUNCTION__
); } while (0);

804

805

m = new0(Member, 1)((Member*) calloc((1), sizeof(Member)));

806

if (!m)

807

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
807, __func__);

808

809

m->type = "method";

810

m->flags = flags;

811

812

r = free_and_strdup(&m->interface, interface);

813

if (r < 0)

814

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
814, __func__);

815

816

r = free_and_strdup(&m->name, name);

817

if (r < 0)

818

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
818, __func__);

819

820

r = free_and_strdup(&m->signature, signature);

821

if (r < 0)

822

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
822, __func__);

823

824

r = free_and_strdup(&m->result, result);

825

if (r < 0)

826

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
826, __func__);

827

828

r = set_put(members, m);

829

if (r <= 0) {

830

log_error("Duplicate method")({ int _level = (((3))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 830, __func__, "Duplicate method"
) : -abs(_e); });

831

return -EINVAL22;

832

}

833

834

m = NULL((void*)0);

835

return 0;

836

}

837

838

static int on_signal(const char *interface, const char *name, const char *signature, uint64_t flags, void *userdata) {

839

_cleanup_(member_freep)__attribute__((cleanup(member_freep))) Member *m;

840

Set *members = userdata;

841

int r;

842

843

assert(interface)do { if ((__builtin_expect(!!(!(interface)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("interface"), "../src/busctl/busctl.c", 843
, __PRETTY_FUNCTION__); } while (0);

844

assert(name)do { if ((__builtin_expect(!!(!(name)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("name"), "../src/busctl/busctl.c", 844, __PRETTY_FUNCTION__
); } while (0);

845

846

m = new0(Member, 1)((Member*) calloc((1), sizeof(Member)));

847

if (!m)

848

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
848, __func__);

849

850

m->type = "signal";

851

m->flags = flags;

852

853

r = free_and_strdup(&m->interface, interface);

854

if (r < 0)

855

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
855, __func__);

856

857

r = free_and_strdup(&m->name, name);

858

if (r < 0)

859

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
859, __func__);

860

861

r = free_and_strdup(&m->signature, signature);

862

if (r < 0)

863

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
863, __func__);

864

865

r = set_put(members, m);

866

if (r <= 0) {

867

log_error("Duplicate signal")({ int _level = (((3))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 867, __func__, "Duplicate signal"
) : -abs(_e); });

868

return -EINVAL22;

869

}

870

871

m = NULL((void*)0);

872

return 0;

873

}

874

875

static int on_property(const char *interface, const char *name, const char *signature, bool_Bool writable, uint64_t flags, void *userdata) {

876

_cleanup_(member_freep)__attribute__((cleanup(member_freep))) Member *m;

877

Set *members = userdata;

878

int r;

879

880

assert(interface)do { if ((__builtin_expect(!!(!(interface)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("interface"), "../src/busctl/busctl.c", 880
, __PRETTY_FUNCTION__); } while (0);

881

assert(name)do { if ((__builtin_expect(!!(!(name)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("name"), "../src/busctl/busctl.c", 881, __PRETTY_FUNCTION__
); } while (0);

882

883

m = new0(Member, 1)((Member*) calloc((1), sizeof(Member)));

884

if (!m)

885

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
885, __func__);

886

887

m->type = "property";

888

m->flags = flags;

889

m->writable = writable;

890

891

r = free_and_strdup(&m->interface, interface);

892

if (r < 0)

893

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
893, __func__);

894

895

r = free_and_strdup(&m->name, name);

896

if (r < 0)

897

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
897, __func__);

898

899

r = free_and_strdup(&m->signature, signature);

900

if (r < 0)

901

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
901, __func__);

902

903

r = set_put(members, m);

904

if (r <= 0) {

905

log_error("Duplicate property")({ int _level = (((3))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 905, __func__, "Duplicate property"
) : -abs(_e); });

906

return -EINVAL22;

907

}

908

909

m = NULL((void*)0);

910

return 0;

911

}

912

913

static int introspect(int argc, char **argv, void *userdata) {

914

static const struct hash_ops member_hash_ops = {

915

.hash = member_hash_func,

916

.compare = member_compare_func,

917

};

918

919

static const XMLIntrospectOps ops = {

920

.on_interface = on_interface,

921

.on_method = on_method,

922

.on_signal = on_signal,

923

.on_property = on_property,

924

};

925

926

_cleanup_(sd_bus_flush_close_unrefp)__attribute__((cleanup(sd_bus_flush_close_unrefp))) sd_bus *bus = NULL((void*)0);

927

_cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *reply_xml = NULL((void*)0);

928

_cleanup_(sd_bus_error_free)__attribute__((cleanup(sd_bus_error_free))) sd_bus_error error = SD_BUS_ERROR_NULL((const sd_bus_error) {(((void*)0)), (((void*)0)), 0});

929

_cleanup_(member_set_freep)__attribute__((cleanup(member_set_freep))) Set *members = NULL((void*)0);

930

unsigned name_width, type_width, signature_width, result_width, j, k = 0;

931

Member *m, **sorted = NULL((void*)0);

932

Iterator i;

933

const char *xml;

934

int r;

935

936

r = acquire_bus(false0, &bus);

937

if (r < 0)

938

return r;

939

940

members = set_new(&member_hash_ops)internal_set_new(&member_hash_ops );

941

if (!members)

942

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
942, __func__);

943

944

r = sd_bus_call_method(bus, argv[1], argv[2], "org.freedesktop.DBus.Introspectable", "Introspect", &error, &reply_xml, "");

945

if (r < 0)

946

return log_error_errno(r, "Failed to introspect object %s of service %s: %s", argv[2], argv[1], bus_error_message(&error, r))({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 946, __func__, "Failed to introspect object %s of service %s: %s"
, argv[2], argv[1], bus_error_message(&error, r)) : -abs(
_e); });

947

948

r = sd_bus_message_read(reply_xml, "s", &xml);

949

if (r < 0)

950

return bus_log_parse_error(r);

951

952

/* First, get list of all properties */

953

r = parse_xml_introspect(argv[2], xml, &ops, members);

954

if (r < 0)

955

return r;

956

957

/* Second, find the current values for them */

958

SET_FOREACH(m, members, i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); set_iterate((members), &(i), (void
**)&(m)); ) {

959

_cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *reply = NULL((void*)0);

960

961

if (!streq(m->type, "property")(strcmp((m->type),("property")) == 0))

962

continue;

963

964

if (m->value)

965

continue;

966

967

if (argv[3] && !streq(argv[3], m->interface)(strcmp((argv[3]),(m->interface)) == 0))

968

continue;

969

970

r = sd_bus_call_method(bus, argv[1], argv[2], "org.freedesktop.DBus.Properties", "GetAll", &error, &reply, "s", m->interface);

971

if (r < 0)

972

return log_error_errno(r, "%s", bus_error_message(&error, r))({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 972, __func__, "%s", bus_error_message
(&error, r)) : -abs(_e); });

973

974

r = sd_bus_message_enter_container(reply, 'a', "{sv}");

975

if (r < 0)

976

return bus_log_parse_error(r);

977

978

for (;;) {

979

Member *z;

980

_cleanup_free___attribute__((cleanup(freep))) char *buf = NULL((void*)0);

981

_cleanup_fclose___attribute__((cleanup(fclosep))) FILE *mf = NULL((void*)0);

982

size_t sz = 0;

983

const char *name;

984

985

r = sd_bus_message_enter_container(reply, 'e', "sv");

986

if (r < 0)

987

return bus_log_parse_error(r);

988

989

if (r == 0)

990

break;

991

992

r = sd_bus_message_read(reply, "s", &name);

993

if (r < 0)

994

return bus_log_parse_error(r);

995

996

r = sd_bus_message_enter_container(reply, 'v', NULL((void*)0));

997

if (r < 0)

998

return bus_log_parse_error(r);

999

1000

mf = open_memstream(&buf, &sz);

1001

if (!mf)

1002

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
1002, __func__);

1003

1004

(void) __fsetlocking(mf, FSETLOCKING_BYCALLERFSETLOCKING_BYCALLER);

1005

1006

r = format_cmdline(reply, mf, false0);

1007

if (r < 0)

1008

return bus_log_parse_error(r);

1009

1010

mf = safe_fclose(mf);

1011

1012

z = set_get(members, &((Member) {

1013

.type = "property",

1014

.interface = m->interface,

1015

.name = (char*) name }));

1016

if (z)

1017

free_and_replace(z->value, buf)({ free(z->value); (z->value) = (buf); (buf) = ((void*)
0); 0; });

1018

1019

r = sd_bus_message_exit_container(reply);

1020

if (r < 0)

1021

return bus_log_parse_error(r);

1022

1023

r = sd_bus_message_exit_container(reply);

1024

if (r < 0)

1025

return bus_log_parse_error(r);

1026

}

1027

1028

r = sd_bus_message_exit_container(reply);

1029

if (r < 0)

1030

return bus_log_parse_error(r);

1031

}

1032

1033

(void) pager_open(arg_no_pager, false0);

1034

1035

name_width = STRLEN("NAME")(sizeof("""NAME""") - 1);

1036

type_width = STRLEN("TYPE")(sizeof("""TYPE""") - 1);

1037

signature_width = STRLEN("SIGNATURE")(sizeof("""SIGNATURE""") - 1);

1038

result_width = STRLEN("RESULT/VALUE")(sizeof("""RESULT/VALUE""") - 1);

1039

1040

sorted = newa(Member*, set_size(members))({ do { if ((__builtin_expect(!!(!(!size_multiply_overflow(sizeof
(Member*), set_size(members)))),0))) log_assert_failed_realm(
LOG_REALM_SYSTEMD, ("!size_multiply_overflow(sizeof(Member*), set_size(members))"
), "../src/busctl/busctl.c", 1040, __PRETTY_FUNCTION__); } while
(0); (Member**) __builtin_alloca (sizeof(Member*)*(set_size(
members))); });

1041

1042

SET_FOREACH(m, members, i)for ((i) = ((Iterator) { .idx = ((2147483647 *2U +1U) - 1), .
next_key = ((void*)0) }); set_iterate((members), &(i), (void
**)&(m)); ) {

1043

1044

if (argv[3] && !streq(argv[3], m->interface)(strcmp((argv[3]),(m->interface)) == 0))

1045

continue;

1046

1047

if (m->interface)

1048

name_width = MAX(name_width, strlen(m->interface))__extension__ ({ const typeof((name_width)) __unique_prefix_A83
= ((name_width)); const typeof((strlen(m->interface))) __unique_prefix_B84
= ((strlen(m->interface))); __unique_prefix_A83 > __unique_prefix_B84
? __unique_prefix_A83 : __unique_prefix_B84; });

1049

if (m->name)

1050

name_width = MAX(name_width, strlen(m->name) + 1)__extension__ ({ const typeof((name_width)) __unique_prefix_A85
= ((name_width)); const typeof((strlen(m->name) + 1)) __unique_prefix_B86
= ((strlen(m->name) + 1)); __unique_prefix_A85 > __unique_prefix_B86
? __unique_prefix_A85 : __unique_prefix_B86; });

1051

if (m->type)

1052

type_width = MAX(type_width, strlen(m->type))__extension__ ({ const typeof((type_width)) __unique_prefix_A87
= ((type_width)); const typeof((strlen(m->type))) __unique_prefix_B88
= ((strlen(m->type))); __unique_prefix_A87 > __unique_prefix_B88
? __unique_prefix_A87 : __unique_prefix_B88; });

1053

if (m->signature)

1054

signature_width = MAX(signature_width, strlen(m->signature))__extension__ ({ const typeof((signature_width)) __unique_prefix_A89
= ((signature_width)); const typeof((strlen(m->signature)
)) __unique_prefix_B90 = ((strlen(m->signature))); __unique_prefix_A89
> __unique_prefix_B90 ? __unique_prefix_A89 : __unique_prefix_B90
; });

1055

if (m->result)

1056

result_width = MAX(result_width, strlen(m->result))__extension__ ({ const typeof((result_width)) __unique_prefix_A91
= ((result_width)); const typeof((strlen(m->result))) __unique_prefix_B92
= ((strlen(m->result))); __unique_prefix_A91 > __unique_prefix_B92
? __unique_prefix_A91 : __unique_prefix_B92; });

1057

if (m->value)

1058

result_width = MAX(result_width, strlen(m->value))__extension__ ({ const typeof((result_width)) __unique_prefix_A93
= ((result_width)); const typeof((strlen(m->value))) __unique_prefix_B94
= ((strlen(m->value))); __unique_prefix_A93 > __unique_prefix_B94
? __unique_prefix_A93 : __unique_prefix_B94; });

1059

1060

sorted[k++] = m;

1061

}

1062

1063

if (result_width > 40)

1064

result_width = 40;

1065

1066

qsort(sorted, k, sizeof(Member*), member_compare_funcp);

1067

1068

if (arg_legend) {

1069

printf("%-*s %-*s %-*s %-*s %s\n",

1070

(int) name_width, "NAME",

1071

(int) type_width, "TYPE",

1072

(int) signature_width, "SIGNATURE",

1073

(int) result_width, "RESULT/VALUE",

1074

"FLAGS");

1075

}

1076

1077

for (j = 0; j < k; j++) {

1078

_cleanup_free___attribute__((cleanup(freep))) char *ellipsized = NULL((void*)0);

1079

const char *rv;

1080

bool_Bool is_interface;

1081

1082

m = sorted[j];

1083

1084

if (argv[3] && !streq(argv[3], m->interface)(strcmp((argv[3]),(m->interface)) == 0))

1085

continue;

1086

1087

is_interface = streq(m->type, "interface")(strcmp((m->type),("interface")) == 0);

1088

1089

if (argv[3] && is_interface)

1090

continue;

1091

1092

if (m->value) {

1093

ellipsized = ellipsize(m->value, result_width, 100);

1094

if (!ellipsized)

1095

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
1095, __func__);

1096

1097

rv = ellipsized;

1098

} else

1099

rv = empty_to_dash(m->result);

1100

1101

printf("%s%s%-*s%s %-*s %-*s %-*s%s%s%s%s%s%s\n",

1102

is_interface ? ansi_highlight() : "",

1103

is_interface ? "" : ".",

1104

- !is_interface + (int) name_width, empty_to_dash(streq_ptr(m->type, "interface") ? m->interface : m->name),

1105

is_interface ? ansi_normal() : "",

1106

(int) type_width, empty_to_dash(m->type),

1107

(int) signature_width, empty_to_dash(m->signature),

1108

(int) result_width, rv,

1109

(m->flags & SD_BUS_VTABLE_DEPRECATED) ? " deprecated" : (m->flags || m->writable ? "" : " -"),

1110

(m->flags & SD_BUS_VTABLE_METHOD_NO_REPLY) ? " no-reply" : "",

1111

(m->flags & SD_BUS_VTABLE_PROPERTY_CONST) ? " const" : "",

1112

(m->flags & SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE) ? " emits-change" : "",

1113

(m->flags & SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION) ? " emits-invalidation" : "",

1114

m->writable ? " writable" : "");

1115

}

1116

1117

return 0;

1118

}

1119

1120

static int message_dump(sd_bus_message *m, FILE *f) {

1121

return bus_message_dump(m, f, BUS_MESSAGE_DUMP_WITH_HEADER);

1122

}

1123

1124

static int message_pcap(sd_bus_message *m, FILE *f) {

1125

return bus_message_pcap_frame(m, arg_snaplen, f);

1126

}

1127

1128

static int monitor(int argc, char **argv, int (*dump)(sd_bus_message *m, FILE *f)) {

1129

_cleanup_(sd_bus_flush_close_unrefp)__attribute__((cleanup(sd_bus_flush_close_unrefp))) sd_bus *bus = NULL((void*)0);

1130

_cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *message = NULL((void*)0);

1131

_cleanup_(sd_bus_error_free)__attribute__((cleanup(sd_bus_error_free))) sd_bus_error error = SD_BUS_ERROR_NULL((const sd_bus_error) {(((void*)0)), (((void*)0)), 0});

1132

char **i;

1133

uint32_t flags = 0;

1134

const char *unique_name;

1135

bool_Bool is_monitor = false0;

1136

int r;

1137

1138

r = acquire_bus(true1, &bus);

1139

if (r < 0)

1140

return r;

1141

1142

/* upgrade connection; it's not used for anything else after this call */

1143

r = sd_bus_message_new_method_call(bus, &message, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus.Monitoring", "BecomeMonitor");

1144

if (r < 0)

1145

return bus_log_create_error(r);

1146

1147

r = sd_bus_message_open_container(message, 'a', "s");

1148

if (r < 0)

1149

return bus_log_create_error(r);

1150

1151

STRV_FOREACH(i, argv+1)for ((i) = (argv+1); (i) && *(i); (i)++) {

1152

_cleanup_free___attribute__((cleanup(freep))) char *m = NULL((void*)0);

1153

1154

if (!service_name_is_valid(*i)) {

1155

log_error("Invalid service name '%s'", *i)({ int _level = (((3))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1155, __func__, "Invalid service name '%s'"
, *i) : -abs(_e); });

1156

return -EINVAL22;

1157

}

1158

1159

m = strjoin("sender='", *i, "'")strjoin_real(("sender='"), *i, "'", ((void*)0));

1160

if (!m)

1161

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
1161, __func__);

1162

1163

r = sd_bus_message_append_basic(message, 's', m);

1164

if (r < 0)

1165

return bus_log_create_error(r);

1166

1167

free(m);

1168

m = strjoin("destination='", *i, "'")strjoin_real(("destination='"), *i, "'", ((void*)0));

1169

if (!m)

1170

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
1170, __func__);

1171

1172

r = sd_bus_message_append_basic(message, 's', m);

1173

if (r < 0)

1174

return bus_log_create_error(r);

1175

}

1176

1177

STRV_FOREACH(i, arg_matches)for ((i) = (arg_matches); (i) && *(i); (i)++) {

1178

r = sd_bus_message_append_basic(message, 's', *i);

1179

if (r < 0)

1180

return bus_log_create_error(r);

1181

}

1182

1183

r = sd_bus_message_close_container(message);

1184

if (r < 0)

1185

return bus_log_create_error(r);

1186

1187

r = sd_bus_message_append_basic(message, 'u', &flags);

1188

if (r < 0)

1189

return bus_log_create_error(r);

1190

1191

r = sd_bus_call(bus, message, arg_timeout, &error, NULL((void*)0));

1192

if (r < 0)

1193

return log_error_errno(r, "%s", bus_error_message(&error, r))({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1193, __func__, "%s", bus_error_message
(&error, r)) : -abs(_e); });

1194

1195

r = sd_bus_get_unique_name(bus, &unique_name);

1196

if (r < 0)

1197

return log_error_errno(r, "Failed to get unique name: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1197, __func__, "Failed to get unique name: %m"
) : -abs(_e); });

1198

1199

log_info("Monitoring bus message stream.")({ int _level = (((6))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1199, __func__, "Monitoring bus message stream."
) : -abs(_e); });

1200

1201

for (;;) {

1202

_cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *m = NULL((void*)0);

1203

1204

r = sd_bus_process(bus, &m);

1205

if (r < 0)

1206

return log_error_errno(r, "Failed to process bus: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1206, __func__, "Failed to process bus: %m"
) : -abs(_e); });

1207

1208

if (!is_monitor) {

1209

const char *name;

1210

1211

/* wait until we lose our unique name */

1212

if (sd_bus_message_is_signal(m, "org.freedesktop.DBus", "NameLost") <= 0)

1213

continue;

1214

1215

r = sd_bus_message_read(m, "s", &name);

1216

if (r < 0)

1217

return log_error_errno(r, "Failed to read lost name: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1217, __func__, "Failed to read lost name: %m"
) : -abs(_e); });

1218

1219

if (streq(name, unique_name)(strcmp((name),(unique_name)) == 0))

1220

is_monitor = true1;

1221

1222

continue;

1223

}

1224

1225

if (m) {

1226

dump(m, stdoutstdout);

1227

fflush(stdoutstdout);

1228

1229

if (sd_bus_message_is_signal(m, "org.freedesktop.DBus.Local", "Disconnected") > 0) {

1230

log_info("Connection terminated, exiting.")({ int _level = (((6))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1230, __func__, "Connection terminated, exiting."
) : -abs(_e); });

1231

return 0;

1232

}

1233

1234

continue;

1235

}

1236

1237

if (r > 0)

1238

continue;

1239

1240

r = sd_bus_wait(bus, (uint64_t) -1);

1241

if (r < 0)

1242

return log_error_errno(r, "Failed to wait for bus: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1242, __func__, "Failed to wait for bus: %m"
) : -abs(_e); });

1243

}

1244

}

1245

1246

static int verb_monitor(int argc, char **argv, void *userdata) {

1247

return monitor(argc, argv, message_dump);

1248

}

1249

1250

static int verb_capture(int argc, char **argv, void *userdata) {

1251

int r;

1252

1253

if (isatty(fileno(stdoutstdout)) > 0) {

1254

log_error("Refusing to write message data to console, please redirect output to a file.")({ int _level = (((3))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1254, __func__, "Refusing to write message data to console, please redirect output to a file."
) : -abs(_e); });

1255

return -EINVAL22;

1256

}

1257

1258

bus_pcap_header(arg_snaplen, stdoutstdout);

1259

1260

r = monitor(argc, argv, message_pcap);

1261

if (r < 0)

1262

return r;

1263

1264

r = fflush_and_check(stdoutstdout);

1265

if (r < 0)

1266

return log_error_errno(r, "Couldn't write capture file: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1266, __func__, "Couldn't write capture file: %m"
) : -abs(_e); });

1267

1268

return r;

1269

}

1270

1271

static int status(int argc, char **argv, void *userdata) {

1272

_cleanup_(sd_bus_flush_close_unrefp)__attribute__((cleanup(sd_bus_flush_close_unrefp))) sd_bus *bus = NULL((void*)0);

1273

_cleanup_(sd_bus_creds_unrefp)__attribute__((cleanup(sd_bus_creds_unrefp))) sd_bus_creds *creds = NULL((void*)0);

1274

pid_t pid;

1275

int r;

1276

1277

r = acquire_bus(false0, &bus);

1278

if (r < 0)

1279

return r;

1280

1281

if (!isempty(argv[1])) {

1282

r = parse_pid(argv[1], &pid);

1283

if (r < 0)

1284

r = sd_bus_get_name_creds(

1285

bus,

1286

argv[1],

1287

(arg_augment_creds ? SD_BUS_CREDS_AUGMENT : 0) | _SD_BUS_CREDS_ALL,

1288

&creds);

1289

else

1290

r = sd_bus_creds_new_from_pid(

1291

&creds,

1292

pid,

1293

_SD_BUS_CREDS_ALL);

1294

} else {

1295

const char *scope, *address;

1296

sd_id128_t bus_id;

1297

1298

r = sd_bus_get_address(bus, &address);

1299

if (r >= 0)

1300

printf("BusAddress=%s%s%s\n", ansi_highlight(), address, ansi_normal());

1301

1302

r = sd_bus_get_scope(bus, &scope);

1303

if (r >= 0)

1304

printf("BusScope=%s%s%s\n", ansi_highlight(), scope, ansi_normal());

1305

1306

r = sd_bus_get_bus_id(bus, &bus_id);

1307

if (r >= 0)

1308

printf("BusID=%s" SD_ID128_FORMAT_STR"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x" "%s\n", ansi_highlight(), SD_ID128_FORMAT_VAL(bus_id)(bus_id).bytes[0], (bus_id).bytes[1], (bus_id).bytes[2], (bus_id
).bytes[3], (bus_id).bytes[4], (bus_id).bytes[5], (bus_id).bytes
[6], (bus_id).bytes[7], (bus_id).bytes[8], (bus_id).bytes[9],
(bus_id).bytes[10], (bus_id).bytes[11], (bus_id).bytes[12], (
bus_id).bytes[13], (bus_id).bytes[14], (bus_id).bytes[15], ansi_normal());

1309

1310

r = sd_bus_get_owner_creds(

1311

bus,

1312

(arg_augment_creds ? SD_BUS_CREDS_AUGMENT : 0) | _SD_BUS_CREDS_ALL,

1313

&creds);

1314

}

1315

1316

if (r < 0)

1317

return log_error_errno(r, "Failed to get credentials: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1317, __func__, "Failed to get credentials: %m"
) : -abs(_e); });

1318

1319

bus_creds_dump(creds, NULL((void*)0), false0);

1320

return 0;

1321

}

1322

1323

static int message_append_cmdline(sd_bus_message *m, const char *signature, char ***x) {

1324

char **p;

1325

int r;

1326

1327

assert(m)do { if ((__builtin_expect(!!(!(m)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("m"), "../src/busctl/busctl.c", 1327, __PRETTY_FUNCTION__
); } while (0);

1328

assert(signature)do { if ((__builtin_expect(!!(!(signature)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("signature"), "../src/busctl/busctl.c", 1328
, __PRETTY_FUNCTION__); } while (0);

1329

assert(x)do { if ((__builtin_expect(!!(!(x)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("x"), "../src/busctl/busctl.c", 1329, __PRETTY_FUNCTION__
); } while (0);

1330

1331

p = *x;

1332

1333

for (;;) {

1334

const char *v;

1335

char t;

1336

1337

t = *signature;

1338

v = *p;

1339

1340

if (t == 0)

1341

break;

1342

if (!v) {

1343

log_error("Too few parameters for signature.")({ int _level = (((3))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1343, __func__, "Too few parameters for signature."
) : -abs(_e); });

1344

return -EINVAL22;

1345

}

1346

1347

signature++;

1348

p++;

1349

1350

switch (t) {

1351

1352

case SD_BUS_TYPE_BOOLEAN:

1353

1354

r = parse_boolean(v);

1355

if (r < 0)

1356

return log_error_errno(r, "Failed to parse as boolean: %s", v)({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1356, __func__, "Failed to parse as boolean: %s"
, v) : -abs(_e); });

1357

1358

r = sd_bus_message_append_basic(m, t, &r);

1359

break;

1360

1361

case SD_BUS_TYPE_BYTE: {

1362

uint8_t z;

1363

1364

r = safe_atou8(v, &z);

1365

if (r < 0)

1366

return log_error_errno(r, "Failed to parse as byte (unsigned 8bit integer): %s", v)({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1366, __func__, "Failed to parse as byte (unsigned 8bit integer): %s"
, v) : -abs(_e); });

1367

1368

r = sd_bus_message_append_basic(m, t, &z);

1369

break;

1370

}

1371

1372

case SD_BUS_TYPE_INT16: {

1373

int16_t z;

1374

1375

r = safe_atoi16(v, &z);

1376

if (r < 0)

1377

return log_error_errno(r, "Failed to parse as signed 16bit integer: %s", v)({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1377, __func__, "Failed to parse as signed 16bit integer: %s"
, v) : -abs(_e); });

1378

1379

r = sd_bus_message_append_basic(m, t, &z);

1380

break;

1381

}

1382

1383

case SD_BUS_TYPE_UINT16: {

1384

uint16_t z;

1385

1386

r = safe_atou16(v, &z);

1387

if (r < 0)

1388

return log_error_errno(r, "Failed to parse as unsigned 16bit integer: %s", v)({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1388, __func__, "Failed to parse as unsigned 16bit integer: %s"
, v) : -abs(_e); });

1389

1390

r = sd_bus_message_append_basic(m, t, &z);

1391

break;

1392

}

1393

1394

case SD_BUS_TYPE_INT32: {

1395

int32_t z;

1396

1397

r = safe_atoi32(v, &z);

1398

if (r < 0)

1399

return log_error_errno(r, "Failed to parse as signed 32bit integer: %s", v)({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1399, __func__, "Failed to parse as signed 32bit integer: %s"
, v) : -abs(_e); });

1400

1401

r = sd_bus_message_append_basic(m, t, &z);

1402

break;

1403

}

1404

1405

case SD_BUS_TYPE_UINT32: {

1406

uint32_t z;

1407

1408

r = safe_atou32(v, &z);

1409

if (r < 0)

1410

return log_error_errno(r, "Failed to parse as unsigned 32bit integer: %s", v)({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1410, __func__, "Failed to parse as unsigned 32bit integer: %s"
, v) : -abs(_e); });

1411

1412

r = sd_bus_message_append_basic(m, t, &z);

1413

break;

1414

}

1415

1416

case SD_BUS_TYPE_INT64: {

1417

int64_t z;

1418

1419

r = safe_atoi64(v, &z);

1420

if (r < 0)

1421

return log_error_errno(r, "Failed to parse as signed 64bit integer: %s", v)({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1421, __func__, "Failed to parse as signed 64bit integer: %s"
, v) : -abs(_e); });

1422

1423

r = sd_bus_message_append_basic(m, t, &z);

1424

break;

1425

}

1426

1427

case SD_BUS_TYPE_UINT64: {

1428

uint64_t z;

1429

1430

r = safe_atou64(v, &z);

1431

if (r < 0)

1432

return log_error_errno(r, "Failed to parse as unsigned 64bit integer: %s", v)({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1432, __func__, "Failed to parse as unsigned 64bit integer: %s"
, v) : -abs(_e); });

1433

1434

r = sd_bus_message_append_basic(m, t, &z);

1435

break;

1436

}

1437

1438

case SD_BUS_TYPE_DOUBLE: {

1439

double z;

1440

1441

r = safe_atod(v, &z);

1442

if (r < 0)

1443

return log_error_errno(r, "Failed to parse as double precision floating point: %s", v)({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1443, __func__, "Failed to parse as double precision floating point: %s"
, v) : -abs(_e); });

1444

1445

r = sd_bus_message_append_basic(m, t, &z);

1446

break;

1447

}

1448

1449

case SD_BUS_TYPE_STRING:

1450

case SD_BUS_TYPE_OBJECT_PATH:

1451

case SD_BUS_TYPE_SIGNATURE:

1452

1453

r = sd_bus_message_append_basic(m, t, v);

1454

break;

1455

1456

case SD_BUS_TYPE_ARRAY: {

1457

uint32_t n;

1458

size_t k;

1459

1460

r = safe_atou32(v, &n);

1461

if (r < 0)

1462

return log_error_errno(r, "Failed to parse number of array entries: %s", v)({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1462, __func__, "Failed to parse number of array entries: %s"
, v) : -abs(_e); });

1463

1464

r = signature_element_length(signature, &k);

1465

if (r < 0)

1466

return log_error_errno(r, "Invalid array signature.")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1466, __func__, "Invalid array signature."
) : -abs(_e); });

1467

1468

{

1469

unsigned i;

1470

char s[k + 1];

1471

memcpy(s, signature, k);

1472

s[k] = 0;

1473

1474

r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, s);

1475

if (r < 0)

1476

return bus_log_create_error(r);

1477

1478

for (i = 0; i < n; i++) {

1479

r = message_append_cmdline(m, s, &p);

1480

if (r < 0)

1481

return r;

1482

}

1483

}

1484

1485

signature += k;

1486

1487

r = sd_bus_message_close_container(m);

1488

break;

1489

}

1490

1491

case SD_BUS_TYPE_VARIANT:

1492

r = sd_bus_message_open_container(m, SD_BUS_TYPE_VARIANT, v);

1493

if (r < 0)

1494

return bus_log_create_error(r);

1495

1496

r = message_append_cmdline(m, v, &p);

1497

if (r < 0)

1498

return r;

1499

1500

r = sd_bus_message_close_container(m);

1501

break;

1502

1503

case SD_BUS_TYPE_STRUCT_BEGIN:

1504

case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {

1505

size_t k;

1506

1507

signature--;

1508

p--;

1509

1510

r = signature_element_length(signature, &k);

1511

if (r < 0)

1512

return log_error_errno(r, "Invalid struct/dict entry signature.")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1512, __func__, "Invalid struct/dict entry signature."
) : -abs(_e); });

1513

1514

{

1515

char s[k-1];

1516

memcpy(s, signature + 1, k - 2);

1517

s[k - 2] = 0;

1518

1519

r = sd_bus_message_open_container(m, t == SD_BUS_TYPE_STRUCT_BEGIN ? SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY, s);

1520

if (r < 0)

1521

return bus_log_create_error(r);

1522

1523

r = message_append_cmdline(m, s, &p);

1524

if (r < 0)

1525

return r;

1526

}

1527

1528

signature += k;

1529

1530

r = sd_bus_message_close_container(m);

1531

break;

1532

}

1533

1534

case SD_BUS_TYPE_UNIX_FD:

1535

log_error("UNIX file descriptor not supported as type.")({ int _level = (((3))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1535, __func__, "UNIX file descriptor not supported as type."
) : -abs(_e); });

1536

return -EINVAL22;

1537

1538

default:

1539

log_error("Unknown signature type %c.", t)({ int _level = (((3))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1539, __func__, "Unknown signature type %c."
, t) : -abs(_e); });

1540

return -EINVAL22;

1541

}

1542

1543

if (r < 0)

1544

return bus_log_create_error(r);

1545

}

1546

1547

*x = p;

1548

return 0;

1549

}

1550

1551

static int call(int argc, char **argv, void *userdata) {

1552

_cleanup_(sd_bus_flush_close_unrefp)__attribute__((cleanup(sd_bus_flush_close_unrefp))) sd_bus *bus = NULL((void*)0);

1553

_cleanup_(sd_bus_error_free)__attribute__((cleanup(sd_bus_error_free))) sd_bus_error error = SD_BUS_ERROR_NULL((const sd_bus_error) {(((void*)0)), (((void*)0)), 0});

1554

_cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *m = NULL((void*)0), *reply = NULL((void*)0);

1555

int r;

1556

1557

r = acquire_bus(false0, &bus);

1558

if (r < 0)

1559

return r;

1560

1561

r = sd_bus_message_new_method_call(bus, &m, argv[1], argv[2], argv[3], argv[4]);

1562

if (r < 0)

1563

return bus_log_create_error(r);

1564

1565

r = sd_bus_message_set_expect_reply(m, arg_expect_reply);

1566

if (r < 0)

1567

return bus_log_create_error(r);

1568

1569

r = sd_bus_message_set_auto_start(m, arg_auto_start);

1570

if (r < 0)

1571

return bus_log_create_error(r);

1572

1573

r = sd_bus_message_set_allow_interactive_authorization(m, arg_allow_interactive_authorization);

1574

if (r < 0)

1575

return bus_log_create_error(r);

1576

1577

if (!isempty(argv[5])) {

1578

char **p;

1579

1580

p = argv+6;

1581

1582

r = message_append_cmdline(m, argv[5], &p);

1583

if (r < 0)

1584

return r;

1585

1586

if (*p) {

1587

log_error("Too many parameters for signature.")({ int _level = (((3))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1587, __func__, "Too many parameters for signature."
) : -abs(_e); });

1588

return -EINVAL22;

1589

}

1590

}

1591

1592

if (!arg_expect_reply) {

1593

r = sd_bus_send(bus, m, NULL((void*)0));

1594

if (r < 0)

1595

return log_error_errno(r, "Failed to send message: %m")({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1595, __func__, "Failed to send message: %m"
) : -abs(_e); });

1596

1597

return 0;

1598

}

1599

1600

r = sd_bus_call(bus, m, arg_timeout, &error, &reply);

1601

if (r < 0)

1602

return log_error_errno(r, "%s", bus_error_message(&error, r))({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1602, __func__, "%s", bus_error_message
(&error, r)) : -abs(_e); });

1603

1604

r = sd_bus_message_is_empty(reply);

1605

if (r < 0)

1606

return bus_log_parse_error(r);

1607

1608

if (r == 0 && !arg_quiet) {

1609

1610

if (arg_verbose) {

1611

(void) pager_open(arg_no_pager, false0);

1612

1613

r = bus_message_dump(reply, stdoutstdout, 0);

1614

if (r < 0)

1615

return r;

1616

} else {

1617

1618

fputs(sd_bus_message_get_signature(reply, true1), stdoutstdout);

1619

fputc(' ', stdoutstdout);

1620

1621

r = format_cmdline(reply, stdoutstdout, false0);

1622

if (r < 0)

1623

return bus_log_parse_error(r);

1624

1625

fputc('\n', stdoutstdout);

1626

}

1627

}

1628

1629

return 0;

1630

}

1631

1632

static int get_property(int argc, char **argv, void *userdata) {

1633

_cleanup_(sd_bus_flush_close_unrefp)__attribute__((cleanup(sd_bus_flush_close_unrefp))) sd_bus *bus = NULL((void*)0);

1634

_cleanup_(sd_bus_error_free)__attribute__((cleanup(sd_bus_error_free))) sd_bus_error error = SD_BUS_ERROR_NULL((const sd_bus_error) {(((void*)0)), (((void*)0)), 0});

1635

char **i;

1636

int r;

1637

1638

r = acquire_bus(false0, &bus);

1639

if (r < 0)

1640

return r;

1641

1642

STRV_FOREACH(i, argv + 4)for ((i) = (argv + 4); (i) && *(i); (i)++) {

1643

_cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *reply = NULL((void*)0);

1644

const char *contents = NULL((void*)0);

1645

char type;

1646

1647

r = sd_bus_call_method(bus, argv[1], argv[2], "org.freedesktop.DBus.Properties", "Get", &error, &reply, "ss", argv[3], *i);

1648

if (r < 0)

1649

return log_error_errno(r, "%s", bus_error_message(&error, r))({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1649, __func__, "%s", bus_error_message
(&error, r)) : -abs(_e); });

1650

1651

r = sd_bus_message_peek_type(reply, &type, &contents);

1652

if (r < 0)

1653

return bus_log_parse_error(r);

1654

1655

r = sd_bus_message_enter_container(reply, 'v', contents);

1656

if (r < 0)

1657

return bus_log_parse_error(r);

1658

1659

if (arg_verbose) {

1660

(void) pager_open(arg_no_pager, false0);

1661

1662

r = bus_message_dump(reply, stdoutstdout, BUS_MESSAGE_DUMP_SUBTREE_ONLY);

1663

if (r < 0)

1664

return r;

1665

} else {

1666

fputs(contents, stdoutstdout);

1667

fputc(' ', stdoutstdout);

1668

1669

r = format_cmdline(reply, stdoutstdout, false0);

1670

if (r < 0)

1671

return bus_log_parse_error(r);

1672

1673

fputc('\n', stdoutstdout);

1674

}

1675

1676

r = sd_bus_message_exit_container(reply);

1677

if (r < 0)

1678

return bus_log_parse_error(r);

1679

}

1680

1681

return 0;

1682

}

1683

1684

static int set_property(int argc, char **argv, void *userdata) {

1685

_cleanup_(sd_bus_flush_close_unrefp)__attribute__((cleanup(sd_bus_flush_close_unrefp))) sd_bus *bus = NULL((void*)0);

1686

_cleanup_(sd_bus_message_unrefp)__attribute__((cleanup(sd_bus_message_unrefp))) sd_bus_message *m = NULL((void*)0);

1687

_cleanup_(sd_bus_error_free)__attribute__((cleanup(sd_bus_error_free))) sd_bus_error error = SD_BUS_ERROR_NULL((const sd_bus_error) {(((void*)0)), (((void*)0)), 0});

1688

char **p;

1689

int r;

1690

1691

r = acquire_bus(false0, &bus);

1692

if (r < 0)

1693

return r;

1694

1695

r = sd_bus_message_new_method_call(bus, &m, argv[1], argv[2], "org.freedesktop.DBus.Properties", "Set");

1696

if (r < 0)

1697

return bus_log_create_error(r);

1698

1699

r = sd_bus_message_append(m, "ss", argv[3], argv[4]);

1700

if (r < 0)

1701

return bus_log_create_error(r);

1702

1703

r = sd_bus_message_open_container(m, 'v', argv[5]);

1704

if (r < 0)

1705

return bus_log_create_error(r);

1706

1707

p = argv + 6;

1708

r = message_append_cmdline(m, argv[5], &p);

1709

if (r < 0)

1710

return r;

1711

1712

r = sd_bus_message_close_container(m);

1713

if (r < 0)

1714

return bus_log_create_error(r);

1715

1716

if (*p) {

1717

log_error("Too many parameters for signature.")({ int _level = (((3))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1717, __func__, "Too many parameters for signature."
) : -abs(_e); });

1718

return -EINVAL22;

1719

}

1720

1721

r = sd_bus_call(bus, m, arg_timeout, &error, NULL((void*)0));

1722

if (r < 0)

1723

return log_error_errno(r, "%s", bus_error_message(&error, r))({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1723, __func__, "%s", bus_error_message
(&error, r)) : -abs(_e); });

1724

1725

return 0;

1726

}

1727

1728

static int help(void) {

1729

printf("%s [OPTIONS...] {COMMAND} ...\n\n"

1730

"Introspect the bus.\n\n"

1731

" -h --help Show this help\n"

1732

" --version Show package version\n"

1733

" --no-pager Do not pipe output into a pager\n"

1734

" --no-legend Do not show the headers and footers\n"

1735

" --system Connect to system bus\n"

1736

" --user Connect to user bus\n"

1737

" -H --host=[USER@]HOST Operate on remote host\n"

1738

" -M --machine=CONTAINER Operate on local container\n"

1739

" --address=ADDRESS Connect to bus specified by address\n"

1740

" --show-machine Show machine ID column in list\n"

1741

" --unique Only show unique names\n"

1742

" --acquired Only show acquired names\n"

1743

" --activatable Only show activatable names\n"

1744

" --match=MATCH Only show matching messages\n"

1745

" --size=SIZE Maximum length of captured packet\n"

1746

" --list Don't show tree, but simple object path list\n"

1747

" -q --quiet Don't show method call reply\n"

1748

" --verbose Show result values in long format\n"

1749

" --expect-reply=BOOL Expect a method call reply\n"

1750

" --auto-start=BOOL Auto-start destination service\n"

1751

" --allow-interactive-authorization=BOOL\n"

1752

" Allow interactive authorization for operation\n"

1753

" --timeout=SECS Maximum time to wait for method call completion\n"

1754

" --augment-creds=BOOL Extend credential data with data read from /proc/$PID\n"

1755

" --watch-bind=BOOL Wait for bus AF_UNIX socket to be bound in the file\n"

1756

" system\n\n"

1757

"Commands:\n"

1758

" list List bus names\n"

1759

" status [SERVICE] Show bus service, process or bus owner credentials\n"

1760

" monitor [SERVICE...] Show bus traffic\n"

1761

" capture [SERVICE...] Capture bus traffic as pcap\n"

1762

" tree [SERVICE...] Show object tree of service\n"

1763

" introspect SERVICE OBJECT [INTERFACE]\n"

1764

" call SERVICE OBJECT INTERFACE METHOD [SIGNATURE [ARGUMENT...]]\n"

1765

" Call a method\n"

1766

" get-property SERVICE OBJECT INTERFACE PROPERTY...\n"

1767

" Get property value\n"

1768

" set-property SERVICE OBJECT INTERFACE PROPERTY SIGNATURE ARGUMENT...\n"

1769

" Set property value\n"

1770

" help Show this help\n"

1771

, program_invocation_short_name);

1772

1773

return 0;

1774

}

1775

1776

static int verb_help(int argc, char **argv, void *userdata) {

1777

return help();

1778

}

1779

1780

static int parse_argv(int argc, char *argv[]) {

1781

1782

enum {

1783

ARG_VERSION = 0x100,

1784

ARG_NO_PAGER,

1785

ARG_NO_LEGEND,

1786

ARG_SYSTEM,

1787

ARG_USER,

1788

ARG_ADDRESS,

1789

ARG_MATCH,

1790

ARG_SHOW_MACHINE,

1791

ARG_UNIQUE,

1792

ARG_ACQUIRED,

1793

ARG_ACTIVATABLE,

1794

ARG_SIZE,

1795

ARG_LIST,

1796

ARG_VERBOSE,

1797

ARG_EXPECT_REPLY,

1798

ARG_AUTO_START,

1799

ARG_ALLOW_INTERACTIVE_AUTHORIZATION,

1800

ARG_TIMEOUT,

1801

ARG_AUGMENT_CREDS,

1802

ARG_WATCH_BIND,

1803

};

1804

1805

static const struct option options[] = {

1806

{ "help", no_argument0, NULL((void*)0), 'h' },

1807

{ "version", no_argument0, NULL((void*)0), ARG_VERSION },

1808

{ "no-pager", no_argument0, NULL((void*)0), ARG_NO_PAGER },

1809

{ "no-legend", no_argument0, NULL((void*)0), ARG_NO_LEGEND },

1810

{ "system", no_argument0, NULL((void*)0), ARG_SYSTEM },

1811

{ "user", no_argument0, NULL((void*)0), ARG_USER },

1812

{ "address", required_argument1, NULL((void*)0), ARG_ADDRESS },

1813

{ "show-machine", no_argument0, NULL((void*)0), ARG_SHOW_MACHINE },

1814

{ "unique", no_argument0, NULL((void*)0), ARG_UNIQUE },

1815

{ "acquired", no_argument0, NULL((void*)0), ARG_ACQUIRED },

1816

{ "activatable", no_argument0, NULL((void*)0), ARG_ACTIVATABLE },

1817

{ "match", required_argument1, NULL((void*)0), ARG_MATCH },

1818

{ "host", required_argument1, NULL((void*)0), 'H' },

1819

{ "machine", required_argument1, NULL((void*)0), 'M' },

1820

{ "size", required_argument1, NULL((void*)0), ARG_SIZE },

1821

{ "list", no_argument0, NULL((void*)0), ARG_LIST },

1822

{ "quiet", no_argument0, NULL((void*)0), 'q' },

1823

{ "verbose", no_argument0, NULL((void*)0), ARG_VERBOSE },

1824

{ "expect-reply", required_argument1, NULL((void*)0), ARG_EXPECT_REPLY },

1825

{ "auto-start", required_argument1, NULL((void*)0), ARG_AUTO_START },

1826

{ "allow-interactive-authorization", required_argument1, NULL((void*)0), ARG_ALLOW_INTERACTIVE_AUTHORIZATION },

1827

{ "timeout", required_argument1, NULL((void*)0), ARG_TIMEOUT },

1828

{ "augment-creds",required_argument1, NULL((void*)0), ARG_AUGMENT_CREDS},

1829

{ "watch-bind", required_argument1, NULL((void*)0), ARG_WATCH_BIND },

1830

{},

1831

};

1832

1833

int c, r;

1834

1835

assert(argc >= 0)do { if ((__builtin_expect(!!(!(argc >= 0)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("argc >= 0"), "../src/busctl/busctl.c"
, 1835, __PRETTY_FUNCTION__); } while (0);

1836

assert(argv)do { if ((__builtin_expect(!!(!(argv)),0))) log_assert_failed_realm
(LOG_REALM_SYSTEMD, ("argv"), "../src/busctl/busctl.c", 1836,
__PRETTY_FUNCTION__); } while (0);

1837

1838

while ((c = getopt_long(argc, argv, "hH:M:q", options, NULL((void*)0))) >= 0)

1839

1840

switch (c) {

1841

1842

case 'h':

1843

return help();

1844

1845

case ARG_VERSION:

1846

return version();

1847

1848

case ARG_NO_PAGER:

1849

arg_no_pager = true1;

1850

break;

1851

1852

case ARG_NO_LEGEND:

1853

arg_legend = false0;

1854

break;

1855

1856

case ARG_USER:

1857

arg_user = true1;

1858

break;

1859

1860

case ARG_SYSTEM:

1861

arg_user = false0;

1862

break;

1863

1864

case ARG_ADDRESS:

1865

arg_address = optarg;

1866

break;

1867

1868

case ARG_SHOW_MACHINE:

1869

arg_show_machine = true1;

1870

break;

1871

1872

case ARG_UNIQUE:

1873

arg_unique = true1;

1874

break;

1875

1876

case ARG_ACQUIRED:

1877

arg_acquired = true1;

1878

break;

1879

1880

case ARG_ACTIVATABLE:

1881

arg_activatable = true1;

1882

break;

1883

1884

case ARG_MATCH:

1885

if (strv_extend(&arg_matches, optarg) < 0)

1886

return log_oom()log_oom_internal(LOG_REALM_SYSTEMD, "../src/busctl/busctl.c",
1886, __func__);

1887

break;

1888

1889

case ARG_SIZE: {

1890

uint64_t sz;

1891

1892

r = parse_size(optarg, 1024, &sz);

1893

if (r < 0)

1894

return log_error_errno(r, "Failed to parse size: %s", optarg)({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1894, __func__, "Failed to parse size: %s"
, optarg) : -abs(_e); });

1895

1896

if ((uint64_t) (size_t) sz != sz) {

1897

log_error("Size out of range.")({ int _level = (((3))), _e = ((0)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1897, __func__, "Size out of range."
) : -abs(_e); });

1898

return -E2BIG7;

1899

}

1900

1901

arg_snaplen = (size_t) sz;

1902

break;

1903

}

1904

1905

case ARG_LIST:

1906

arg_list = true1;

1907

break;

1908

1909

case 'H':

1910

arg_transport = BUS_TRANSPORT_REMOTE;

1911

arg_host = optarg;

1912

break;

1913

1914

case 'M':

1915

arg_transport = BUS_TRANSPORT_MACHINE;

1916

arg_host = optarg;

1917

break;

1918

1919

case 'q':

1920

arg_quiet = true1;

1921

break;

1922

1923

case ARG_VERBOSE:

1924

arg_verbose = true1;

1925

break;

1926

1927

case ARG_EXPECT_REPLY:

1928

r = parse_boolean(optarg);

1929

if (r < 0)

1930

return log_error_errno(r, "Failed to parse --expect-reply= parameter: %s", optarg)({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1930, __func__, "Failed to parse --expect-reply= parameter: %s"
, optarg) : -abs(_e); });

1931

1932

arg_expect_reply = r;

1933

break;

1934

1935

case ARG_AUTO_START:

1936

r = parse_boolean(optarg);

1937

if (r < 0)

1938

return log_error_errno(r, "Failed to parse --auto-start= parameter: %s", optarg)({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1938, __func__, "Failed to parse --auto-start= parameter: %s"
, optarg) : -abs(_e); });

1939

1940

arg_auto_start = r;

1941

break;

1942

1943

case ARG_ALLOW_INTERACTIVE_AUTHORIZATION:

1944

r = parse_boolean(optarg);

1945

if (r < 0)

1946

return log_error_errno(r, "Failed to parse --allow-interactive-authorization= parameter: %s", optarg)({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1946, __func__, "Failed to parse --allow-interactive-authorization= parameter: %s"
, optarg) : -abs(_e); });

1947

1948

arg_allow_interactive_authorization = r;

1949

break;

1950

1951

case ARG_TIMEOUT:

1952

r = parse_sec(optarg, &arg_timeout);

1953

if (r < 0)

1954

return log_error_errno(r, "Failed to parse --timeout= parameter: %s", optarg)({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1954, __func__, "Failed to parse --timeout= parameter: %s"
, optarg) : -abs(_e); });

1955

1956

break;

1957

1958

case ARG_AUGMENT_CREDS:

1959

r = parse_boolean(optarg);

1960

if (r < 0)

1961

return log_error_errno(r, "Failed to parse --augment-creds= parameter: %s", optarg)({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1961, __func__, "Failed to parse --augment-creds= parameter: %s"
, optarg) : -abs(_e); });

1962

1963

arg_augment_creds = r;

1964

break;

1965

1966

case ARG_WATCH_BIND:

1967

r = parse_boolean(optarg);

1968

if (r < 0)

1969

return log_error_errno(r, "Failed to parse --watch-bind= parameter: %s", optarg)({ int _level = ((3)), _e = ((r)), _realm = (LOG_REALM_SYSTEMD
); (log_get_max_level_realm(_realm) >= ((_level) & 0x07
)) ? log_internal_realm(((_realm) << 10 | (_level)), _e
, "../src/busctl/busctl.c", 1969, __func__, "Failed to parse --watch-bind= parameter: %s"
, optarg) : -abs(_e); });

1970

1971

arg_watch_bind = r;

1972

break;

1973

1974

case '?':

1975

return -EINVAL22;

1976

1977

default:

1978

assert_not_reached("Unhandled option")do { log_assert_failed_unreachable_realm(LOG_REALM_SYSTEMD, (
"Unhandled option"), "../src/busctl/busctl.c", 1978, __PRETTY_FUNCTION__
); } while (0);

1979

}

1980

1981

return 1;

1982

}

1983

1984

static int busctl_main(int argc, char *argv[]) {

1985

1986

static const Verb verbs[] = {

1987

{ "list", VERB_ANY((unsigned) -1), 1, VERB_DEFAULT, list_bus_names },

1988

{ "status", VERB_ANY((unsigned) -1), 2, 0, status },

1989

{ "monitor", VERB_ANY((unsigned) -1), VERB_ANY((unsigned) -1), 0, verb_monitor },

1990

{ "capture", VERB_ANY((unsigned) -1), VERB_ANY((unsigned) -1), 0, verb_capture },

1991

{ "tree", VERB_ANY((unsigned) -1), VERB_ANY((unsigned) -1), 0, tree },

1992

{ "introspect", 3, 4, 0, introspect },

1993

{ "call", 5, VERB_ANY((unsigned) -1), 0, call },

1994

{ "get-property", 5, VERB_ANY((unsigned) -1), 0, get_property },

1995

{ "set-property", 6, VERB_ANY((unsigned) -1), 0, set_property },

1996

{ "help", VERB_ANY((unsigned) -1), VERB_ANY((unsigned) -1), 0, verb_help },

1997

{}

1998

};

1999

2000

return dispatch_verb(argc, argv, verbs, NULL((void*)0));

2001

}

2002

2003

int main(int argc, char *argv[]) {

2004

int r;

2005

2006

log_parse_environment()log_parse_environment_realm(LOG_REALM_SYSTEMD);

2007

log_open();

2008

2009

r = parse_argv(argc, argv);

2010

if (r <= 0)

2011

goto finish;

2012

2013

r = busctl_main(argc, argv);

2014

2015

finish:

2016

/* make sure we terminate the bus connection first, and then close the

2017

* pager, see issue #3543 for the details. */

2018

pager_close();

2019

2020

arg_matches = strv_free(arg_matches);

2021

2022

return r < 0 ? EXIT_FAILURE1 : EXIT_SUCCESS0;

2023

}

File:	build-scan/../src/busctl/busctl.c
Warning:	line 1010, column 25 Value stored to 'mf' is never read

Bug Summary

Annotated Source Code