]> git.ipfire.org Git - thirdparty/e2fsprogs.git/blob - misc/create_inode.c
projects / thirdparty / e2fsprogs.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
tests: add test for handling an invalid symlink in an inline directory
[thirdparty/e2fsprogs.git] / misc / create_inode.c
1 /*
2 * create_inode.c --- create an inode
3 *
4 * Copyright (C) 2014 Robert Yang <liezhi.yang@windriver.com>
5 *
6 * %Begin-Header%
7 * This file may be redistributed under the terms of the GNU library
8 * General Public License, version 2.
9 * %End-Header%
10 */
11
12 #define _FILE_OFFSET_BITS 64
13 #define _LARGEFILE64_SOURCE 1
14 #define _GNU_SOURCE 1
15
16 #include "config.h"
17 #include <time.h>
18 #include <sys/stat.h>
19 #include <sys/types.h>
20 #include <unistd.h>
21 #include <limits.h> /* for PATH_MAX */
22 #include <dirent.h> /* for scandir() and alphasort() */
23 #if defined HAVE_SYS_XATTR_H
24 #include <sys/xattr.h>
25 #elif defined HAVE_ATTR_XATTR_H
26 #include <attr/xattr.h>
27 #endif
28 #ifdef HAVE_SYS_IOCTL_H
29 #include <sys/ioctl.h>
30 #endif
31 #ifdef HAVE_SYS_SYSMACROS_H
32 #include <sys/sysmacros.h>
33 #endif
34
35 #include <ext2fs/ext2fs.h>
36 #include <ext2fs/ext2_types.h>
37 #include <ext2fs/fiemap.h>
38
39 #include "create_inode.h"
40 #include "support/nls-enable.h"
41
42 /* 64KiB is the minimum blksize to best minimize system call overhead. */
43 #define COPY_FILE_BUFLEN 65536
44
45 static int ext2_file_type(unsigned int mode)
46 {
47 if (LINUX_S_ISREG(mode))
48 return EXT2_FT_REG_FILE;
49
50 if (LINUX_S_ISDIR(mode))
51 return EXT2_FT_DIR;
52
53 if (LINUX_S_ISCHR(mode))
54 return EXT2_FT_CHRDEV;
55
56 if (LINUX_S_ISBLK(mode))
57 return EXT2_FT_BLKDEV;
58
59 if (LINUX_S_ISLNK(mode))
60 return EXT2_FT_SYMLINK;
61
62 if (LINUX_S_ISFIFO(mode))
63 return EXT2_FT_FIFO;
64
65 if (LINUX_S_ISSOCK(mode))
66 return EXT2_FT_SOCK;
67
68 return 0;
69 }
70
71 /* Link an inode number to a directory */
72 static errcode_t add_link(ext2_filsys fs, ext2_ino_t parent_ino,
73 ext2_ino_t ino, const char *name)
74 {
75 struct ext2_inode inode;
76 errcode_t retval;
77
78 retval = ext2fs_read_inode(fs, ino, &inode);
79 if (retval) {
80 com_err(__func__, retval, _("while reading inode %u"), ino);
81 return retval;
82 }
83
84 retval = ext2fs_link(fs, parent_ino, name, ino,
85 ext2_file_type(inode.i_mode));
86 if (retval == EXT2_ET_DIR_NO_SPACE) {
87 retval = ext2fs_expand_dir(fs, parent_ino);
88 if (retval) {
89 com_err(__func__, retval,
90 _("while expanding directory"));
91 return retval;
92 }
93 retval = ext2fs_link(fs, parent_ino, name, ino,
94 ext2_file_type(inode.i_mode));
95 }
96 if (retval) {
97 com_err(__func__, retval, _("while linking \"%s\""), name);
98 return retval;
99 }
100
101 inode.i_links_count++;
102
103 retval = ext2fs_write_inode(fs, ino, &inode);
104 if (retval)
105 com_err(__func__, retval, _("while writing inode %u"), ino);
106
107 return retval;
108 }
109
110 /* Set the uid, gid, mode and time for the inode */
111 static errcode_t set_inode_extra(ext2_filsys fs, ext2_ino_t ino,
112 struct stat *st)
113 {
114 errcode_t retval;
115 struct ext2_inode inode;
116
117 retval = ext2fs_read_inode(fs, ino, &inode);
118 if (retval) {
119 com_err(__func__, retval, _("while reading inode %u"), ino);
120 return retval;
121 }
122
123 inode.i_uid = st->st_uid;
124 ext2fs_set_i_uid_high(inode, st->st_uid >> 16);
125 inode.i_gid = st->st_gid;
126 ext2fs_set_i_gid_high(inode, st->st_gid >> 16);
127 inode.i_mode = (LINUX_S_IFMT & inode.i_mode) | (~S_IFMT & st->st_mode);
128 inode.i_atime = st->st_atime;
129 inode.i_mtime = st->st_mtime;
130 inode.i_ctime = st->st_ctime;
131
132 retval = ext2fs_write_inode(fs, ino, &inode);
133 if (retval)
134 com_err(__func__, retval, _("while writing inode %u"), ino);
135 return retval;
136 }
137
138 #ifdef HAVE_LLISTXATTR
139 static errcode_t set_inode_xattr(ext2_filsys fs, ext2_ino_t ino,
140 const char *filename)
141 {
142 errcode_t retval, close_retval;
143 struct ext2_xattr_handle *handle;
144 ssize_t size, value_size;
145 char *list = NULL;
146 int i;
147
148 if (no_copy_xattrs)
149 return 0;
150
151 size = llistxattr(filename, NULL, 0);
152 if (size == -1) {
153 if (errno == ENOTSUP)
154 return 0;
155 retval = errno;
156 com_err(__func__, retval, _("while listing attributes of \"%s\""),
157 filename);
158 return retval;
159 } else if (size == 0) {
160 return 0;
161 }
162
163 retval = ext2fs_xattrs_open(fs, ino, &handle);
164 if (retval) {
165 if (retval == EXT2_ET_MISSING_EA_FEATURE)
166 return 0;
167 com_err(__func__, retval, _("while opening inode %u"), ino);
168 return retval;
169 }
170
171 retval = ext2fs_xattrs_read(handle);
172 if (retval) {
173 com_err(__func__, retval,
174 _("while reading xattrs for inode %u"), ino);
175 goto out;
176 }
177
178 retval = ext2fs_get_mem(size, &list);
179 if (retval) {
180 com_err(__func__, retval, _("while allocating memory"));
181 goto out;
182 }
183
184 size = llistxattr(filename, list, size);
185 if (size == -1) {
186 retval = errno;
187 com_err(__func__, retval, _("while listing attributes of \"%s\""),
188 filename);
189 goto out;
190 }
191
192 for (i = 0; i < size; i += strlen(&list[i]) + 1) {
193 const char *name = &list[i];
194 char *value;
195
196 value_size = lgetxattr(filename, name, NULL, 0);
197 if (value_size == -1) {
198 retval = errno;
199 com_err(__func__, retval,
200 _("while reading attribute \"%s\" of \"%s\""),
201 name, filename);
202 break;
203 }
204
205 retval = ext2fs_get_mem(value_size, &value);
206 if (retval) {
207 com_err(__func__, retval, _("while allocating memory"));
208 break;
209 }
210
211 value_size = lgetxattr(filename, name, value, value_size);
212 if (value_size == -1) {
213 ext2fs_free_mem(&value);
214 retval = errno;
215 com_err(__func__, retval,
216 _("while reading attribute \"%s\" of \"%s\""),
217 name, filename);
218 break;
219 }
220
221 retval = ext2fs_xattr_set(handle, name, value, value_size);
222 ext2fs_free_mem(&value);
223 if (retval) {
224 com_err(__func__, retval,
225 _("while writing attribute \"%s\" to inode %u"),
226 name, ino);
227 break;
228 }
229
230 }
231 out:
232 ext2fs_free_mem(&list);
233 close_retval = ext2fs_xattrs_close(&handle);
234 if (close_retval) {
235 com_err(__func__, retval, _("while closing inode %u"), ino);
236 retval = retval ? retval : close_retval;
237 }
238 return retval;
239 }
240 #else /* HAVE_LLISTXATTR */
241 static errcode_t set_inode_xattr(ext2_filsys fs EXT2FS_ATTR((unused)),
242 ext2_ino_t ino EXT2FS_ATTR((unused)),
243 const char *filename EXT2FS_ATTR((unused)))
244 {
245 return 0;
246 }
247 #endif /* HAVE_LLISTXATTR */
248
249 #ifndef _WIN32
250 /* Make a special files (block and character devices), fifo's, and sockets */
251 errcode_t do_mknod_internal(ext2_filsys fs, ext2_ino_t cwd, const char *name,
252 unsigned int st_mode, unsigned int st_rdev)
253 {
254 ext2_ino_t ino;
255 errcode_t retval;
256 struct ext2_inode inode;
257 unsigned long devmajor, devminor, mode;
258 int filetype;
259
260 switch(st_mode & S_IFMT) {
261 case S_IFCHR:
262 mode = LINUX_S_IFCHR;
263 filetype = EXT2_FT_CHRDEV;
264 break;
265 case S_IFBLK:
266 mode = LINUX_S_IFBLK;
267 filetype = EXT2_FT_BLKDEV;
268 break;
269 case S_IFIFO:
270 mode = LINUX_S_IFIFO;
271 filetype = EXT2_FT_FIFO;
272 break;
273 #ifndef _WIN32
274 case S_IFSOCK:
275 mode = LINUX_S_IFSOCK;
276 filetype = EXT2_FT_SOCK;
277 break;
278 #endif
279 default:
280 return EXT2_ET_INVALID_ARGUMENT;
281 }
282
283 retval = ext2fs_new_inode(fs, cwd, 010755, 0, &ino);
284 if (retval) {
285 com_err(__func__, retval, _("while allocating inode \"%s\""),
286 name);
287 return retval;
288 }
289
290 #ifdef DEBUGFS
291 printf("Allocated inode: %u\n", ino);
292 #endif
293 retval = ext2fs_link(fs, cwd, name, ino, filetype);
294 if (retval == EXT2_ET_DIR_NO_SPACE) {
295 retval = ext2fs_expand_dir(fs, cwd);
296 if (retval) {
297 com_err(__func__, retval,
298 _("while expanding directory"));
299 return retval;
300 }
301 retval = ext2fs_link(fs, cwd, name, ino, filetype);
302 }
303 if (retval) {
304 com_err(name, retval, _("while creating inode \"%s\""), name);
305 return retval;
306 }
307 if (ext2fs_test_inode_bitmap2(fs->inode_map, ino))
308 com_err(__func__, 0, "Warning: inode already set");
309 ext2fs_inode_alloc_stats2(fs, ino, +1, 0);
310 memset(&inode, 0, sizeof(inode));
311 inode.i_mode = mode;
312 inode.i_atime = inode.i_ctime = inode.i_mtime =
313 fs->now ? fs->now : time(0);
314
315 if (filetype != S_IFIFO) {
316 devmajor = major(st_rdev);
317 devminor = minor(st_rdev);
318
319 if ((devmajor < 256) && (devminor < 256)) {
320 inode.i_block[0] = devmajor * 256 + devminor;
321 inode.i_block[1] = 0;
322 } else {
323 inode.i_block[0] = 0;
324 inode.i_block[1] = (devminor & 0xff) | (devmajor << 8) |
325 ((devminor & ~0xff) << 12);
326 }
327 }
328 inode.i_links_count = 1;
329
330 retval = ext2fs_write_new_inode(fs, ino, &inode);
331 if (retval)
332 com_err(__func__, retval, _("while writing inode %u"), ino);
333
334 return retval;
335 }
336 #endif
337
338 /* Make a symlink name -> target */
339 errcode_t do_symlink_internal(ext2_filsys fs, ext2_ino_t cwd, const char *name,
340 char *target, ext2_ino_t root)
341 {
342 char *cp;
343 ext2_ino_t parent_ino;
344 errcode_t retval;
345
346 cp = strrchr(name, '/');
347 if (cp) {
348 *cp = 0;
349 retval = ext2fs_namei(fs, root, cwd, name, &parent_ino);
350 if (retval) {
351 com_err(name, retval, 0);
352 return retval;
353 }
354 name = cp+1;
355 } else
356 parent_ino = cwd;
357
358 retval = ext2fs_symlink(fs, parent_ino, 0, name, target);
359 if (retval == EXT2_ET_DIR_NO_SPACE) {
360 retval = ext2fs_expand_dir(fs, parent_ino);
361 if (retval) {
362 com_err("do_symlink_internal", retval,
363 _("while expanding directory"));
364 return retval;
365 }
366 retval = ext2fs_symlink(fs, parent_ino, 0, name, target);
367 }
368 if (retval)
369 com_err("ext2fs_symlink", retval,
370 _("while creating symlink \"%s\""), name);
371 return retval;
372 }
373
374 /* Make a directory in the fs */
375 errcode_t do_mkdir_internal(ext2_filsys fs, ext2_ino_t cwd, const char *name,
376 ext2_ino_t root)
377 {
378 char *cp;
379 ext2_ino_t parent_ino;
380 errcode_t retval;
381
382
383 cp = strrchr(name, '/');
384 if (cp) {
385 *cp = 0;
386 retval = ext2fs_namei(fs, root, cwd, name, &parent_ino);
387 if (retval) {
388 com_err(name, retval, _("while looking up \"%s\""),
389 name);
390 return retval;
391 }
392 name = cp+1;
393 } else
394 parent_ino = cwd;
395
396 retval = ext2fs_mkdir(fs, parent_ino, 0, name);
397 if (retval == EXT2_ET_DIR_NO_SPACE) {
398 retval = ext2fs_expand_dir(fs, parent_ino);
399 if (retval) {
400 com_err(__func__, retval,
401 _("while expanding directory"));
402 return retval;
403 }
404 retval = ext2fs_mkdir(fs, parent_ino, 0, name);
405 }
406 if (retval)
407 com_err("ext2fs_mkdir", retval,
408 _("while creating directory \"%s\""), name);
409 return retval;
410 }
411
412 #if !defined HAVE_PREAD64 && !defined HAVE_PREAD
413 static ssize_t my_pread(int fd, void *buf, size_t count, off_t offset)
414 {
415 if (lseek(fd, offset, SEEK_SET) < 0)
416 return 0;
417
418 return read(fd, buf, count);
419 }
420 #endif /* !defined HAVE_PREAD64 && !defined HAVE_PREAD */
421
422 static errcode_t copy_file_chunk(ext2_filsys fs, int fd, ext2_file_t e2_file,
423 off_t start, off_t end, char *buf,
424 char *zerobuf)
425 {
426 off_t off, bpos;
427 ssize_t got, blen;
428 unsigned int written;
429 char *ptr;
430 errcode_t err = 0;
431
432 for (off = start; off < end; off += COPY_FILE_BUFLEN) {
433 #ifdef HAVE_PREAD64
434 got = pread64(fd, buf, COPY_FILE_BUFLEN, off);
435 #elif HAVE_PREAD
436 got = pread(fd, buf, COPY_FILE_BUFLEN, off);
437 #else
438 got = my_pread(fd, buf, COPY_FILE_BUFLEN, off);
439 #endif
440 if (got < 0) {
441 err = errno;
442 goto fail;
443 }
444 for (bpos = 0, ptr = buf; bpos < got; bpos += fs->blocksize) {
445 blen = fs->blocksize;
446 if (blen > got - bpos)
447 blen = got - bpos;
448 if (memcmp(ptr, zerobuf, blen) == 0) {
449 ptr += blen;
450 continue;
451 }
452 err = ext2fs_file_llseek(e2_file, off + bpos,
453 EXT2_SEEK_SET, NULL);
454 if (err)
455 goto fail;
456 while (blen > 0) {
457 err = ext2fs_file_write(e2_file, ptr, blen,
458 &written);
459 if (err)
460 goto fail;
461 if (written == 0) {
462 err = EIO;
463 goto fail;
464 }
465 blen -= written;
466 ptr += written;
467 }
468 }
469 }
470 fail:
471 return err;
472 }
473
474 #if defined(SEEK_DATA) && defined(SEEK_HOLE)
475 static errcode_t try_lseek_copy(ext2_filsys fs, int fd, struct stat *statbuf,
476 ext2_file_t e2_file, char *buf, char *zerobuf)
477 {
478 off_t data = 0, hole;
479 off_t data_blk, hole_blk;
480 errcode_t err = 0;
481
482 /* Try to use SEEK_DATA and SEEK_HOLE */
483 while (data < statbuf->st_size) {
484 data = lseek(fd, data, SEEK_DATA);
485 if (data < 0) {
486 if (errno == ENXIO)
487 break;
488 return EXT2_ET_UNIMPLEMENTED;
489 }
490 hole = lseek(fd, data, SEEK_HOLE);
491 if (hole < 0)
492 return EXT2_ET_UNIMPLEMENTED;
493
494 data_blk = data & ~(off_t)(fs->blocksize - 1);
495 hole_blk = ((hole + (off_t)(fs->blocksize - 1)) &
496 ~(off_t)(fs->blocksize - 1));
497 err = copy_file_chunk(fs, fd, e2_file, data_blk, hole_blk, buf,
498 zerobuf);
499 if (err)
500 return err;
501
502 data = hole;
503 }
504
505 return err;
506 }
507 #endif /* SEEK_DATA and SEEK_HOLE */
508
509 #if defined(FS_IOC_FIEMAP)
510 static errcode_t try_fiemap_copy(ext2_filsys fs, int fd, ext2_file_t e2_file,
511 char *buf, char *zerobuf)
512 {
513 #define EXTENT_MAX_COUNT 512
514 struct fiemap *fiemap_buf;
515 struct fiemap_extent *ext_buf, *ext;
516 int ext_buf_size, fie_buf_size;
517 off_t pos = 0;
518 unsigned int i;
519 errcode_t err;
520
521 ext_buf_size = EXTENT_MAX_COUNT * sizeof(struct fiemap_extent);
522 fie_buf_size = sizeof(struct fiemap) + ext_buf_size;
523
524 err = ext2fs_get_memzero(fie_buf_size, &fiemap_buf);
525 if (err)
526 return err;
527
528 ext_buf = fiemap_buf->fm_extents;
529 memset(fiemap_buf, 0, fie_buf_size);
530 fiemap_buf->fm_length = FIEMAP_MAX_OFFSET;
531 fiemap_buf->fm_flags |= FIEMAP_FLAG_SYNC;
532 fiemap_buf->fm_extent_count = EXTENT_MAX_COUNT;
533
534 do {
535 fiemap_buf->fm_start = pos;
536 memset(ext_buf, 0, ext_buf_size);
537 err = ioctl(fd, FS_IOC_FIEMAP, fiemap_buf);
538 if (err < 0 && (errno == EOPNOTSUPP || errno == ENOTTY)) {
539 err = EXT2_ET_UNIMPLEMENTED;
540 goto out;
541 } else if (err < 0) {
542 err = errno;
543 goto out;
544 } else if (fiemap_buf->fm_mapped_extents == 0)
545 goto out;
546 for (i = 0, ext = ext_buf; i < fiemap_buf->fm_mapped_extents;
547 i++, ext++) {
548 err = copy_file_chunk(fs, fd, e2_file, ext->fe_logical,
549 ext->fe_logical + ext->fe_length,
550 buf, zerobuf);
551 if (err)
552 goto out;
553 }
554
555 ext--;
556 /* Record file's logical offset this time */
557 pos = ext->fe_logical + ext->fe_length;
558 /*
559 * If fm_extents array has been filled and
560 * there are extents left, continue to cycle.
561 */
562 } while (fiemap_buf->fm_mapped_extents == EXTENT_MAX_COUNT &&
563 !(ext->fe_flags & FIEMAP_EXTENT_LAST));
564 out:
565 ext2fs_free_mem(&fiemap_buf);
566 return err;
567 }
568 #endif /* FS_IOC_FIEMAP */
569
570 static errcode_t copy_file(ext2_filsys fs, int fd, struct stat *statbuf,
571 ext2_ino_t ino)
572 {
573 ext2_file_t e2_file;
574 char *buf = NULL, *zerobuf = NULL;
575 errcode_t err, close_err;
576
577 err = ext2fs_file_open(fs, ino, EXT2_FILE_WRITE, &e2_file);
578 if (err)
579 return err;
580
581 err = ext2fs_get_mem(COPY_FILE_BUFLEN, &buf);
582 if (err)
583 goto out;
584
585 err = ext2fs_get_memzero(fs->blocksize, &zerobuf);
586 if (err)
587 goto out;
588
589 #if defined(SEEK_DATA) && defined(SEEK_HOLE)
590 err = try_lseek_copy(fs, fd, statbuf, e2_file, buf, zerobuf);
591 if (err != EXT2_ET_UNIMPLEMENTED)
592 goto out;
593 #endif
594
595 #if defined(FS_IOC_FIEMAP)
596 err = try_fiemap_copy(fs, fd, e2_file, buf, zerobuf);
597 if (err != EXT2_ET_UNIMPLEMENTED)
598 goto out;
599 #endif
600
601 err = copy_file_chunk(fs, fd, e2_file, 0, statbuf->st_size, buf,
602 zerobuf);
603 out:
604 ext2fs_free_mem(&zerobuf);
605 ext2fs_free_mem(&buf);
606 close_err = ext2fs_file_close(e2_file);
607 if (err == 0)
608 err = close_err;
609 return err;
610 }
611
612 static int is_hardlink(struct hdlinks_s *hdlinks, dev_t dev, ino_t ino)
613 {
614 int i;
615
616 for (i = 0; i < hdlinks->count; i++) {
617 if (hdlinks->hdl[i].src_dev == dev &&
618 hdlinks->hdl[i].src_ino == ino)
619 return i;
620 }
621 return -1;
622 }
623
624 /* Copy the native file to the fs */
625 errcode_t do_write_internal(ext2_filsys fs, ext2_ino_t cwd, const char *src,
626 const char *dest, ext2_ino_t root)
627 {
628 int fd;
629 struct stat statbuf;
630 ext2_ino_t newfile, parent_ino;
631 errcode_t retval;
632 struct ext2_inode inode;
633 char *cp;
634
635 fd = ext2fs_open_file(src, O_RDONLY, 0);
636 if (fd < 0) {
637 retval = errno;
638 com_err(__func__, retval, _("while opening \"%s\" to copy"),
639 src);
640 return retval;
641 }
642 if (fstat(fd, &statbuf) < 0) {
643 retval = errno;
644 goto out;
645 }
646
647 cp = strrchr(dest, '/');
648 if (cp) {
649 *cp = 0;
650 retval = ext2fs_namei(fs, root, cwd, dest, &parent_ino);
651 if (retval) {
652 com_err(dest, retval, _("while looking up \"%s\""),
653 dest);
654 goto out;
655 }
656 dest = cp+1;
657 } else
658 parent_ino = cwd;
659
660 retval = ext2fs_namei(fs, root, parent_ino, dest, &newfile);
661 if (retval == 0) {
662 retval = EXT2_ET_FILE_EXISTS;
663 goto out;
664 }
665
666 retval = ext2fs_new_inode(fs, parent_ino, 010755, 0, &newfile);
667 if (retval)
668 goto out;
669 #ifdef DEBUGFS
670 printf("Allocated inode: %u\n", newfile);
671 #endif
672 retval = ext2fs_link(fs, parent_ino, dest, newfile, EXT2_FT_REG_FILE);
673 if (retval == EXT2_ET_DIR_NO_SPACE) {
674 retval = ext2fs_expand_dir(fs, parent_ino);
675 if (retval)
676 goto out;
677 retval = ext2fs_link(fs, parent_ino, dest, newfile,
678 EXT2_FT_REG_FILE);
679 }
680 if (retval)
681 goto out;
682 if (ext2fs_test_inode_bitmap2(fs->inode_map, newfile))
683 com_err(__func__, 0, "Warning: inode already set");
684 ext2fs_inode_alloc_stats2(fs, newfile, +1, 0);
685 memset(&inode, 0, sizeof(inode));
686 inode.i_mode = (statbuf.st_mode & ~S_IFMT) | LINUX_S_IFREG;
687 inode.i_atime = inode.i_ctime = inode.i_mtime =
688 fs->now ? fs->now : time(0);
689 inode.i_links_count = 1;
690 retval = ext2fs_inode_size_set(fs, &inode, statbuf.st_size);
691 if (retval)
692 goto out;
693 if (ext2fs_has_feature_inline_data(fs->super)) {
694 inode.i_flags |= EXT4_INLINE_DATA_FL;
695 } else if (ext2fs_has_feature_extents(fs->super)) {
696 ext2_extent_handle_t handle;
697
698 inode.i_flags &= ~EXT4_EXTENTS_FL;
699 retval = ext2fs_extent_open2(fs, newfile, &inode, &handle);
700 if (retval)
701 goto out;
702 ext2fs_extent_free(handle);
703 }
704
705 retval = ext2fs_write_new_inode(fs, newfile, &inode);
706 if (retval)
707 goto out;
708 if (inode.i_flags & EXT4_INLINE_DATA_FL) {
709 retval = ext2fs_inline_data_init(fs, newfile);
710 if (retval)
711 goto out;
712 }
713 if (LINUX_S_ISREG(inode.i_mode)) {
714 retval = copy_file(fs, fd, &statbuf, newfile);
715 if (retval)
716 goto out;
717 }
718 out:
719 close(fd);
720 return retval;
721 }
722
723 struct file_info {
724 char *path;
725 size_t path_len;
726 size_t path_max_len;
727 };
728
729 static errcode_t path_append(struct file_info *target, const char *file)
730 {
731 if (strlen(file) + target->path_len + 1 > target->path_max_len) {
732 void *p;
733 target->path_max_len *= 2;
734 p = realloc(target->path, target->path_max_len);
735 if (p == NULL)
736 return EXT2_ET_NO_MEMORY;
737 target->path = p;
738 }
739 target->path_len += sprintf(target->path + target->path_len, "/%s",
740 file);
741 return 0;
742 }
743
744 #ifdef _WIN32
745 static int scandir(const char *dir_name, struct dirent ***name_list,
746 int (*filter)(const struct dirent*),
747 int (*compar)(const struct dirent**, const struct dirent**)) {
748 DIR *dir;
749 struct dirent *dent;
750 struct dirent **temp_list = NULL;
751 size_t temp_list_size = 0; // unit: num of dirent
752 size_t num_dent = 0;
753
754 dir = opendir(dir_name);
755 if (dir == NULL) {
756 return -1;
757 }
758
759 while ((dent = readdir(dir))) {
760 if (filter != NULL && !(*filter)(dent))
761 continue;
762
763 // re-allocate the list
764 if (num_dent == temp_list_size) {
765 size_t new_list_size = temp_list_size + 32;
766 struct dirent **new_list = (struct dirent**)realloc(
767 temp_list, new_list_size * sizeof(struct dirent*));
768 if (new_list == NULL)
769 goto out_err;
770 temp_list_size = new_list_size;
771 temp_list = new_list;
772 }
773 // add the copy of dirent to the list
774 temp_list[num_dent] = (struct dirent*)malloc((dent->d_reclen + 3) & ~3);
775 if (!temp_list[num_dent])
776 goto out_err;
777 memcpy(temp_list[num_dent], dent, dent->d_reclen);
778 num_dent++;
779 }
780 closedir(dir);
781
782 if (compar != NULL) {
783 qsort(temp_list, num_dent, sizeof(struct dirent*),
784 (int (*)(const void*, const void*))compar);
785 }
786 *name_list = temp_list;
787 return num_dent;
788
789 out_err:
790 closedir(dir);
791 while (num_dent > 0)
792 free(temp_list[--num_dent]);
793 free(temp_list);
794 return -1;
795 }
796
797 static int alphasort(const struct dirent **a, const struct dirent **b) {
798 return strcoll((*a)->d_name, (*b)->d_name);
799 }
800 #endif
801
802 /* Copy files from source_dir to fs in alphabetical order */
803 static errcode_t __populate_fs(ext2_filsys fs, ext2_ino_t parent_ino,
804 const char *source_dir, ext2_ino_t root,
805 struct hdlinks_s *hdlinks,
806 struct file_info *target,
807 struct fs_ops_callbacks *fs_callbacks)
808 {
809 const char *name;
810 struct dirent **dent;
811 struct stat st;
812 unsigned int save_inode;
813 ext2_ino_t ino;
814 errcode_t retval = 0;
815 int hdlink;
816 size_t cur_dir_path_len;
817 int i, num_dents;
818
819 if (chdir(source_dir) < 0) {
820 retval = errno;
821 com_err(__func__, retval,
822 _("while changing working directory to \"%s\""),
823 source_dir);
824 return retval;
825 }
826
827 num_dents = scandir(".", &dent, NULL, alphasort);
828
829 if (num_dents < 0) {
830 retval = errno;
831 com_err(__func__, retval,
832 _("while scanning directory \"%s\""), source_dir);
833 return retval;
834 }
835
836 for (i = 0; i < num_dents; free(dent[i]), i++) {
837 name = dent[i]->d_name;
838 if ((!strcmp(name, ".")) || (!strcmp(name, "..")))
839 continue;
840 if (lstat(name, &st)) {
841 retval = errno;
842 com_err(__func__, retval, _("while lstat \"%s\""),
843 name);
844 goto out;
845 }
846
847 /* Check for hardlinks */
848 save_inode = 0;
849 if (!S_ISDIR(st.st_mode) && !S_ISLNK(st.st_mode) &&
850 st.st_nlink > 1) {
851 hdlink = is_hardlink(hdlinks, st.st_dev, st.st_ino);
852 if (hdlink >= 0) {
853 retval = add_link(fs, parent_ino,
854 hdlinks->hdl[hdlink].dst_ino,
855 name);
856 if (retval) {
857 com_err(__func__, retval,
858 "while linking %s", name);
859 goto out;
860 }
861 continue;
862 } else
863 save_inode = 1;
864 }
865
866 cur_dir_path_len = target->path_len;
867 retval = path_append(target, name);
868 if (retval) {
869 com_err(__func__, retval,
870 "while appending %s", name);
871 goto out;
872 }
873
874 if (fs_callbacks && fs_callbacks->create_new_inode) {
875 retval = fs_callbacks->create_new_inode(fs,
876 target->path, name, parent_ino, root,
877 st.st_mode & S_IFMT);
878 if (retval)
879 goto out;
880 }
881
882 switch(st.st_mode & S_IFMT) {
883 case S_IFCHR:
884 case S_IFBLK:
885 case S_IFIFO:
886 #ifndef _WIN32
887 case S_IFSOCK:
888 retval = do_mknod_internal(fs, parent_ino, name,
889 st.st_mode, st.st_rdev);
890 if (retval) {
891 com_err(__func__, retval,
892 _("while creating special file "
893 "\"%s\""), name);
894 goto out;
895 }
896 break;
897 case S_IFLNK: {
898 char *ln_target;
899 int read_cnt;
900
901 ln_target = malloc(st.st_size + 1);
902 if (ln_target == NULL) {
903 com_err(__func__, retval,
904 _("malloc failed"));
905 goto out;
906 }
907 read_cnt = readlink(name, ln_target,
908 st.st_size + 1);
909 if (read_cnt == -1) {
910 retval = errno;
911 com_err(__func__, retval,
912 _("while trying to read link \"%s\""),
913 name);
914 free(ln_target);
915 goto out;
916 }
917 if (read_cnt > st.st_size) {
918 com_err(__func__, retval,
919 _("symlink increased in size "
920 "between lstat() and readlink()"));
921 free(ln_target);
922 goto out;
923 }
924 ln_target[read_cnt] = '\0';
925 retval = do_symlink_internal(fs, parent_ino, name,
926 ln_target, root);
927 free(ln_target);
928 if (retval) {
929 com_err(__func__, retval,
930 _("while writing symlink\"%s\""),
931 name);
932 goto out;
933 }
934 break;
935 }
936 #endif /* !_WIN32 */
937 case S_IFREG:
938 retval = do_write_internal(fs, parent_ino, name, name,
939 root);
940 if (retval) {
941 com_err(__func__, retval,
942 _("while writing file \"%s\""), name);
943 goto out;
944 }
945 break;
946 case S_IFDIR:
947 /* Don't choke on /lost+found */
948 if (parent_ino == EXT2_ROOT_INO &&
949 strcmp(name, "lost+found") == 0)
950 goto find_lnf;
951 retval = do_mkdir_internal(fs, parent_ino, name,
952 root);
953 if (retval) {
954 com_err(__func__, retval,
955 _("while making dir \"%s\""), name);
956 goto out;
957 }
958 find_lnf:
959 retval = ext2fs_namei(fs, root, parent_ino,
960 name, &ino);
961 if (retval) {
962 com_err(name, retval, 0);
963 goto out;
964 }
965 /* Populate the dir recursively*/
966 retval = __populate_fs(fs, ino, name, root, hdlinks,
967 target, fs_callbacks);
968 if (retval)
969 goto out;
970 if (chdir("..")) {
971 retval = errno;
972 com_err(__func__, retval,
973 _("while changing directory"));
974 goto out;
975 }
976 break;
977 default:
978 com_err(__func__, 0,
979 _("ignoring entry \"%s\""), name);
980 }
981
982 retval = ext2fs_namei(fs, root, parent_ino, name, &ino);
983 if (retval) {
984 com_err(name, retval, _("while looking up \"%s\""),
985 name);
986 goto out;
987 }
988
989 retval = set_inode_extra(fs, ino, &st);
990 if (retval) {
991 com_err(__func__, retval,
992 _("while setting inode for \"%s\""), name);
993 goto out;
994 }
995
996 retval = set_inode_xattr(fs, ino, name);
997 if (retval) {
998 com_err(__func__, retval,
999 _("while setting xattrs for \"%s\""), name);
1000 goto out;
1001 }
1002
1003 if (fs_callbacks && fs_callbacks->end_create_new_inode) {
1004 retval = fs_callbacks->end_create_new_inode(fs,
1005 target->path, name, parent_ino, root,
1006 st.st_mode & S_IFMT);
1007 if (retval)
1008 goto out;
1009 }
1010
1011 /* Save the hardlink ino */
1012 if (save_inode) {
1013 /*
1014 * Check whether need more memory, and we don't need
1015 * free() since the lifespan will be over after the fs
1016 * populated.
1017 */
1018 if (hdlinks->count == hdlinks->size) {
1019 void *p = realloc(hdlinks->hdl,
1020 (hdlinks->size + HDLINK_CNT) *
1021 sizeof(struct hdlink_s));
1022 if (p == NULL) {
1023 retval = EXT2_ET_NO_MEMORY;
1024 com_err(name, retval,
1025 _("while saving inode data"));
1026 goto out;
1027 }
1028 hdlinks->hdl = p;
1029 hdlinks->size += HDLINK_CNT;
1030 }
1031 hdlinks->hdl[hdlinks->count].src_dev = st.st_dev;
1032 hdlinks->hdl[hdlinks->count].src_ino = st.st_ino;
1033 hdlinks->hdl[hdlinks->count].dst_ino = ino;
1034 hdlinks->count++;
1035 }
1036 target->path_len = cur_dir_path_len;
1037 target->path[target->path_len] = 0;
1038 }
1039
1040 out:
1041 for (; i < num_dents; free(dent[i]), i++);
1042 free(dent);
1043 return retval;
1044 }
1045
1046 errcode_t populate_fs2(ext2_filsys fs, ext2_ino_t parent_ino,
1047 const char *source_dir, ext2_ino_t root,
1048 struct fs_ops_callbacks *fs_callbacks)
1049 {
1050 struct file_info file_info;
1051 struct hdlinks_s hdlinks;
1052 errcode_t retval;
1053
1054 if (!(fs->flags & EXT2_FLAG_RW)) {
1055 com_err(__func__, 0, "Filesystem opened readonly");
1056 return EROFS;
1057 }
1058
1059 hdlinks.count = 0;
1060 hdlinks.size = HDLINK_CNT;
1061 hdlinks.hdl = realloc(NULL, hdlinks.size * sizeof(struct hdlink_s));
1062 if (hdlinks.hdl == NULL) {
1063 retval = errno;
1064 com_err(__func__, retval, _("while allocating memory"));
1065 return retval;
1066 }
1067
1068 file_info.path_len = 0;
1069 file_info.path_max_len = 255;
1070 file_info.path = calloc(file_info.path_max_len, 1);
1071
1072 retval = set_inode_xattr(fs, root, source_dir);
1073 if (retval) {
1074 com_err(__func__, retval,
1075 _("while copying xattrs on root directory"));
1076 goto out;
1077 }
1078
1079 retval = __populate_fs(fs, parent_ino, source_dir, root, &hdlinks,
1080 &file_info, fs_callbacks);
1081
1082 out:
1083 free(file_info.path);
1084 free(hdlinks.hdl);
1085 return retval;
1086 }
1087
1088 errcode_t populate_fs(ext2_filsys fs, ext2_ino_t parent_ino,
1089 const char *source_dir, ext2_ino_t root)
1090 {
1091 return populate_fs2(fs, parent_ino, source_dir, root, NULL);
1092 }
Unnamed repository; edit this file 'description' to name the repository.