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)
 121 {
 122         ext2_ino_t ino;
 123
 124         if (argc != 2) {
 125                 printf("%s: Usage: %s <file>\n", argv[0],
 126                        argv[0]);
 127                 return;
 128         }
 129
 130         if (check_fs_open(argv[0]))
 131                 return;
 132
 133         ino = string_to_inode(argv[1]);
 134         if (!ino)
 135                 return;
 136
 137         dump_inode_attributes(stdout, ino);
 138 }
 139
 140 void do_get_xattr(int argc, char **argv)
 141 {
 142         ext2_ino_t ino;
 143         struct ext2_xattr_handle *h;
 144         FILE *fp = NULL;
 145         char *buf = NULL;
 146         size_t buflen;
 147         int i;
 148         int print_flags = 0;
 149         errcode_t err;
 150
 151         reset_getopt();
 152         while ((i = getopt(argc, argv, "Cf:xV")) != -1) {
 153                 switch (i) {
 154                 case 'f':
 155                         if (fp)
 156                                 fclose(fp);
 157                         fp = fopen(optarg, "w");
 158                         if (fp == NULL) {
 159                                 perror(optarg);
 160                                 return;
 161                         }
 162                         break;
 163                 case 'x':
 164                         print_flags |= PRINT_XATTR_HEX;
 165                         break;
 166                 case 'V':
 167                         print_flags |= PRINT_XATTR_RAW;
 168                         break;
 169                 case 'C':
 170                         print_flags |= PRINT_XATTR_C;
 171                         break;
 172                 default:
 173                         goto usage;
 174                 }
 175         }
 176
 177         if (optind != argc - 2) {
 178         usage:
 179                 printf("%s: Usage: %s <file> <attr> [-f outfile]|[-xVC]\n",
 180                                argv[0], argv[0]);
 181                 goto out2;
 182         }
 183
 184         if (check_fs_open(argv[0]))
 185                 goto out2;
 186
 187         ino = string_to_inode(argv[optind]);
 188         if (!ino)
 189                 goto out2;
 190
 191         err = ext2fs_xattrs_open(current_fs, ino, &h);
 192         if (err)
 193                 goto out2;
 194
 195         err = ext2fs_xattrs_read(h);
 196         if (err)
 197                 goto out;
 198
 199         err = ext2fs_xattr_get(h, argv[optind + 1], (void **)&buf, &buflen);
 200         if (err)
 201                 goto out;
 202
 203         if (fp) {
 204                 fwrite(buf, buflen, 1, fp);
 205         } else {
 206                 if (print_flags & PRINT_XATTR_RAW) {
 207                         if (print_flags & PRINT_XATTR_HEX|PRINT_XATTR_C)
 208                                 print_flags &= ~PRINT_XATTR_RAW;
 209                         print_xattr_string(stdout, buf, buflen, print_flags);
 210                 } else {
 211                         print_xattr(stdout, argv[optind + 1],
 212                                     buf, buflen, print_flags);
 213                 }
 214                 printf("\n");
 215         }
 216
 217         ext2fs_free_mem(&buf);
 218 out:
 219         ext2fs_xattrs_close(&h);
 220         if (err)
 221                 com_err(argv[0], err, "while getting extended attribute");
 222 out2:
 223         if (fp)
 224                 fclose(fp);
 225 }
 226
 227 void do_set_xattr(int argc, char **argv)
 228 {
 229         ext2_ino_t ino;
 230         struct ext2_xattr_handle *h;
 231         FILE *fp = NULL;
 232         char *buf = NULL;
 233         size_t buflen;
 234         int i;
 235         errcode_t err;
 236
 237         reset_getopt();
 238         while ((i = getopt(argc, argv, "f:")) != -1) {
 239                 switch (i) {
 240                 case 'f':
 241                         if (fp)
 242                                 fclose(fp);
 243                         fp = fopen(optarg, "r");
 244                         if (fp == NULL) {
 245                                 perror(optarg);
 246                                 return;
 247                         }
 248                         break;
 249                 default:
 250                         goto print_usage;
 251                 }
 252         }
 253
 254         if (!(fp && optind == argc - 2) && !(!fp && optind == argc - 3)) {
 255         print_usage:
 256                 printf("Usage:\t%s <file> <attr> <value>\n", argv[0]);
 257                 printf("\t%s -f <value_file> <file> <attr>\n", argv[0]);
 258                 goto out2;
 259         }
 260
 261         if (check_fs_open(argv[0]))
 262                 goto out2;
 263         if (check_fs_read_write(argv[0]))
 264                 goto out2;
 265         if (check_fs_bitmaps(argv[0]))
 266                 goto out2;
 267
 268         ino = string_to_inode(argv[optind]);
 269         if (!ino)
 270                 goto out2;
 271
 272         err = ext2fs_xattrs_open(current_fs, ino, &h);
 273         if (err)
 274                 goto out2;
 275
 276         err = ext2fs_xattrs_read(h);
 277         if (err)
 278                 goto out;
 279
 280         if (fp) {
 281                 err = ext2fs_get_mem(current_fs->blocksize, &buf);
 282                 if (err)
 283                         goto out;
 284                 buflen = fread(buf, 1, current_fs->blocksize, fp);
 285         } else {
 286                 buf = argv[optind + 2];
 287                 buflen = parse_c_string(buf);
 288         }
 289
 290         err = ext2fs_xattr_set(h, argv[optind + 1], buf, buflen);
 291         if (err)
 292                 goto out;
 293
 294         err = ext2fs_xattrs_write(h);
 295         if (err)
 296                 goto out;
 297
 298 out:
 299         ext2fs_xattrs_close(&h);
 300         if (err)
 301                 com_err(argv[0], err, "while setting extended attribute");
 302 out2:
 303         if (fp) {
 304                 fclose(fp);
 305                 ext2fs_free_mem(&buf);
 306         }
 307 }
 308
 309 void do_rm_xattr(int argc, char **argv)
 310 {
 311         ext2_ino_t ino;
 312         struct ext2_xattr_handle *h;
 313         int i;
 314         errcode_t err;
 315
 316         if (argc < 3) {
 317                 printf("%s: Usage: %s <file> <attrs>...\n", argv[0], argv[0]);
 318                 return;
 319         }
 320
 321         if (check_fs_open(argv[0]))
 322                 return;
 323         if (check_fs_read_write(argv[0]))
 324                 return;
 325         if (check_fs_bitmaps(argv[0]))
 326                 return;
 327
 328         ino = string_to_inode(argv[1]);
 329         if (!ino)
 330                 return;
 331
 332         err = ext2fs_xattrs_open(current_fs, ino, &h);
 333         if (err)
 334                 return;
 335
 336         err = ext2fs_xattrs_read(h);
 337         if (err)
 338                 goto out;
 339
 340         for (i = 2; i < argc; i++) {
 341                 err = ext2fs_xattr_remove(h, argv[i]);
 342                 if (err)
 343                         goto out;
 344         }
 345
 346         err = ext2fs_xattrs_write(h);
 347         if (err)
 348                 goto out;
 349 out:
 350         ext2fs_xattrs_close(&h);
 351         if (err)
 352                 com_err(argv[0], err, "while removing extended attribute");
 353 }