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