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

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