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