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

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