src/libsystemd/sd-bus/bus-dump.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <sys/time.h>
   4
   5 #include "alloc-util.h"
   6 #include "bus-dump.h"
   7 #include "bus-internal.h"
   8 #include "bus-message.h"
   9 #include "bus-type.h"
  10 #include "cap-list.h"
  11 #include "capability-util.h"
  12 #include "fileio.h"
  13 #include "format-util.h"
  14 #include "locale-util.h"
  15 #include "macro.h"
  16 #include "string-util.h"
  17 #include "strv.h"
  18 #include "terminal-util.h"
  19 #include "util.h"
  20
  21 static char *indent(unsigned level, unsigned flags) {
  22         char *p;
  23         unsigned n, i = 0;
  24
  25         n = 0;
  26
  27         if (flags & BUS_MESSAGE_DUMP_SUBTREE_ONLY && level > 0)
  28                 level -= 1;
  29
  30         if (flags & BUS_MESSAGE_DUMP_WITH_HEADER)
  31                 n += 2;
  32
  33         p = new(char, n + level*8 + 1);
  34         if (!p)
  35                 return NULL;
  36
  37         if (flags & BUS_MESSAGE_DUMP_WITH_HEADER) {
  38                 p[i++] = ' ';
  39                 p[i++] = ' ';
  40         }
  41
  42         memset(p + i, ' ', level*8);
  43         p[i + level*8] = 0;
  44
  45         return p;
  46 }
  47
  48 int bus_message_dump(sd_bus_message *m, FILE *f, unsigned flags) {
  49         unsigned level = 1;
  50         int r;
  51
  52         assert(m);
  53
  54         if (!f)
  55                 f = stdout;
  56
  57         if (flags & BUS_MESSAGE_DUMP_WITH_HEADER) {
  58                 fprintf(f,
  59                         "%s%s%s Type=%s%s%s  Endian=%c  Flags=%u  Version=%u  Priority=%"PRIi64,
  60                         m->header->type == SD_BUS_MESSAGE_METHOD_ERROR ? ansi_highlight_red() :
  61                         m->header->type == SD_BUS_MESSAGE_METHOD_RETURN ? ansi_highlight_green() :
  62                         m->header->type != SD_BUS_MESSAGE_SIGNAL ? ansi_highlight() : "",
  63                         special_glyph(SPECIAL_GLYPH_TRIANGULAR_BULLET),
  64                         ansi_normal(),
  65
  66                         ansi_highlight(),
  67                         bus_message_type_to_string(m->header->type) ?: "(unknown)",
  68                         ansi_normal(),
  69
  70                         m->header->endian,
  71                         m->header->flags,
  72                         m->header->version,
  73                         m->priority);
  74
  75                 /* Display synthetic message serial number in a more readable
  76                  * format than (uint32_t) -1 */
  77                 if (BUS_MESSAGE_COOKIE(m) == 0xFFFFFFFFULL)
  78                         fprintf(f, " Cookie=-1");
  79                 else
  80                         fprintf(f, " Cookie=%" PRIu64, BUS_MESSAGE_COOKIE(m));
  81
  82                 if (m->reply_cookie != 0)
  83                         fprintf(f, "  ReplyCookie=%" PRIu64, m->reply_cookie);
  84
  85                 fputs("\n", f);
  86
  87                 if (m->sender)
  88                         fprintf(f, "  Sender=%s%s%s", ansi_highlight(), m->sender, ansi_normal());
  89                 if (m->destination)
  90                         fprintf(f, "  Destination=%s%s%s", ansi_highlight(), m->destination, ansi_normal());
  91                 if (m->path)
  92                         fprintf(f, "  Path=%s%s%s", ansi_highlight(), m->path, ansi_normal());
  93                 if (m->interface)
  94                         fprintf(f, "  Interface=%s%s%s", ansi_highlight(), m->interface, ansi_normal());
  95                 if (m->member)
  96                         fprintf(f, "  Member=%s%s%s", ansi_highlight(), m->member, ansi_normal());
  97
  98                 if (m->sender || m->destination || m->path || m->interface || m->member)
  99                         fputs("\n", f);
 100
 101                 if (sd_bus_error_is_set(&m->error))
 102                         fprintf(f,
 103                                 "  ErrorName=%s%s%s"
 104                                 "  ErrorMessage=%s\"%s\"%s\n",
 105                                 ansi_highlight_red(), strna(m->error.name), ansi_normal(),
 106                                 ansi_highlight_red(), strna(m->error.message), ansi_normal());
 107
 108                 if (m->monotonic != 0)
 109                         fprintf(f, "  Monotonic="USEC_FMT, m->monotonic);
 110                 if (m->realtime != 0)
 111                         fprintf(f, "  Realtime="USEC_FMT, m->realtime);
 112                 if (m->seqnum != 0)
 113                         fprintf(f, "  SequenceNumber=%"PRIu64, m->seqnum);
 114
 115                 if (m->monotonic != 0 || m->realtime != 0 || m->seqnum != 0)
 116                         fputs("\n", f);
 117
 118                 bus_creds_dump(&m->creds, f, true);
 119         }
 120
 121         r = sd_bus_message_rewind(m, !(flags & BUS_MESSAGE_DUMP_SUBTREE_ONLY));
 122         if (r < 0)
 123                 return log_error_errno(r, "Failed to rewind: %m");
 124
 125         if (!(flags & BUS_MESSAGE_DUMP_SUBTREE_ONLY)) {
 126                 _cleanup_free_ char *prefix = NULL;
 127
 128                 prefix = indent(0, flags);
 129                 if (!prefix)
 130                         return log_oom();
 131
 132                 fprintf(f, "%sMESSAGE \"%s\" {\n", prefix, strempty(m->root_container.signature));
 133         }
 134
 135         for (;;) {
 136                 _cleanup_free_ char *prefix = NULL;
 137                 const char *contents = NULL;
 138                 char type;
 139                 union {
 140                         uint8_t u8;
 141                         uint16_t u16;
 142                         int16_t s16;
 143                         uint32_t u32;
 144                         int32_t s32;
 145                         uint64_t u64;
 146                         int64_t s64;
 147                         double d64;
 148                         const char *string;
 149                         int i;
 150                 } basic;
 151
 152                 r = sd_bus_message_peek_type(m, &type, &contents);
 153                 if (r < 0)
 154                         return log_error_errno(r, "Failed to peek type: %m");
 155
 156                 if (r == 0) {
 157                         if (level <= 1)
 158                                 break;
 159
 160                         r = sd_bus_message_exit_container(m);
 161                         if (r < 0)
 162                                 return log_error_errno(r, "Failed to exit container: %m");
 163
 164                         level--;
 165
 166                         prefix = indent(level, flags);
 167                         if (!prefix)
 168                                 return log_oom();
 169
 170                         fprintf(f, "%s};\n", prefix);
 171                         continue;
 172                 }
 173
 174                 prefix = indent(level, flags);
 175                 if (!prefix)
 176                         return log_oom();
 177
 178                 if (bus_type_is_container(type) > 0) {
 179                         r = sd_bus_message_enter_container(m, type, contents);
 180                         if (r < 0)
 181                                 return log_error_errno(r, "Failed to enter container: %m");
 182
 183                         if (type == SD_BUS_TYPE_ARRAY)
 184                                 fprintf(f, "%sARRAY \"%s\" {\n", prefix, contents);
 185                         else if (type == SD_BUS_TYPE_VARIANT)
 186                                 fprintf(f, "%sVARIANT \"%s\" {\n", prefix, contents);
 187                         else if (type == SD_BUS_TYPE_STRUCT)
 188                                 fprintf(f, "%sSTRUCT \"%s\" {\n", prefix, contents);
 189                         else if (type == SD_BUS_TYPE_DICT_ENTRY)
 190                                 fprintf(f, "%sDICT_ENTRY \"%s\" {\n", prefix, contents);
 191
 192                         level++;
 193
 194                         continue;
 195                 }
 196
 197                 r = sd_bus_message_read_basic(m, type, &basic);
 198                 if (r < 0)
 199                         return log_error_errno(r, "Failed to get basic: %m");
 200
 201                 assert(r > 0);
 202
 203                 switch (type) {
 204
 205                 case SD_BUS_TYPE_BYTE:
 206                         fprintf(f, "%sBYTE %s%u%s;\n", prefix, ansi_highlight(), basic.u8, ansi_normal());
 207                         break;
 208
 209                 case SD_BUS_TYPE_BOOLEAN:
 210                         fprintf(f, "%sBOOLEAN %s%s%s;\n", prefix, ansi_highlight(), true_false(basic.i), ansi_normal());
 211                         break;
 212
 213                 case SD_BUS_TYPE_INT16:
 214                         fprintf(f, "%sINT16 %s%i%s;\n", prefix, ansi_highlight(), basic.s16, ansi_normal());
 215                         break;
 216
 217                 case SD_BUS_TYPE_UINT16:
 218                         fprintf(f, "%sUINT16 %s%u%s;\n", prefix, ansi_highlight(), basic.u16, ansi_normal());
 219                         break;
 220
 221                 case SD_BUS_TYPE_INT32:
 222                         fprintf(f, "%sINT32 %s%i%s;\n", prefix, ansi_highlight(), basic.s32, ansi_normal());
 223                         break;
 224
 225                 case SD_BUS_TYPE_UINT32:
 226                         fprintf(f, "%sUINT32 %s%u%s;\n", prefix, ansi_highlight(), basic.u32, ansi_normal());
 227                         break;
 228
 229                 case SD_BUS_TYPE_INT64:
 230                         fprintf(f, "%sINT64 %s%"PRIi64"%s;\n", prefix, ansi_highlight(), basic.s64, ansi_normal());
 231                         break;
 232
 233                 case SD_BUS_TYPE_UINT64:
 234                         fprintf(f, "%sUINT64 %s%"PRIu64"%s;\n", prefix, ansi_highlight(), basic.u64, ansi_normal());
 235                         break;
 236
 237                 case SD_BUS_TYPE_DOUBLE:
 238                         fprintf(f, "%sDOUBLE %s%g%s;\n", prefix, ansi_highlight(), basic.d64, ansi_normal());
 239                         break;
 240
 241                 case SD_BUS_TYPE_STRING:
 242                         fprintf(f, "%sSTRING \"%s%s%s\";\n", prefix, ansi_highlight(), basic.string, ansi_normal());
 243                         break;
 244
 245                 case SD_BUS_TYPE_OBJECT_PATH:
 246                         fprintf(f, "%sOBJECT_PATH \"%s%s%s\";\n", prefix, ansi_highlight(), basic.string, ansi_normal());
 247                         break;
 248
 249                 case SD_BUS_TYPE_SIGNATURE:
 250                         fprintf(f, "%sSIGNATURE \"%s%s%s\";\n", prefix, ansi_highlight(), basic.string, ansi_normal());
 251                         break;
 252
 253                 case SD_BUS_TYPE_UNIX_FD:
 254                         fprintf(f, "%sUNIX_FD %s%i%s;\n", prefix, ansi_highlight(), basic.i, ansi_normal());
 255                         break;
 256
 257                 default:
 258                         assert_not_reached("Unknown basic type.");
 259                 }
 260         }
 261
 262         if (!(flags & BUS_MESSAGE_DUMP_SUBTREE_ONLY)) {
 263                 _cleanup_free_ char *prefix = NULL;
 264
 265                 prefix = indent(0, flags);
 266                 if (!prefix)
 267                         return log_oom();
 268
 269                 fprintf(f, "%s};\n\n", prefix);
 270         }
 271
 272         return 0;
 273 }
 274
 275 static void dump_capabilities(
 276                 sd_bus_creds *c,
 277                 FILE *f,
 278                 const char *name,
 279                 bool terse,
 280                 int (*has)(sd_bus_creds *c, int capability)) {
 281
 282         unsigned long i, last_cap;
 283         unsigned n = 0;
 284         int r;
 285
 286         assert(c);
 287         assert(f);
 288         assert(name);
 289         assert(has);
 290
 291         i = 0;
 292         r = has(c, i);
 293         if (r < 0)
 294                 return;
 295
 296         fprintf(f, "%s%s=%s", terse ? "  " : "", name, terse ? "" : ansi_highlight());
 297         last_cap = cap_last_cap();
 298
 299         for (;;) {
 300                 if (r > 0) {
 301
 302                         if (n > 0)
 303                                 fputc(' ', f);
 304                         if (n % 4 == 3)
 305                                 fprintf(f, terse ? "\n          " : "\n        ");
 306
 307                         fprintf(f, "%s", strna(capability_to_name(i)));
 308                         n++;
 309                 }
 310
 311                 i++;
 312
 313                 if (i > last_cap)
 314                         break;
 315
 316                 r = has(c, i);
 317         }
 318
 319         fputs("\n", f);
 320
 321         if (!terse)
 322                 fputs(ansi_normal(), f);
 323 }
 324
 325 int bus_creds_dump(sd_bus_creds *c, FILE *f, bool terse) {
 326         uid_t owner, audit_loginuid;
 327         uint32_t audit_sessionid;
 328         char **cmdline = NULL, **well_known = NULL;
 329         const char *prefix, *color, *suffix, *s;
 330         int r, q, v, w, z;
 331
 332         assert(c);
 333
 334         if (!f)
 335                 f = stdout;
 336
 337         if (terse) {
 338                 prefix = "  ";
 339                 suffix = "";
 340                 color = "";
 341         } else {
 342                 const char *off;
 343
 344                 prefix = "";
 345                 color = ansi_highlight();
 346
 347                 off = ansi_normal();
 348                 suffix = strjoina(off, "\n");
 349         }
 350
 351         if (c->mask & SD_BUS_CREDS_PID)
 352                 fprintf(f, "%sPID=%s"PID_FMT"%s", prefix, color, c->pid, suffix);
 353         if (c->mask & SD_BUS_CREDS_TID)
 354                 fprintf(f, "%sTID=%s"PID_FMT"%s", prefix, color, c->tid, suffix);
 355         if (c->mask & SD_BUS_CREDS_PPID) {
 356                 if (c->ppid == 0)
 357                         fprintf(f, "%sPPID=%sn/a%s", prefix, color, suffix);
 358                 else
 359                         fprintf(f, "%sPPID=%s"PID_FMT"%s", prefix, color, c->ppid, suffix);
 360         }
 361         if (c->mask & SD_BUS_CREDS_TTY)
 362                 fprintf(f, "%sTTY=%s%s%s", prefix, color, strna(c->tty), suffix);
 363
 364         if (terse && ((c->mask & (SD_BUS_CREDS_PID|SD_BUS_CREDS_TID|SD_BUS_CREDS_PPID|SD_BUS_CREDS_TTY))))
 365                 fputs("\n", f);
 366
 367         if (c->mask & SD_BUS_CREDS_UID)
 368                 fprintf(f, "%sUID=%s"UID_FMT"%s", prefix, color, c->uid, suffix);
 369         if (c->mask & SD_BUS_CREDS_EUID)
 370                 fprintf(f, "%sEUID=%s"UID_FMT"%s", prefix, color, c->euid, suffix);
 371         if (c->mask & SD_BUS_CREDS_SUID)
 372                 fprintf(f, "%sSUID=%s"UID_FMT"%s", prefix, color, c->suid, suffix);
 373         if (c->mask & SD_BUS_CREDS_FSUID)
 374                 fprintf(f, "%sFSUID=%s"UID_FMT"%s", prefix, color, c->fsuid, suffix);
 375         r = sd_bus_creds_get_owner_uid(c, &owner);
 376         if (r >= 0)
 377                 fprintf(f, "%sOwnerUID=%s"UID_FMT"%s", prefix, color, owner, suffix);
 378         if (c->mask & SD_BUS_CREDS_GID)
 379                 fprintf(f, "%sGID=%s"GID_FMT"%s", prefix, color, c->gid, suffix);
 380         if (c->mask & SD_BUS_CREDS_EGID)
 381                 fprintf(f, "%sEGID=%s"GID_FMT"%s", prefix, color, c->egid, suffix);
 382         if (c->mask & SD_BUS_CREDS_SGID)
 383                 fprintf(f, "%sSGID=%s"GID_FMT"%s", prefix, color, c->sgid, suffix);
 384         if (c->mask & SD_BUS_CREDS_FSGID)
 385                 fprintf(f, "%sFSGID=%s"GID_FMT"%s", prefix, color, c->fsgid, suffix);
 386
 387         if (c->mask & SD_BUS_CREDS_SUPPLEMENTARY_GIDS) {
 388                 unsigned i;
 389
 390                 fprintf(f, "%sSupplementaryGIDs=%s", prefix, color);
 391                 for (i = 0; i < c->n_supplementary_gids; i++)
 392                         fprintf(f, "%s" GID_FMT, i > 0 ? " " : "", c->supplementary_gids[i]);
 393                 fprintf(f, "%s", suffix);
 394         }
 395
 396         if (terse && ((c->mask & (SD_BUS_CREDS_UID|SD_BUS_CREDS_EUID|SD_BUS_CREDS_SUID|SD_BUS_CREDS_FSUID|
 397                                   SD_BUS_CREDS_GID|SD_BUS_CREDS_EGID|SD_BUS_CREDS_SGID|SD_BUS_CREDS_FSGID|
 398                                   SD_BUS_CREDS_SUPPLEMENTARY_GIDS)) || r >= 0))
 399                 fputs("\n", f);
 400
 401         if (c->mask & SD_BUS_CREDS_COMM)
 402                 fprintf(f, "%sComm=%s%s%s", prefix, color, c->comm, suffix);
 403         if (c->mask & SD_BUS_CREDS_TID_COMM)
 404                 fprintf(f, "%sTIDComm=%s%s%s", prefix, color, c->tid_comm, suffix);
 405         if (c->mask & SD_BUS_CREDS_EXE)
 406                 fprintf(f, "%sExe=%s%s%s", prefix, color, strna(c->exe), suffix);
 407
 408         if (terse && (c->mask & (SD_BUS_CREDS_EXE|SD_BUS_CREDS_COMM|SD_BUS_CREDS_TID_COMM)))
 409                 fputs("\n", f);
 410
 411         r = sd_bus_creds_get_cmdline(c, &cmdline);
 412         if (r >= 0) {
 413                 char **i;
 414
 415                 fprintf(f, "%sCommandLine=%s", prefix, color);
 416                 STRV_FOREACH(i, cmdline) {
 417                         if (i != cmdline)
 418                                 fputc(' ', f);
 419
 420                         fputs(*i, f);
 421                 }
 422
 423                 fprintf(f, "%s", suffix);
 424         } else if (r != -ENODATA)
 425                 fprintf(f, "%sCommandLine=%sn/a%s", prefix, color, suffix);
 426
 427         if (c->mask & SD_BUS_CREDS_SELINUX_CONTEXT)
 428                 fprintf(f, "%sLabel=%s%s%s", prefix, color, c->label, suffix);
 429         if (c->mask & SD_BUS_CREDS_DESCRIPTION)
 430                 fprintf(f, "%sDescription=%s%s%s", prefix, color, c->description, suffix);
 431
 432         if (terse && (c->mask & (SD_BUS_CREDS_SELINUX_CONTEXT|SD_BUS_CREDS_DESCRIPTION)))
 433                 fputs("\n", f);
 434
 435         if (c->mask & SD_BUS_CREDS_CGROUP)
 436                 fprintf(f, "%sCGroup=%s%s%s", prefix, color, c->cgroup, suffix);
 437         s = NULL;
 438         r = sd_bus_creds_get_unit(c, &s);
 439         if (r != -ENODATA)
 440                 fprintf(f, "%sUnit=%s%s%s", prefix, color, strna(s), suffix);
 441         s = NULL;
 442         v = sd_bus_creds_get_slice(c, &s);
 443         if (v != -ENODATA)
 444                 fprintf(f, "%sSlice=%s%s%s", prefix, color, strna(s), suffix);
 445         s = NULL;
 446         q = sd_bus_creds_get_user_unit(c, &s);
 447         if (q != -ENODATA)
 448                 fprintf(f, "%sUserUnit=%s%s%s", prefix, color, strna(s), suffix);
 449         s = NULL;
 450         w = sd_bus_creds_get_user_slice(c, &s);
 451         if (w != -ENODATA)
 452                 fprintf(f, "%sUserSlice=%s%s%s", prefix, color, strna(s), suffix);
 453         s = NULL;
 454         z = sd_bus_creds_get_session(c, &s);
 455         if (z != -ENODATA)
 456                 fprintf(f, "%sSession=%s%s%s", prefix, color, strna(s), suffix);
 457
 458         if (terse && ((c->mask & SD_BUS_CREDS_CGROUP) || r != -ENODATA || q != -ENODATA || v != -ENODATA || w != -ENODATA || z != -ENODATA))
 459                 fputs("\n", f);
 460
 461         r = sd_bus_creds_get_audit_login_uid(c, &audit_loginuid);
 462         if (r >= 0)
 463                 fprintf(f, "%sAuditLoginUID=%s"UID_FMT"%s", prefix, color, audit_loginuid, suffix);
 464         else if (r != -ENODATA)
 465                 fprintf(f, "%sAuditLoginUID=%sn/a%s", prefix, color, suffix);
 466         q = sd_bus_creds_get_audit_session_id(c, &audit_sessionid);
 467         if (q >= 0)
 468                 fprintf(f, "%sAuditSessionID=%s%"PRIu32"%s", prefix, color, audit_sessionid, suffix);
 469         else if (q != -ENODATA)
 470                 fprintf(f, "%sAuditSessionID=%sn/a%s", prefix, color, suffix);
 471
 472         if (terse && (r != -ENODATA || q != -ENODATA))
 473                 fputs("\n", f);
 474
 475         if (c->mask & SD_BUS_CREDS_UNIQUE_NAME)
 476                 fprintf(f, "%sUniqueName=%s%s%s", prefix, color, c->unique_name, suffix);
 477
 478         if (sd_bus_creds_get_well_known_names(c, &well_known) >= 0) {
 479                 char **i;
 480
 481                 fprintf(f, "%sWellKnownNames=%s", prefix, color);
 482                 STRV_FOREACH(i, well_known) {
 483                         if (i != well_known)
 484                                 fputc(' ', f);
 485
 486                         fputs(*i, f);
 487                 }
 488
 489                 fprintf(f, "%s", suffix);
 490         }
 491
 492         if (terse && (c->mask & SD_BUS_CREDS_UNIQUE_NAME || well_known))
 493                 fputc('\n', f);
 494
 495         dump_capabilities(c, f, "EffectiveCapabilities", terse, sd_bus_creds_has_effective_cap);
 496         dump_capabilities(c, f, "PermittedCapabilities", terse, sd_bus_creds_has_permitted_cap);
 497         dump_capabilities(c, f, "InheritableCapabilities", terse, sd_bus_creds_has_inheritable_cap);
 498         dump_capabilities(c, f, "BoundingCapabilities", terse, sd_bus_creds_has_bounding_cap);
 499
 500         return 0;
 501 }
 502
 503 /*
 504  * For details about the file format, see:
 505  *
 506  * http://wiki.wireshark.org/Development/LibpcapFileFormat
 507  */
 508
 509 typedef struct _packed_ pcap_hdr_s {
 510         uint32_t magic_number;   /* magic number */
 511         uint16_t version_major;  /* major version number */
 512         uint16_t version_minor;  /* minor version number */
 513         int32_t  thiszone;       /* GMT to local correction */
 514         uint32_t sigfigs;        /* accuracy of timestamps */
 515         uint32_t snaplen;        /* max length of captured packets, in octets */
 516         uint32_t network;        /* data link type */
 517 } pcap_hdr_t ;
 518
 519 typedef struct  _packed_ pcaprec_hdr_s {
 520         uint32_t ts_sec;         /* timestamp seconds */
 521         uint32_t ts_usec;        /* timestamp microseconds */
 522         uint32_t incl_len;       /* number of octets of packet saved in file */
 523         uint32_t orig_len;       /* actual length of packet */
 524 } pcaprec_hdr_t;
 525
 526 int bus_pcap_header(size_t snaplen, FILE *f) {
 527
 528         pcap_hdr_t hdr = {
 529                 .magic_number = 0xa1b2c3d4U,
 530                 .version_major = 2,
 531                 .version_minor = 4,
 532                 .thiszone = 0, /* UTC */
 533                 .sigfigs = 0,
 534                 .network = 231, /* D-Bus */
 535         };
 536
 537         if (!f)
 538                 f = stdout;
 539
 540         assert(snaplen > 0);
 541         assert((size_t) (uint32_t) snaplen == snaplen);
 542
 543         hdr.snaplen = (uint32_t) snaplen;
 544
 545         fwrite(&hdr, 1, sizeof(hdr), f);
 546
 547         return fflush_and_check(f);
 548 }
 549
 550 int bus_message_pcap_frame(sd_bus_message *m, size_t snaplen, FILE *f) {
 551         struct bus_body_part *part;
 552         pcaprec_hdr_t hdr = {};
 553         struct timeval tv;
 554         unsigned i;
 555         size_t w;
 556
 557         if (!f)
 558                 f = stdout;
 559
 560         assert(m);
 561         assert(snaplen > 0);
 562         assert((size_t) (uint32_t) snaplen == snaplen);
 563
 564         if (m->realtime != 0)
 565                 timeval_store(&tv, m->realtime);
 566         else
 567                 assert_se(gettimeofday(&tv, NULL) >= 0);
 568
 569         hdr.ts_sec = tv.tv_sec;
 570         hdr.ts_usec = tv.tv_usec;
 571         hdr.orig_len = BUS_MESSAGE_SIZE(m);
 572         hdr.incl_len = MIN(hdr.orig_len, snaplen);
 573
 574         /* write the pcap header */
 575         fwrite(&hdr, 1, sizeof(hdr), f);
 576
 577         /* write the dbus header */
 578         w = MIN(BUS_MESSAGE_BODY_BEGIN(m), snaplen);
 579         fwrite(m->header, 1, w, f);
 580         snaplen -= w;
 581
 582         /* write the dbus body */
 583         MESSAGE_FOREACH_PART(part, i, m) {
 584                 if (snaplen <= 0)
 585                         break;
 586
 587                 w = MIN(part->size, snaplen);
 588                 fwrite(part->data, 1, w, f);
 589                 snaplen -= w;
 590         }
 591
 592         return fflush_and_check(f);
 593 }