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;
 770                         }
 771                         temp_list_size = new_list_size;
 772                         temp_list = new_list;
 773                 }
 774                 // add the copy of dirent to the list
 775                 temp_list[num_dent] = (struct dirent*)malloc((dent->d_reclen + 3) & ~3);
 776                 if (!temp_list[num_dent])
 777                         goto out;
 778                 memcpy(temp_list[num_dent], dent, dent->d_reclen);
 779                 num_dent++;
 780         }
 781
 782         if (compar != NULL) {
 783                 qsort(temp_list, num_dent, sizeof(struct dirent*),
 784                       (int (*)(const void*, const void*))compar);
 785         }
 786
 787         // release the temp list
 788         *name_list = temp_list;
 789         temp_list = NULL;
 790
 791 out:
 792         if (temp_list != NULL) {
 793                 while (num_dent > 0) {
 794                         free(temp_list[--num_dent]);
 795                 }
 796                 free(temp_list);
 797                 num_dent = -1;
 798         }
 799         closedir(dir);
 800         return num_dent;
 801 }
 802
 803 static int alphasort(const struct dirent **a, const struct dirent **b) {
 804         return strcoll((*a)->d_name, (*b)->d_name);
 805 }
 806 #endif
 807
 808 /* Copy files from source_dir to fs in alphabetical order */
 809 static errcode_t __populate_fs(ext2_filsys fs, ext2_ino_t parent_ino,
 810                                const char *source_dir, ext2_ino_t root,
 811                                struct hdlinks_s *hdlinks,
 812                                struct file_info *target,
 813                                struct fs_ops_callbacks *fs_callbacks)
 814 {
 815         const char      *name;
 816         struct dirent   **dent;
 817         struct stat     st;
 818         char            *ln_target = NULL;
 819         unsigned int    save_inode;
 820         ext2_ino_t      ino;
 821         errcode_t       retval = 0;
 822         int             read_cnt;
 823         int             hdlink;
 824         size_t          cur_dir_path_len;
 825         int             i, num_dents;
 826
 827         if (chdir(source_dir) < 0) {
 828                 retval = errno;
 829                 com_err(__func__, retval,
 830                         _("while changing working directory to \"%s\""),
 831                         source_dir);
 832                 return retval;
 833         }
 834
 835         num_dents = scandir(".", &dent, NULL, alphasort);
 836
 837         if (num_dents < 0) {
 838                 retval = errno;
 839                 com_err(__func__, retval,
 840                         _("while scanning directory \"%s\""), source_dir);
 841                 return retval;
 842         }
 843
 844         for (i = 0; i < num_dents; free(dent[i]), i++) {
 845                 name = dent[i]->d_name;
 846                 if ((!strcmp(name, ".")) || (!strcmp(name, "..")))
 847                         continue;
 848                 if (lstat(name, &st)) {
 849                         retval = errno;
 850                         com_err(__func__, retval, _("while lstat \"%s\""),
 851                                 name);
 852                         goto out;
 853                 }
 854
 855                 /* Check for hardlinks */
 856                 save_inode = 0;
 857                 if (!S_ISDIR(st.st_mode) && !S_ISLNK(st.st_mode) &&
 858                     st.st_nlink > 1) {
 859                         hdlink = is_hardlink(hdlinks, st.st_dev, st.st_ino);
 860                         if (hdlink >= 0) {
 861                                 retval = add_link(fs, parent_ino,
 862                                                   hdlinks->hdl[hdlink].dst_ino,
 863                                                   name);
 864                                 if (retval) {
 865                                         com_err(__func__, retval,
 866                                                 "while linking %s", name);
 867                                         goto out;
 868                                 }
 869                                 continue;
 870                         } else
 871                                 save_inode = 1;
 872                 }
 873
 874                 cur_dir_path_len = target->path_len;
 875                 retval = path_append(target, name);
 876                 if (retval) {
 877                         com_err(__func__, retval,
 878                                 "while appending %s", name);
 879                         goto out;
 880                 }
 881
 882                 if (fs_callbacks && fs_callbacks->create_new_inode) {
 883                         retval = fs_callbacks->create_new_inode(fs,
 884                                 target->path, name, parent_ino, root,
 885                                 st.st_mode & S_IFMT);
 886                         if (retval)
 887                                 goto out;
 888                 }
 889
 890                 switch(st.st_mode & S_IFMT) {
 891                 case S_IFCHR:
 892                 case S_IFBLK:
 893                 case S_IFIFO:
 894 #ifndef _WIN32
 895                 case S_IFSOCK:
 896                         retval = do_mknod_internal(fs, parent_ino, name,
 897                                                    st.st_mode, st.st_rdev);
 898                         if (retval) {
 899                                 com_err(__func__, retval,
 900                                         _("while creating special file "
 901                                           "\"%s\""), name);
 902                                 goto out;
 903                         }
 904                         break;
 905                 case S_IFLNK:
 906                         ln_target = malloc(st.st_size + 1);
 907                         if (ln_target == NULL) {
 908                                 com_err(__func__, retval,
 909                                         _("malloc failed"));
 910                                 goto out;
 911                         }
 912                         read_cnt = readlink(name, ln_target,
 913                                             st.st_size + 1);
 914                         if (read_cnt == -1) {
 915                                 retval = errno;
 916                                 com_err(__func__, retval,
 917                                         _("while trying to read link \"%s\""),
 918                                         name);
 919                                 free(ln_target);
 920                                 goto out;
 921                         }
 922                         if (read_cnt > st.st_size) {
 923                                 com_err(__func__, retval,
 924                                         _("symlink increased in size "
 925                                           "between lstat() and readlink()"));
 926                                 free(ln_target);
 927                                 goto out;
 928                         }
 929                         ln_target[read_cnt] = '\0';
 930                         retval = do_symlink_internal(fs, parent_ino, name,
 931                                                      ln_target, root);
 932                         free(ln_target);
 933                         if (retval) {
 934                                 com_err(__func__, retval,
 935                                         _("while writing symlink\"%s\""),
 936                                         name);
 937                                 goto out;
 938                         }
 939                         break;
 940 #endif
 941                 case S_IFREG:
 942                         retval = do_write_internal(fs, parent_ino, name, name,
 943                                                    root);
 944                         if (retval) {
 945                                 com_err(__func__, retval,
 946                                         _("while writing file \"%s\""), name);
 947                                 goto out;
 948                         }
 949                         break;
 950                 case S_IFDIR:
 951                         /* Don't choke on /lost+found */
 952                         if (parent_ino == EXT2_ROOT_INO &&
 953                             strcmp(name, "lost+found") == 0)
 954                                 goto find_lnf;
 955                         retval = do_mkdir_internal(fs, parent_ino, name,
 956                                                    root);
 957                         if (retval) {
 958                                 com_err(__func__, retval,
 959                                         _("while making dir \"%s\""), name);
 960                                 goto out;
 961                         }
 962 find_lnf:
 963                         retval = ext2fs_namei(fs, root, parent_ino,
 964                                               name, &ino);
 965                         if (retval) {
 966                                 com_err(name, retval, 0);
 967                                         goto out;
 968                         }
 969                         /* Populate the dir recursively*/
 970                         retval = __populate_fs(fs, ino, name, root, hdlinks,
 971                                                target, fs_callbacks);
 972                         if (retval)
 973                                 goto out;
 974                         if (chdir("..")) {
 975                                 retval = errno;
 976                                 com_err(__func__, retval,
 977                                         _("while changing directory"));
 978                                 goto out;
 979                         }
 980                         break;
 981                 default:
 982                         com_err(__func__, 0,
 983                                 _("ignoring entry \"%s\""), name);
 984                 }
 985
 986                 retval =  ext2fs_namei(fs, root, parent_ino, name, &ino);
 987                 if (retval) {
 988                         com_err(name, retval, _("while looking up \"%s\""),
 989                                 name);
 990                         goto out;
 991                 }
 992
 993                 retval = set_inode_extra(fs, ino, &st);
 994                 if (retval) {
 995                         com_err(__func__, retval,
 996                                 _("while setting inode for \"%s\""), name);
 997                         goto out;
 998                 }
 999
1000                 retval = set_inode_xattr(fs, ino, name);
1001                 if (retval) {
1002                         com_err(__func__, retval,
1003                                 _("while setting xattrs for \"%s\""), name);
1004                         goto out;
1005                 }
1006
1007                 if (fs_callbacks && fs_callbacks->end_create_new_inode) {
1008                         retval = fs_callbacks->end_create_new_inode(fs,
1009                                 target->path, name, parent_ino, root,
1010                                 st.st_mode & S_IFMT);
1011                         if (retval)
1012                                 goto out;
1013                 }
1014
1015                 /* Save the hardlink ino */
1016                 if (save_inode) {
1017                         /*
1018                          * Check whether need more memory, and we don't need
1019                          * free() since the lifespan will be over after the fs
1020                          * populated.
1021                          */
1022                         if (hdlinks->count == hdlinks->size) {
1023                                 void *p = realloc(hdlinks->hdl,
1024                                                 (hdlinks->size + HDLINK_CNT) *
1025                                                 sizeof(struct hdlink_s));
1026                                 if (p == NULL) {
1027                                         retval = EXT2_ET_NO_MEMORY;
1028                                         com_err(name, retval,
1029                                                 _("while saving inode data"));
1030                                         goto out;
1031                                 }
1032                                 hdlinks->hdl = p;
1033                                 hdlinks->size += HDLINK_CNT;
1034                         }
1035                         hdlinks->hdl[hdlinks->count].src_dev = st.st_dev;
1036                         hdlinks->hdl[hdlinks->count].src_ino = st.st_ino;
1037                         hdlinks->hdl[hdlinks->count].dst_ino = ino;
1038                         hdlinks->count++;
1039                 }
1040                 target->path_len = cur_dir_path_len;
1041                 target->path[target->path_len] = 0;
1042         }
1043
1044 out:
1045         for (; i < num_dents; free(dent[i]), i++);
1046         free(dent);
1047         return retval;
1048 }
1049
1050 errcode_t populate_fs2(ext2_filsys fs, ext2_ino_t parent_ino,
1051                        const char *source_dir, ext2_ino_t root,
1052                        struct fs_ops_callbacks *fs_callbacks)
1053 {
1054         struct file_info file_info;
1055         struct hdlinks_s hdlinks;
1056         errcode_t retval;
1057
1058         if (!(fs->flags & EXT2_FLAG_RW)) {
1059                 com_err(__func__, 0, "Filesystem opened readonly");
1060                 return EROFS;
1061         }
1062
1063         hdlinks.count = 0;
1064         hdlinks.size = HDLINK_CNT;
1065         hdlinks.hdl = realloc(NULL, hdlinks.size * sizeof(struct hdlink_s));
1066         if (hdlinks.hdl == NULL) {
1067                 retval = errno;
1068                 com_err(__func__, retval, _("while allocating memory"));
1069                 return retval;
1070         }
1071
1072         file_info.path_len = 0;
1073         file_info.path_max_len = 255;
1074         file_info.path = calloc(file_info.path_max_len, 1);
1075
1076         retval = set_inode_xattr(fs, root, source_dir);
1077         if (retval) {
1078                 com_err(__func__, retval,
1079                         _("while copying xattrs on root directory"));
1080                 goto out;
1081         }
1082
1083         retval = __populate_fs(fs, parent_ino, source_dir, root, &hdlinks,
1084                                &file_info, fs_callbacks);
1085
1086 out:
1087         free(file_info.path);
1088         free(hdlinks.hdl);
1089         return retval;
1090 }
1091
1092 errcode_t populate_fs(ext2_filsys fs, ext2_ino_t parent_ino,
1093                       const char *source_dir, ext2_ino_t root)
1094 {
1095         return populate_fs2(fs, parent_ino, source_dir, root, NULL);
1096 }