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

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