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
  21 #define PRINT_XATTR_HEX         0x01
  22 #define PRINT_XATTR_RAW         0x02
  23 #define PRINT_XATTR_C           0x04
  24 #define PRINT_XATTR_STATFMT     0x08
  25 #define PRINT_XATTR_NOQUOTES    0x10
  26
  27 /* Dump extended attributes */
  28 static void print_xattr_hex(FILE *f, const char *str, int len)
  29 {
  30         int i;
  31
  32         for (i = 0; i < len; i++)
  33                 fprintf(f, "%02x ", (unsigned char)str[i]);
  34 }
  35
  36 /* Dump extended attributes */
  37 static void print_xattr_string(FILE *f, const char *str, int len, int flags)
  38 {
  39         int printable = 0;
  40         int i;
  41
  42         if (flags & PRINT_XATTR_RAW) {
  43                 fwrite(str, len, 1, f);
  44                 return;
  45         }
  46
  47         if ((flags & PRINT_XATTR_C) == 0) {
  48                 /* check: is string "printable enough?" */
  49                 for (i = 0; i < len; i++)
  50                         if (isprint(str[i]))
  51                                 printable++;
  52
  53                 if (printable <= len*7/8)
  54                         flags |= PRINT_XATTR_HEX;
  55         }
  56
  57         if (flags & PRINT_XATTR_HEX) {
  58                 print_xattr_hex(f, str, len);
  59         } else {
  60                 if ((flags & PRINT_XATTR_NOQUOTES) == 0)
  61                         fputc('\"', f);
  62                 print_c_string(f, str, len);
  63                 if ((flags & PRINT_XATTR_NOQUOTES) == 0)
  64                         fputc('\"', f);
  65         }
  66 }
  67
  68 static void print_xattr(FILE *f, char *name, char *value, size_t value_len,
  69                         int print_flags)
  70 {
  71         print_xattr_string(f, name, strlen(name), PRINT_XATTR_NOQUOTES);
  72         fprintf(f, " (%zu)", value_len);
  73         if ((print_flags & PRINT_XATTR_STATFMT) &&
  74             (strcmp(name, "system.data") == 0))
  75                 value_len = 0;
  76         if (value_len != 0 &&
  77             (!(print_flags & PRINT_XATTR_STATFMT) || (value_len < 40))) {
  78                 fprintf(f, " = ");
  79                 print_xattr_string(f, value, value_len, print_flags);
  80         }
  81         fputc('\n', f);
  82 }
  83
  84 static int dump_attr(char *name, char *value, size_t value_len, void *data)
  85 {
  86         FILE *out = data;
  87
  88         fprintf(out, "  ");
  89         print_xattr(out, name, value, value_len, PRINT_XATTR_STATFMT);
  90         return 0;
  91 }
  92
  93 void dump_inode_attributes(FILE *out, ext2_ino_t ino)
  94 {
  95         struct ext2_xattr_handle *h;
  96         size_t sz;
  97         errcode_t err;
  98
  99         err = ext2fs_xattrs_open(current_fs, ino, &h);
 100         if (err)
 101                 return;
 102
 103         err = ext2fs_xattrs_read(h);
 104         if (err)
 105                 goto out;
 106
 107         err = ext2fs_xattrs_count(h, &sz);
 108         if (err || sz == 0)
 109                 goto out;
 110
 111         fprintf(out, "Extended attributes:\n");
 112         err = ext2fs_xattrs_iterate(h, dump_attr, out);
 113         if (err)
 114                 goto out;
 115
 116 out:
 117         err = ext2fs_xattrs_close(&h);
 118 }
 119
 120 void do_list_xattr(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
 121                    void *infop EXT2FS_ATTR((unused)))
 122 {
 123         ext2_ino_t ino;
 124
 125         if (argc != 2) {
 126                 printf("%s: Usage: %s <file>\n", argv[0],
 127                        argv[0]);
 128                 return;
 129         }
 130
 131         if (check_fs_open(argv[0]))
 132                 return;
 133
 134         ino = string_to_inode(argv[1]);
 135         if (!ino)
 136                 return;
 137
 138         dump_inode_attributes(stdout, ino);
 139 }
 140
 141 void do_get_xattr(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
 142                   void *infop EXT2FS_ATTR((unused)))
 143 {
 144         ext2_ino_t ino;
 145         struct ext2_xattr_handle *h;
 146         FILE *fp = NULL;
 147         char *buf = NULL;
 148         size_t buflen;
 149         int i;
 150         int print_flags = 0;
 151         unsigned int handle_flags = 0;
 152         errcode_t err;
 153
 154         reset_getopt();
 155         while ((i = getopt(argc, argv, "Cf:rxV")) != -1) {
 156                 switch (i) {
 157                 case 'f':
 158                         if (fp)
 159                                 fclose(fp);
 160                         fp = fopen(optarg, "w");
 161                         if (fp == NULL) {
 162                                 perror(optarg);
 163                                 return;
 164                         }
 165                         break;
 166                 case 'r':
 167                         handle_flags |= XATTR_HANDLE_FLAG_RAW;
 168                         break;
 169                 case 'x':
 170                         print_flags |= PRINT_XATTR_HEX;
 171                         break;
 172                 case 'V':
 173                         print_flags |= PRINT_XATTR_RAW|
 174                                 PRINT_XATTR_NOQUOTES;
 175                         break;
 176                 case 'C':
 177                         print_flags |= PRINT_XATTR_C;
 178                         break;
 179                 default:
 180                         goto usage;
 181                 }
 182         }
 183
 184         if (optind != argc - 2) {
 185         usage:
 186                 printf("%s: Usage: %s [-f outfile]|[-xVC] [-r] <file> <attr>\n",
 187                                argv[0], argv[0]);
 188
 189                 goto out2;
 190         }
 191
 192         if (check_fs_open(argv[0]))
 193                 goto out2;
 194
 195         ino = string_to_inode(argv[optind]);
 196         if (!ino)
 197                 goto out2;
 198
 199         err = ext2fs_xattrs_open(current_fs, ino, &h);
 200         if (err)
 201                 goto out2;
 202
 203         err = ext2fs_xattrs_flags(h, &handle_flags, NULL);
 204         if (err)
 205                 goto out;
 206
 207         err = ext2fs_xattrs_read(h);
 208         if (err)
 209                 goto out;
 210
 211         err = ext2fs_xattr_get(h, argv[optind + 1], (void **)&buf, &buflen);
 212         if (err)
 213                 goto out;
 214
 215         if (fp) {
 216                 fwrite(buf, buflen, 1, fp);
 217         } else {
 218                 if (print_flags & PRINT_XATTR_RAW) {
 219                         if (print_flags & (PRINT_XATTR_HEX|PRINT_XATTR_C))
 220                                 print_flags &= ~PRINT_XATTR_RAW;
 221                         print_xattr_string(stdout, buf, buflen, print_flags);
 222                 } else {
 223                         print_xattr(stdout, argv[optind + 1],
 224                                     buf, buflen, print_flags);
 225                 }
 226                 printf("\n");
 227         }
 228
 229         ext2fs_free_mem(&buf);
 230 out:
 231         ext2fs_xattrs_close(&h);
 232         if (err)
 233                 com_err(argv[0], err, "while getting extended attribute");
 234 out2:
 235         if (fp)
 236                 fclose(fp);
 237 }
 238
 239 void do_set_xattr(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
 240                   void *infop EXT2FS_ATTR((unused)))
 241 {
 242         ext2_ino_t ino;
 243         struct ext2_xattr_handle *h;
 244         FILE *fp = NULL;
 245         char *buf = NULL;
 246         size_t buflen;
 247         unsigned int handle_flags = 0;
 248         int i;
 249         errcode_t err;
 250
 251         reset_getopt();
 252         while ((i = getopt(argc, argv, "f:r")) != -1) {
 253                 switch (i) {
 254                 case 'f':
 255                         if (fp)
 256                                 fclose(fp);
 257                         fp = fopen(optarg, "r");
 258                         if (fp == NULL) {
 259                                 perror(optarg);
 260                                 return;
 261                         }
 262                         break;
 263                 case 'r':
 264                         handle_flags |= XATTR_HANDLE_FLAG_RAW;
 265                         break;
 266                 default:
 267                         goto print_usage;
 268                 }
 269         }
 270
 271         if (!(fp && optind == argc - 2) && !(!fp && optind == argc - 3)) {
 272         print_usage:
 273                 printf("Usage:\t%s [-r] <file> <attr> <value>\n", argv[0]);
 274                 printf("\t%s -f <value_file> [-r] <file> <attr>\n", argv[0]);
 275                 goto out2;
 276         }
 277
 278         if (check_fs_open(argv[0]))
 279                 goto out2;
 280         if (check_fs_read_write(argv[0]))
 281                 goto out2;
 282         if (check_fs_bitmaps(argv[0]))
 283                 goto out2;
 284
 285         ino = string_to_inode(argv[optind]);
 286         if (!ino)
 287                 goto out2;
 288
 289         err = ext2fs_xattrs_open(current_fs, ino, &h);
 290         if (err)
 291                 goto out2;
 292
 293         err = ext2fs_xattrs_flags(h, &handle_flags, NULL);
 294         if (err)
 295                 goto out;
 296
 297         err = ext2fs_xattrs_read(h);
 298         if (err)
 299                 goto out;
 300
 301         if (fp) {
 302                 err = ext2fs_get_mem(current_fs->blocksize, &buf);
 303                 if (err)
 304                         goto out;
 305                 buflen = fread(buf, 1, current_fs->blocksize, fp);
 306         } else {
 307                 buf = argv[optind + 2];
 308                 buflen = parse_c_string(buf);
 309         }
 310
 311         err = ext2fs_xattr_set(h, argv[optind + 1], buf, buflen);
 312 out:
 313         ext2fs_xattrs_close(&h);
 314         if (err)
 315                 com_err(argv[0], err, "while setting extended attribute");
 316 out2:
 317         if (fp) {
 318                 fclose(fp);
 319                 ext2fs_free_mem(&buf);
 320         }
 321 }
 322
 323 void do_rm_xattr(int argc, char **argv, int sci_idx EXT2FS_ATTR((unused)),
 324                  void *infop EXT2FS_ATTR((unused)))
 325 {
 326         ext2_ino_t ino;
 327         struct ext2_xattr_handle *h;
 328         int i;
 329         errcode_t err;
 330
 331         if (argc < 3) {
 332                 printf("%s: Usage: %s <file> <attrs>...\n", argv[0], argv[0]);
 333                 return;
 334         }
 335
 336         if (check_fs_open(argv[0]))
 337                 return;
 338         if (check_fs_read_write(argv[0]))
 339                 return;
 340         if (check_fs_bitmaps(argv[0]))
 341                 return;
 342
 343         ino = string_to_inode(argv[1]);
 344         if (!ino)
 345                 return;
 346
 347         err = ext2fs_xattrs_open(current_fs, ino, &h);
 348         if (err)
 349                 return;
 350
 351         err = ext2fs_xattrs_read(h);
 352         if (err)
 353                 goto out;
 354
 355         for (i = 2; i < argc; i++) {
 356                 err = ext2fs_xattr_remove(h, argv[i]);
 357                 if (err)
 358                         goto out;
 359         }
 360 out:
 361         ext2fs_xattrs_close(&h);
 362         if (err)
 363                 com_err(argv[0], err, "while removing extended attribute");
 364 }
 365
 366 /*
 367  * Return non-zero if the string has a minimal number of non-printable
 368  * characters.
 369  */
 370 static int is_mostly_printable(const char *cp, int len)
 371 {
 372         int     np = 0;
 373
 374         if (len < 0)
 375                 len = strlen(cp);
 376
 377         while (len--) {
 378                 if (!isprint(*cp++)) {
 379                         np++;
 380                         if (np > 3)
 381                                 return 0;
 382                 }
 383         }
 384         return 1;
 385 }
 386
 387 static void safe_print(FILE *f, const char *cp, int len)
 388 {
 389         unsigned char   ch;
 390
 391         if (len < 0)
 392                 len = strlen(cp);
 393
 394         while (len--) {
 395                 ch = *cp++;
 396                 if (ch > 128) {
 397                         fputs("M-", f);
 398                         ch -= 128;
 399                 }
 400                 if ((ch < 32) || (ch == 0x7f)) {
 401                         fputc('^', f);
 402                         ch ^= 0x40; /* ^@, ^A, ^B; ^? for DEL */
 403                 }
 404                 fputc(ch, f);
 405         }
 406 }
 407
 408 static void dump_xattr_raw_entries(FILE *f, unsigned char *buf,
 409                                    unsigned int start, unsigned int len,
 410                                    unsigned value_start)
 411 {
 412         struct ext2_ext_attr_entry ent;
 413         unsigned int off = start;
 414         unsigned int vstart;
 415
 416         while (off < len) {
 417                 if ((*(__u16 *) (buf + off)) == 0) {
 418                         fprintf(f, "last entry found at offset %u (%04o)\n",
 419                                 off, off);
 420                         break;
 421                 }
 422                 if ((off + sizeof(struct ext2_ext_attr_entry)) >= len) {
 423                         fprintf(f, "xattr buffer overrun at %u (len = %u)\n",
 424                                 off, len);
 425                         break;
 426                 }
 427 #if WORDS_BIGENDIAN
 428                 ext2fs_swap_ext_attr_entry(&ent,
 429                         (struct ext2_ext_attr_entry *) (buf + off));
 430 #else
 431                 ent = *((struct ext2_ext_attr_entry *) (buf + off));
 432 #endif
 433                 fprintf(f, "offset = %d (%04o), hash = %u, name_len = %u, "
 434                         "name_index = %u\n",
 435                         off, off, ent.e_hash, ent.e_name_len, ent.e_name_index);
 436                 vstart = value_start + ent.e_value_offs;
 437                 fprintf(f, "value_offset = %d (%04o), value_inum = %u, "
 438                         "value_size = %u\n", ent.e_value_offs,
 439                         vstart, ent.e_value_inum, ent.e_value_size);
 440                 off += sizeof(struct ext2_ext_attr_entry);
 441                 fprintf(f, "name = ");
 442                 if ((off + ent.e_name_len) >= len)
 443                         fprintf(f, "<runs off end>");
 444                 else
 445                         safe_print(f, (char *)(buf + off), ent.e_name_len);
 446                 fputc('\n', f);
 447                 if (ent.e_value_size == 0)
 448                         goto skip_value;
 449                 fprintf(f, "value = ");
 450                 if (ent.e_value_inum)
 451                         fprintf(f, "<ino %u>", ent.e_value_inum);
 452                 else if (ent.e_value_offs >= len ||
 453                          (vstart + ent.e_value_size) > len)
 454                         fprintf(f, "<runs off end>");
 455                 else if (is_mostly_printable((char *)(buf + vstart),
 456                                         ent.e_value_size))
 457                         safe_print(f, (char *)(buf + vstart),
 458                                    ent.e_value_size);
 459                 else {
 460                         fprintf(f, "<hexdump>\n");
 461                         do_byte_hexdump(f, (unsigned char *)(buf + vstart),
 462                                         ent.e_value_size);
 463                 }
 464                 fputc('\n', f);
 465         skip_value:
 466                 fputc('\n', f);
 467                 off += (ent.e_name_len + 3) & ~3;
 468         }
 469 }
 470
 471 void raw_inode_xattr_dump(FILE *f, unsigned char *buf, unsigned int len)
 472 {
 473         __u32 magic = ext2fs_le32_to_cpu(*((__le32 *) buf));
 474
 475         fprintf(f, "magic = %08x, length = %u, value_start =4 \n\n",
 476                 magic, len);
 477         if (magic == EXT2_EXT_ATTR_MAGIC)
 478                 dump_xattr_raw_entries(f, buf, 4, len, 4);
 479 }
 480
 481 void block_xattr_dump(FILE *f, unsigned char *buf, unsigned int len)
 482 {
 483         struct ext2_ext_attr_header header;
 484
 485 #ifdef WORDS_BIGENDIAN
 486         ext2fs_swap_ext_attr_header(&header,
 487                                     (struct ext2_ext_attr_header *) buf);
 488 #else
 489         header = *((struct ext2_ext_attr_header *) buf);
 490 #endif
 491         fprintf(f, "magic = %08x, length = %u\n", header.h_magic, len);
 492         if (header.h_magic != EXT2_EXT_ATTR_MAGIC)
 493                 return;
 494         fprintf(f, "refcount = %u, blocks = %u\n", header.h_refcount,
 495                 header.h_blocks);
 496         fprintf(f, "hash = %08x, checksum = %08x\n", header.h_hash,
 497                 header.h_checksum);
 498         fprintf(f, "reserved: %08x %08x %08x\n\n", header.h_reserved[0],
 499                 header.h_reserved[1], header.h_reserved[2]);
 500
 501         dump_xattr_raw_entries(f, buf,
 502                                sizeof(struct ext2_ext_attr_header), len, 0);
 503 }