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 */
print_xattr_hex(FILE * f,const char * str,int len)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 */
print_xattr_string(FILE * f,const char * str,int len,int flags)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
print_xattr(FILE * f,char * name,char * value,size_t value_len,int print_flags)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
dump_attr(char * name,char * value,size_t value_len,void * data)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
dump_inode_attributes(FILE * out,ext2_ino_t ino)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
do_list_xattr(int argc,char ** argv,int sci_idx EXT2FS_ATTR ((unused)),void * infop EXT2FS_ATTR ((unused)))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
do_get_xattr(int argc,char ** argv,int sci_idx EXT2FS_ATTR ((unused)),void * infop EXT2FS_ATTR ((unused)))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
do_set_xattr(int argc,char ** argv,int sci_idx EXT2FS_ATTR ((unused)),void * infop EXT2FS_ATTR ((unused)))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
do_rm_xattr(int argc,char ** argv,int sci_idx EXT2FS_ATTR ((unused)),void * infop EXT2FS_ATTR ((unused)))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 */
is_mostly_printable(const char * cp,int len)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
safe_print(FILE * f,const char * cp,int len)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
dump_xattr_raw_entries(FILE * f,unsigned char * buf,unsigned int start,unsigned int len,unsigned value_start)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), name_len = %u, "
434 "name_index = %u\n",
435 off, off, 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 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
raw_inode_xattr_dump(FILE * f,unsigned char * buf,unsigned int len)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
block_xattr_dump(FILE * f,unsigned char * buf,unsigned int len)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 }
504