debugfs/xattrs.c

   1 /*
   2  * xattrs.c --- Modify extended attributes via debugfs.
   3  *
   4  * Copyright (C) 2014 Oracle.  This file may be redistributed
   5  * under the terms of the GNU Public License.
   6  */
   7
   8 #include "config.h"
   9 #include <stdio.h>
  10 #ifdef HAVE_GETOPT_H
  11 #include <getopt.h>
  12 #else
  13 extern int optind;
  14 extern char *optarg;
  15 #endif
  16 #include <ctype.h>
  17 #include "support/cstring.h"
  18
  19 #include "debugfs.h"
  20 #include "ext2fs/ext4_acl.h"
  21 #include "ext2fs/lfsck.h"
  22
  23 #define PRINT_XATTR_HEX         0x01
  24 #define PRINT_XATTR_RAW         0x02
  25 #define PRINT_XATTR_C           0x04
  26 #define PRINT_XATTR_STATFMT     0x08
  27 #define PRINT_XATTR_NOQUOTES    0x10
  28
  29 extern const char *debug_prog_name;
  30
  31 /* Dump extended attributes */
  32 static void print_xattr_hex(FILE *f, const char *str, int len)
  33 {
  34         int i;
  35
  36         for (i = 0; i < len; i++)
  37                 fprintf(f, "%02x ", (unsigned char)str[i]);
  38 }
  39
  40 /* Dump extended attributes */
  41 static void print_xattr_string(FILE *f, const char *str, int len, int flags)
  42 {
  43         int printable = 0;
  44         int i;
  45
  46         if (flags & PRINT_XATTR_RAW) {
  47                 fwrite(str, len, 1, f);
  48                 return;
  49         }
  50
  51         if ((flags & PRINT_XATTR_C) == 0) {
  52                 /* check: is string "printable enough?" */
  53                 for (i = 0; i < len; i++)
  54                         if (isprint(str[i]))
  55                                 printable++;
  56
  57                 if (printable <= len*7/8)
  58                         flags |= PRINT_XATTR_HEX;
  59         }
  60
  61         if (flags & PRINT_XATTR_HEX) {
  62                 print_xattr_hex(f, str, len);
  63         } else {
  64                 if ((flags & PRINT_XATTR_NOQUOTES) == 0)
  65                         fputc('\"', f);
  66                 print_c_string(f, str, len);
  67                 if ((flags & PRINT_XATTR_NOQUOTES) == 0)
  68                         fputc('\"', f);
  69         }
  70 }
  71
  72 static void print_xattr(FILE *f, char *name, char *value, size_t value_len,
  73                         int print_flags)
  74 {
  75         print_xattr_string(f, name, strlen(name), PRINT_XATTR_NOQUOTES);
  76         fprintf(f, " (%zu)", value_len);
  77         if ((print_flags & PRINT_XATTR_STATFMT) &&
  78             (strcmp(name, "system.data") == 0))
  79                 value_len = 0;
  80         if (value_len != 0 &&
  81             (!(print_flags & PRINT_XATTR_STATFMT) || (value_len < 120))) {
  82                 fprintf(f, " = ");
  83                 print_xattr_string(f, value, value_len, print_flags);
  84         }
  85         fputc('\n', f);
  86 }
  87
  88 static int print_acl(FILE *f, char *name, void *value, size_t value_len)
  89 {
  90         const ext4_acl_header *ext_acl = (const ext4_acl_header *)value;
  91         const char *cp;
  92
  93         if (!value ||
  94             (value_len < sizeof(ext4_acl_header)) ||
  95             (ext_acl->a_version != ext2fs_cpu_to_le32(EXT4_ACL_VERSION)))
  96                 return -EINVAL;
  97
  98         cp = (const char *)value + sizeof(ext4_acl_header);
  99         value_len -= sizeof(ext4_acl_header);
 100
 101         fprintf(f, "%s:\n", name);
 102
 103         while (value_len > 0) {
 104                 const ext4_acl_entry *disk_entry = (const ext4_acl_entry *)cp;
 105                 posix_acl_xattr_entry entry;
 106                 entry.e_tag = ext2fs_le16_to_cpu(disk_entry->e_tag);
 107                 entry.e_perm = ext2fs_le16_to_cpu(disk_entry->e_perm);
 108
 109                 switch(entry.e_tag) {
 110                         case ACL_USER_OBJ:
 111                         case ACL_USER:
 112                                 fprintf(f, "    user:");
 113                                 if (entry.e_tag == ACL_USER)
 114                                         fprintf(f, "%u",
 115                                         ext2fs_le32_to_cpu(disk_entry->e_id));
 116                                 break;
 117
 118                         case ACL_GROUP_OBJ:
 119                         case ACL_GROUP:
 120                                 fprintf(f, "    group:");
 121                                 if (entry.e_tag == ACL_GROUP)
 122                                         fprintf(f, "%u",
 123                                         ext2fs_le32_to_cpu(disk_entry->e_id));
 124                                 break;
 125
 126                         case ACL_MASK:
 127                                 fprintf(f, "    mask:");
 128                                 break;
 129
 130                         case ACL_OTHER:
 131                                 fprintf(f, "    other:");
 132                                 break;
 133
 134                         default:
 135                                 fprintf(stderr,
 136                                         "%s: error: invalid tag %x in ACL\n",
 137                                         debug_prog_name, entry.e_tag);
 138                                 return -EINVAL;
 139                 }
 140                 fprintf(f, ":");
 141                 fprintf(f, (entry.e_perm & ACL_READ) ? "r" : "-");
 142                 fprintf(f, (entry.e_perm & ACL_WRITE) ? "w" : "-");
 143                 fprintf(f, (entry.e_perm & ACL_EXECUTE) ? "x" : "-");
 144                 fprintf(f, "\n");
 145
 146                 if (entry.e_tag == ACL_USER || entry.e_tag == ACL_GROUP) {
 147                         cp += sizeof(ext4_acl_entry);
 148                         value_len -= sizeof(ext4_acl_entry);
 149                 } else {
 150                         cp += sizeof(ext4_acl_entry_short);
 151                         value_len -= sizeof(ext4_acl_entry_short);
 152                 }
 153         }
 154
 155         return 0;
 156 }
 157
 158 static int print_fidstr(FILE *f, char *name, void *value, size_t value_len)
 159 {
 160         struct filter_fid_old *ff = value;
 161         int stripe;
 162
 163         /* Since Lustre 2.4 only the parent FID is stored in filter_fid,
 164          * and the self fid is stored in the LMA and is printed below. */
 165         if (value_len < sizeof(ff->ff_parent)) {
 166                 fprintf(stderr, "%s: error: xattr '%s' too small (%zu bytes)\n",
 167                         debug_prog_name, name, value_len);
 168                 return -EINVAL;
 169         }
 170         fid_le_to_cpu(&ff->ff_parent, &ff->ff_parent);
 171         stripe = fid_ver(&ff->ff_parent); /* stripe index is stored in f_ver */
 172         ff->ff_parent.f_ver = 0;
 173
 174         fprintf(f, "fid: ");
 175         /* Old larger filter_fid should only ever be used with seq = 0.
 176          * FID-on-OST should use LMA for FID_SEQ_NORMAL OST objects. */
 177         if (value_len == sizeof(*ff))
 178                 fprintf(f, "objid=%llu seq=%llu ",
 179                         ext2fs_le64_to_cpu(ff->ff_objid),
 180                         ext2fs_le64_to_cpu(ff->ff_seq));
 181
 182         fprintf(f, "parent="DFID" stripe=%u", PFID(&ff->ff_parent), stripe);
 183         if (value_len >= sizeof(struct filter_fid_210)) {
 184                 struct filter_fid_210 *ff_new = value;
 185
 186                 fprintf(f, " stripe_size=%u stripe_count=%u",
 187                         ext2fs_le32_to_cpu(ff_new->ff_stripe_size),
 188                         ext2fs_le32_to_cpu(ff_new->ff_stripe_count));
 189                 if (ff_new->ff_pfl_id != 0)
 190                         fprintf(f, " component_id=%u component_start=%llu "
 191                                 "component_end=%llu",
 192                                 ext2fs_le32_to_cpu(ff_new->ff_pfl_id),
 193                                 ext2fs_le64_to_cpu(ff_new->ff_pfl_start),
 194                                 ext2fs_le64_to_cpu(ff_new->ff_pfl_end));
 195         }
 196
 197         if (value_len >= sizeof(struct filter_fid)) {
 198                 struct filter_fid *ff_new = value;
 199
 200                 fprintf(f, " layout_version=%u range=%u",
 201                         ext2fs_le32_to_cpu(ff_new->ff_layout_version),
 202                         ext2fs_le32_to_cpu(ff_new->ff_range));
 203         }
 204
 205         fprintf(f, "\n");
 206
 207         return 0;
 208 }
 209
 210 static int print_lmastr(FILE *f, char *name, void *value, size_t value_len)
 211 {
 212         struct lustre_mdt_attrs *lma = value;
 213         struct lustre_ost_attrs *loa = value;
 214
 215         if (value_len < offsetof(typeof(*lma), lma_self_fid) +
 216                         sizeof(lma->lma_self_fid)) {
 217                 fprintf(stderr, "%s: error: xattr '%s' too small (%zu bytes)\n",
 218                         debug_prog_name, name, value_len);
 219                 return -EINVAL;
 220         }
 221         fid_le_to_cpu(&lma->lma_self_fid, &lma->lma_self_fid);
 222         fprintf(f, "lma: fid="DFID" compat=%x incompat=%x\n",
 223                 PFID(&lma->lma_self_fid), ext2fs_le32_to_cpu(lma->lma_compat),
 224                 ext2fs_le32_to_cpu(lma->lma_incompat));
 225         if (value_len >= offsetof(typeof(*loa), loa_pfl_end) +
 226                   sizeof(loa->loa_pfl_end)) {
 227                 int idx;
 228                 int cnt;
 229
 230                 fid_le_to_cpu(&loa->loa_parent_fid, &loa->loa_parent_fid);
 231                 idx = loa->loa_parent_fid.f_ver & PFID_STRIPE_COUNT_MASK;
 232                 cnt = loa->loa_parent_fid.f_ver >> PFID_STRIPE_IDX_BITS;
 233                 loa->loa_parent_fid.f_ver = 0;
 234
 235                 fprintf(f, "  fid: parent="DFID" stripe=%u stripe_size=%u "
 236                         "stripe_count=%u", PFID(&loa->loa_parent_fid), idx,
 237                         ext2fs_le32_to_cpu(loa->loa_stripe_size), cnt);
 238                 if (loa->loa_pfl_id != 0)
 239                         fprintf(f, " component_id=%u component_start=%llu "
 240                                 "component_end=%llu",
 241                                 ext2fs_le32_to_cpu(loa->loa_pfl_id),
 242                                 ext2fs_le64_to_cpu(loa->loa_pfl_start),
 243                                 ext2fs_le64_to_cpu(loa->loa_pfl_end));
 244                 fprintf(f, "\n");
 245         }
 246
 247         return 0;
 248 }
 249
 250 static void print_name(FILE *f, const char *cp, int len)
 251 {
 252         unsigned char ch;
 253
 254         while (len--) {
 255                 ch = *cp++;
 256                 if (!isprint(ch) || ch == '\\') {
 257                         if (f)
 258                                 fprintf(f, "\\x%02x", ch);
 259                 } else {
 260                         if (f)
 261                                 fputc(ch, f);
 262                 }
 263         }
 264 }
 265
 266 static int print_linkea(FILE *f, char *name, void *value, size_t value_len)
 267 {
 268         struct link_ea_header *leh = value;
 269         struct link_ea_entry *lee;
 270         int i;
 271
 272         if (value_len < sizeof(*leh) ||
 273             value_len < ext2fs_le64_to_cpu(leh->leh_len)) {
 274                 fprintf(stderr, "%s: error: xattr '%s' too small (%zu bytes)\n",
 275                         debug_prog_name, name, value_len);
 276                 return -EINVAL;
 277         }
 278
 279         if (ext2fs_le32_to_cpu(leh->leh_magic) != LINK_EA_MAGIC) {
 280                 fprintf(stderr, "%s: error: xattr '%s' bad magic '%#x'\n",
 281                         debug_prog_name, name,
 282                         ext2fs_le32_to_cpu(leh->leh_magic));
 283                 return -EINVAL;
 284         }
 285
 286         lee = leh->leh_entry;
 287         value_len -= sizeof(*leh);
 288
 289         for (i = 0; i < ext2fs_le32_to_cpu(leh->leh_reccount) &&
 290                     value_len > 2; i++) {
 291                 int reclen = lee->lee_reclen[0] << 8 | lee->lee_reclen[1];
 292                 struct lu_fid pfid;
 293
 294                 if (value_len < sizeof(*lee) || value_len < reclen) {
 295                         fprintf(stderr,
 296                                 "%s: error: xattr '%s' entry %d too small "
 297                                 "(%zu bytes)\n",
 298                                 debug_prog_name, name, i, value_len);
 299                         return -EINVAL;
 300                 }
 301
 302                 memcpy(&pfid, &lee->lee_parent_fid, sizeof(pfid));
 303                 fid_be_to_cpu(&pfid, &pfid);
 304                 fprintf(f, "%s idx=%u parent="DFID" name='",
 305                         i == 0 ? "linkea:" : "         ", i, PFID(&pfid));
 306                 print_name(f, lee->lee_name, reclen - (int)sizeof(*lee));
 307                 fprintf(f, "'\n");
 308
 309                 lee = (struct link_ea_entry *)((char *)lee + reclen);
 310                 value_len -= reclen;
 311         }
 312
 313         return 0;
 314 }
 315
 316 struct dump_attr_pretty {
 317         const char *dap_name;
 318         int (*dap_print)(FILE *f, char *name, void *value, size_t value_len);
 319 } dumpers[] = {
 320         {
 321                 .dap_name = "system.posix_acl_access",
 322                 .dap_print = print_acl,
 323         },
 324         {
 325                 .dap_name = "system.posix_acl_default",
 326                 .dap_print = print_acl,
 327         },
 328         {
 329                 .dap_name = "trusted.fid",
 330                 .dap_print = print_fidstr,
 331         },
 332         {
 333                 .dap_name = "trusted.lma",
 334                 .dap_print = print_lmastr,
 335         },
 336         {
 337                 .dap_name = "trusted.link",
 338                 .dap_print = print_linkea,
 339         },
 340         {
 341                 .dap_name = NULL,
 342         }
 343 };
 344
 345 static int dump_attr(char *name, char *value, size_t value_len,
 346                      ext2_ino_t inode_num, void *data)
 347 {
 348         struct dump_attr_pretty *dap;
 349         FILE *out = data;
 350         int rc = 0;
 351
 352         fprintf(out, "  ");
 353         if (EXT2_HAS_INCOMPAT_FEATURE(current_fs->super,
 354                                       EXT4_FEATURE_INCOMPAT_EA_INODE) &&
 355                                       inode_num != 0) {
 356                 fprintf(out, "inode <%u> ", inode_num);
 357         }
 358
 359         for (dap = dumpers; dap->dap_name != NULL; dap++) {
 360                 if (strcmp(name, dap->dap_name) == 0) {
 361                         rc = dap->dap_print(out, name, value, value_len);
 362                         break;
 363                 }
 364         }
 365         if (dap->dap_name == NULL || rc)
 366                 print_xattr(out, name, value, value_len, PRINT_XATTR_STATFMT);
 367
 368         return 0;
 369 }
 370
 371 void dump_inode_attributes(FILE *out, ext2_ino_t ino)
 372 {
 373         struct ext2_xattr_handle *h;
 374         size_t sz;
 375         errcode_t err;
 376
 377         err = ext2fs_xattrs_open(current_fs, ino, &h);
 378         if (err)
 379                 return;
 380
 381         err = ext2fs_xattrs_read(h);
 382         if (err)
 383                 goto out;
 384
 385         err = ext2fs_xattrs_count(h, &sz);
 386         if (err || sz == 0)
 387                 goto out;
 388
 389         fprintf(out, "Extended attributes:\n");
 390         err = ext2fs_xattrs_iterate(h, dump_attr, out);
 391         if (err)
 392                 goto out;
 393
 394 out:
 395         err = ext2fs_xattrs_close(&h);
 396 }
 397
 398 void do_list_xattr(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
 399                    void *infop EXT2FS_ATTR((unused)))
 400 {
 401         ext2_ino_t ino;
 402
 403         if (argc != 2) {
 404                 printf("%s: Usage: %s <file>\n", argv[0],
 405                        argv[0]);
 406                 return;
 407         }
 408
 409         if (check_fs_open(argv[0]))
 410                 return;
 411
 412         ino = string_to_inode(argv[1]);
 413         if (!ino)
 414                 return;
 415
 416         dump_inode_attributes(stdout, ino);
 417 }
 418
 419 void do_get_xattr(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
 420                   void *infop EXT2FS_ATTR((unused)))
 421 {
 422         ext2_ino_t ino;
 423         struct ext2_xattr_handle *h;
 424         FILE *fp = NULL;
 425         char *buf = NULL;
 426         size_t buflen;
 427         int i;
 428         int print_flags = 0;
 429         unsigned int handle_flags = 0;
 430         errcode_t err;
 431
 432         reset_getopt();
 433         while ((i = getopt(argc, argv, "Cf:rxV")) != -1) {
 434                 switch (i) {
 435                 case 'f':
 436                         if (fp)
 437                                 fclose(fp);
 438                         fp = fopen(optarg, "w");
 439                         if (fp == NULL) {
 440                                 perror(optarg);
 441                                 return;
 442                         }
 443                         break;
 444                 case 'r':
 445                         handle_flags |= XATTR_HANDLE_FLAG_RAW;
 446                         break;
 447                 case 'x':
 448                         print_flags |= PRINT_XATTR_HEX;
 449                         break;
 450                 case 'V':
 451                         print_flags |= PRINT_XATTR_RAW|
 452                                 PRINT_XATTR_NOQUOTES;
 453                         break;
 454                 case 'C':
 455                         print_flags |= PRINT_XATTR_C;
 456                         break;
 457                 default:
 458                         goto usage;
 459                 }
 460         }
 461
 462         if (optind != argc - 2) {
 463         usage:
 464                 printf("%s: Usage: %s [-f outfile]|[-xVC] [-r] <file> <attr>\n",
 465                                argv[0], argv[0]);
 466
 467                 goto out2;
 468         }
 469
 470         if (check_fs_open(argv[0]))
 471                 goto out2;
 472
 473         ino = string_to_inode(argv[optind]);
 474         if (!ino)
 475                 goto out2;
 476
 477         err = ext2fs_xattrs_open(current_fs, ino, &h);
 478         if (err)
 479                 goto out2;
 480
 481         err = ext2fs_xattrs_flags(h, &handle_flags, NULL);
 482         if (err)
 483                 goto out;
 484
 485         err = ext2fs_xattrs_read(h);
 486         if (err)
 487                 goto out;
 488
 489         err = ext2fs_xattr_get(h, argv[optind + 1], (void **)&buf, &buflen);
 490         if (err)
 491                 goto out;
 492
 493         if (fp) {
 494                 fwrite(buf, buflen, 1, fp);
 495         } else {
 496                 if (print_flags & PRINT_XATTR_RAW) {
 497                         if (print_flags & (PRINT_XATTR_HEX|PRINT_XATTR_C))
 498                                 print_flags &= ~PRINT_XATTR_RAW;
 499                         print_xattr_string(stdout, buf, buflen, print_flags);
 500                 } else {
 501                         print_xattr(stdout, argv[optind + 1],
 502                                     buf, buflen, print_flags);
 503                 }
 504                 printf("\n");
 505         }
 506
 507         ext2fs_free_mem(&buf);
 508 out:
 509         ext2fs_xattrs_close(&h);
 510         if (err)
 511                 com_err(argv[0], err, "while getting extended attribute");
 512 out2:
 513         if (fp)
 514                 fclose(fp);
 515 }
 516
 517 void do_set_xattr(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
 518                   void *infop EXT2FS_ATTR((unused)))
 519 {
 520         ext2_ino_t ino;
 521         struct ext2_xattr_handle *h;
 522         FILE *fp = NULL;
 523         char *buf = NULL;
 524         size_t buflen;
 525         unsigned int handle_flags = 0;
 526         int i;
 527         errcode_t err;
 528
 529         reset_getopt();
 530         while ((i = getopt(argc, argv, "f:r")) != -1) {
 531                 switch (i) {
 532                 case 'f':
 533                         if (fp)
 534                                 fclose(fp);
 535                         fp = fopen(optarg, "r");
 536                         if (fp == NULL) {
 537                                 perror(optarg);
 538                                 return;
 539                         }
 540                         break;
 541                 case 'r':
 542                         handle_flags |= XATTR_HANDLE_FLAG_RAW;
 543                         break;
 544                 default:
 545                         goto print_usage;
 546                 }
 547         }
 548
 549         if (!(fp && optind == argc - 2) && !(!fp && optind == argc - 3)) {
 550         print_usage:
 551                 printf("Usage:\t%s [-r] <file> <attr> <value>\n", argv[0]);
 552                 printf("\t%s -f <value_file> [-r] <file> <attr>\n", argv[0]);
 553                 goto out2;
 554         }
 555
 556         if (check_fs_open(argv[0]))
 557                 goto out2;
 558         if (check_fs_read_write(argv[0]))
 559                 goto out2;
 560         if (check_fs_bitmaps(argv[0]))
 561                 goto out2;
 562
 563         ino = string_to_inode(argv[optind]);
 564         if (!ino)
 565                 goto out2;
 566
 567         err = ext2fs_xattrs_open(current_fs, ino, &h);
 568         if (err)
 569                 goto out2;
 570
 571         err = ext2fs_xattrs_flags(h, &handle_flags, NULL);
 572         if (err)
 573                 goto out;
 574
 575         err = ext2fs_xattrs_read(h);
 576         if (err)
 577                 goto out;
 578
 579         if (fp) {
 580                 err = ext2fs_get_mem(current_fs->blocksize, &buf);
 581                 if (err)
 582                         goto out;
 583                 buflen = fread(buf, 1, current_fs->blocksize, fp);
 584         } else {
 585                 buf = argv[optind + 2];
 586                 buflen = parse_c_string(buf);
 587         }
 588
 589         err = ext2fs_xattr_set(h, argv[optind + 1], buf, buflen);
 590 out:
 591         ext2fs_xattrs_close(&h);
 592         if (err)
 593                 com_err(argv[0], err, "while setting extended attribute");
 594 out2:
 595         if (fp) {
 596                 fclose(fp);
 597                 ext2fs_free_mem(&buf);
 598         }
 599 }
 600
 601 void do_rm_xattr(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
 602                  void *infop EXT2FS_ATTR((unused)))
 603 {
 604         ext2_ino_t ino;
 605         struct ext2_xattr_handle *h;
 606         int i;
 607         errcode_t err;
 608
 609         if (argc < 3) {
 610                 printf("%s: Usage: %s <file> <attrs>...\n", argv[0], argv[0]);
 611                 return;
 612         }
 613
 614         if (check_fs_open(argv[0]))
 615                 return;
 616         if (check_fs_read_write(argv[0]))
 617                 return;
 618         if (check_fs_bitmaps(argv[0]))
 619                 return;
 620
 621         ino = string_to_inode(argv[1]);
 622         if (!ino)
 623                 return;
 624
 625         err = ext2fs_xattrs_open(current_fs, ino, &h);
 626         if (err)
 627                 return;
 628
 629         err = ext2fs_xattrs_read(h);
 630         if (err)
 631                 goto out;
 632
 633         for (i = 2; i < argc; i++) {
 634                 err = ext2fs_xattr_remove(h, argv[i]);
 635                 if (err)
 636                         goto out;
 637         }
 638 out:
 639         ext2fs_xattrs_close(&h);
 640         if (err)
 641                 com_err(argv[0], err, "while removing extended attribute");
 642 }
 643
 644 /*
 645  * Return non-zero if the string has a minimal number of non-printable
 646  * characters.
 647  */
 648 static int is_mostly_printable(const char *cp, int len)
 649 {
 650         int     np = 0;
 651
 652         if (len < 0)
 653                 len = strlen(cp);
 654
 655         while (len--) {
 656                 if (!isprint(*cp++)) {
 657                         np++;
 658                         if (np > 3)
 659                                 return 0;
 660                 }
 661         }
 662         return 1;
 663 }
 664
 665 static void safe_print(FILE *f, const char *cp, int len)
 666 {
 667         unsigned char   ch;
 668
 669         if (len < 0)
 670                 len = strlen(cp);
 671
 672         while (len--) {
 673                 ch = *cp++;
 674                 if (ch > 128) {
 675                         fputs("M-", f);
 676                         ch -= 128;
 677                 }
 678                 if ((ch < 32) || (ch == 0x7f)) {
 679                         fputc('^', f);
 680                         ch ^= 0x40; /* ^@, ^A, ^B; ^? for DEL */
 681                 }
 682                 fputc(ch, f);
 683         }
 684 }
 685
 686 static void dump_xattr_raw_entries(FILE *f, unsigned char *buf,
 687                                    unsigned int start, unsigned int len,
 688                                    unsigned value_start)
 689 {
 690         struct ext2_ext_attr_entry ent;
 691         unsigned int off = start;
 692         unsigned int vstart;
 693
 694         while (off < len) {
 695                 if ((*(__u16 *) (buf + off)) == 0) {
 696                         fprintf(f, "last entry found at offset %u (%04o)\n",
 697                                 off, off);
 698                         break;
 699                 }
 700                 if ((off + sizeof(struct ext2_ext_attr_entry)) >= len) {
 701                         fprintf(f, "xattr buffer overrun at %u (len = %u)\n",
 702                                 off, len);
 703                         break;
 704                 }
 705 #if WORDS_BIGENDIAN
 706                 ext2fs_swap_ext_attr_entry(&ent,
 707                         (struct ext2_ext_attr_entry *) (buf + off));
 708 #else
 709                 ent = *((struct ext2_ext_attr_entry *) (buf + off));
 710 #endif
 711                 fprintf(f, "offset = %d (%04o), name_len = %u, "
 712                         "name_index = %u\n",
 713                         off, off, ent.e_name_len, ent.e_name_index);
 714                 vstart = value_start + ent.e_value_offs;
 715                 fprintf(f, "value_offset = %d (%04o), value_inum = %u, "
 716                         "value_size = %u\n", ent.e_value_offs,
 717                         vstart, ent.e_value_inum, ent.e_value_size);
 718                 off += sizeof(struct ext2_ext_attr_entry);
 719                 fprintf(f, "name = ");
 720                 if ((off + ent.e_name_len) >= len)
 721                         fprintf(f, "<runs off end>");
 722                 else
 723                         safe_print(f, (char *)(buf + off), ent.e_name_len);
 724                 fputc('\n', f);
 725                 if (ent.e_value_size == 0)
 726                         goto skip_value;
 727                 fprintf(f, "value = ");
 728                 if (ent.e_value_inum)
 729                         fprintf(f, "<ino %u>", ent.e_value_inum);
 730                 else if (ent.e_value_offs >= len ||
 731                          (vstart + ent.e_value_size) > len)
 732                         fprintf(f, "<runs off end>");
 733                 else if (is_mostly_printable((char *)(buf + vstart),
 734                                         ent.e_value_size))
 735                         safe_print(f, (char *)(buf + vstart),
 736                                    ent.e_value_size);
 737                 else {
 738                         fprintf(f, "<hexdump>\n");
 739                         do_byte_hexdump(f, (unsigned char *)(buf + vstart),
 740                                         ent.e_value_size);
 741                 }
 742                 fputc('\n', f);
 743         skip_value:
 744                 fputc('\n', f);
 745                 off += (ent.e_name_len + 3) & ~3;
 746         }
 747 }
 748
 749 void raw_inode_xattr_dump(FILE *f, unsigned char *buf, unsigned int len)
 750 {
 751         __u32 magic = ext2fs_le32_to_cpu(*((__le32 *) buf));
 752
 753         fprintf(f, "magic = %08x, length = %u, value_start =4 \n\n",
 754                 magic, len);
 755         if (magic == EXT2_EXT_ATTR_MAGIC)
 756                 dump_xattr_raw_entries(f, buf, 4, len, 4);
 757 }
 758
 759 void block_xattr_dump(FILE *f, unsigned char *buf, unsigned int len)
 760 {
 761         struct ext2_ext_attr_header header;
 762
 763 #ifdef WORDS_BIGENDIAN
 764         ext2fs_swap_ext_attr_header(&header,
 765                                     (struct ext2_ext_attr_header *) buf);
 766 #else
 767         header = *((struct ext2_ext_attr_header *) buf);
 768 #endif
 769         fprintf(f, "magic = %08x, length = %u\n", header.h_magic, len);
 770         if (header.h_magic != EXT2_EXT_ATTR_MAGIC)
 771                 return;
 772         fprintf(f, "refcount = %u, blocks = %u\n", header.h_refcount,
 773                 header.h_blocks);
 774         fprintf(f, "hash = %08x, checksum = %08x\n", header.h_hash,
 775                 header.h_checksum);
 776         fprintf(f, "reserved: %08x %08x %08x\n\n", header.h_reserved[0],
 777                 header.h_reserved[1], header.h_reserved[2]);
 778
 779         dump_xattr_raw_entries(f, buf,
 780                                sizeof(struct ext2_ext_attr_header), len, 0);
 781 }