lib/ext2fs/symlink.c

   1 /*
   2  * symlink.c --- make a symlink in the filesystem, based on mkdir.c
   3  *
   4  * Copyright (c) 2012, Intel Corporation.
   5  * All Rights Reserved.
   6  *
   7  * %Begin-Header%
   8  * This file may be redistributed under the terms of the GNU Library
   9  * General Public License, version 2.
  10  * %End-Header%
  11  */
  12
  13 #include "config.h"
  14 #include <stdio.h>
  15 #include <string.h>
  16 #if HAVE_UNISTD_H
  17 #include <unistd.h>
  18 #endif
  19 #include <fcntl.h>
  20 #include <time.h>
  21 #if HAVE_SYS_STAT_H
  22 #include <sys/stat.h>
  23 #endif
  24 #if HAVE_SYS_TYPES_H
  25 #include <sys/types.h>
  26 #endif
  27
  28 #include "ext2_fs.h"
  29 #include "ext2fs.h"
  30
  31 #ifndef HAVE_STRNLEN
  32 /*
  33  * Incredibly, libc5 doesn't appear to have strnlen.  So we have to
  34  * provide our own.
  35  */
  36 static int my_strnlen(const char * s, int count)
  37 {
  38         const char *cp = s;
  39
  40         while (count-- && *cp)
  41                 cp++;
  42         return cp - s;
  43 }
  44 #define strnlen(str, x) my_strnlen((str),(x))
  45 #endif
  46
  47 errcode_t ext2fs_symlink(ext2_filsys fs, ext2_ino_t parent, ext2_ino_t ino,
  48                          const char *name, const char *target)
  49 {
  50         errcode_t               retval;
  51         struct ext2_inode       inode;
  52         ext2_ino_t              scratch_ino;
  53         blk64_t                 blk;
  54         int                     fastlink, inlinelink;
  55         unsigned int            target_len;
  56         char                    *block_buf = 0;
  57         int                     drop_refcount = 0;
  58
  59         EXT2_CHECK_MAGIC(fs, EXT2_ET_MAGIC_EXT2FS_FILSYS);
  60
  61         /*
  62          * The Linux kernel doesn't allow for links longer than a block
  63          * (counting the NUL terminator)
  64          */
  65         target_len = strnlen(target, fs->blocksize + 1);
  66         if (target_len >= fs->blocksize) {
  67                 retval = EXT2_ET_INVALID_ARGUMENT;
  68                 goto cleanup;
  69         }
  70
  71         /*
  72          * Allocate a data block for slow links
  73          */
  74         retval = ext2fs_get_mem(fs->blocksize, &block_buf);
  75         if (retval)
  76                 goto cleanup;
  77         memset(block_buf, 0, fs->blocksize);
  78         strncpy(block_buf, target, fs->blocksize);
  79
  80         memset(&inode, 0, sizeof(struct ext2_inode));
  81         fastlink = (target_len < sizeof(inode.i_block));
  82         if (!fastlink) {
  83                 retval = ext2fs_new_block2(fs, ext2fs_find_inode_goal(fs, ino,
  84                                                                       &inode,
  85                                                                       0),
  86                                            NULL, &blk);
  87                 if (retval)
  88                         goto cleanup;
  89         }
  90
  91         /*
  92          * Allocate an inode, if necessary
  93          */
  94         if (!ino) {
  95                 retval = ext2fs_new_inode(fs, parent, LINUX_S_IFLNK | 0755,
  96                                           0, &ino);
  97                 if (retval)
  98                         goto cleanup;
  99         }
 100
 101         /*
 102          * Create the inode structure....
 103          */
 104         inode.i_mode = LINUX_S_IFLNK | 0777;
 105         inode.i_uid = inode.i_gid = 0;
 106         inode.i_links_count = 1;
 107         ext2fs_inode_size_set(fs, &inode, target_len);
 108         /* The time fields are set by ext2fs_write_new_inode() */
 109
 110         inlinelink = !fastlink && ext2fs_has_feature_inline_data(fs->super);
 111         if (fastlink) {
 112                 /* Fast symlinks, target stored in inode */
 113                 strcpy((char *)&inode.i_block, target);
 114         } else if (inlinelink) {
 115                 /* Try inserting an inline data symlink */
 116                 inode.i_flags |= EXT4_INLINE_DATA_FL;
 117                 retval = ext2fs_write_new_inode(fs, ino, &inode);
 118                 if (retval)
 119                         goto cleanup;
 120                 retval = ext2fs_inline_data_set(fs, ino, &inode, block_buf,
 121                                                 target_len);
 122                 if (retval) {
 123                         inode.i_flags &= ~EXT4_INLINE_DATA_FL;
 124                         inlinelink = 0;
 125                         goto need_block;
 126                 }
 127                 retval = ext2fs_read_inode(fs, ino, &inode);
 128                 if (retval)
 129                         goto cleanup;
 130         } else {
 131 need_block:
 132                 /* Slow symlinks, target stored in the first block */
 133                 ext2fs_iblk_set(fs, &inode, 1);
 134                 if (ext2fs_has_feature_extents(fs->super)) {
 135                         /*
 136                          * The extent bmap is setup after the inode and block
 137                          * have been written out below.
 138                          */
 139                         inode.i_flags |= EXT4_EXTENTS_FL;
 140                 }
 141         }
 142
 143         /*
 144          * Write out the inode and inode data block.  The inode generation
 145          * number is assigned by write_new_inode, which means that the
 146          * operations using ino must come after it.
 147          */
 148         if (inlinelink)
 149                 retval = ext2fs_write_inode(fs, ino, &inode);
 150         else
 151                 retval = ext2fs_write_new_inode(fs, ino, &inode);
 152         if (retval)
 153                 goto cleanup;
 154
 155         if (!fastlink && !inlinelink) {
 156                 retval = ext2fs_bmap2(fs, ino, &inode, NULL, BMAP_SET, 0, NULL,
 157                                       &blk);
 158                 if (retval)
 159                         goto cleanup;
 160
 161                 retval = io_channel_write_blk64(fs->io, blk, 1, block_buf);
 162                 if (retval)
 163                         goto cleanup;
 164         }
 165
 166         /*
 167          * Update accounting....
 168          */
 169         if (!fastlink && !inlinelink)
 170                 ext2fs_block_alloc_stats2(fs, blk, +1);
 171         ext2fs_inode_alloc_stats2(fs, ino, +1, 0);
 172         drop_refcount = 1;
 173
 174         /*
 175          * Link the symlink into the filesystem hierarchy
 176          */
 177         if (name) {
 178                 retval = ext2fs_lookup(fs, parent, name, strlen(name), 0,
 179                                        &scratch_ino);
 180                 if (!retval) {
 181                         retval = EXT2_ET_FILE_EXISTS;
 182                         goto cleanup;
 183                 }
 184                 if (retval != EXT2_ET_FILE_NOT_FOUND)
 185                         goto cleanup;
 186                 retval = ext2fs_link(fs, parent, name, ino, EXT2_FT_SYMLINK);
 187                 if (retval)
 188                         goto cleanup;
 189         }
 190         drop_refcount = 0;
 191
 192 cleanup:
 193         if (block_buf)
 194                 ext2fs_free_mem(&block_buf);
 195         if (drop_refcount) {
 196                 if (!fastlink && !inlinelink)
 197                         ext2fs_block_alloc_stats2(fs, blk, -1);
 198                 ext2fs_inode_alloc_stats2(fs, ino, -1, 0);
 199         }
 200         return retval;
 201 }
 202
 203 /*
 204  * Test whether an inode is a fast symlink.
 205  *
 206  * A fast symlink has its symlink data stored in inode->i_block.
 207  */
 208 int ext2fs_is_fast_symlink(struct ext2_inode *inode)
 209 {
 210         return LINUX_S_ISLNK(inode->i_mode) && EXT2_I_SIZE(inode) &&
 211                EXT2_I_SIZE(inode) < sizeof(inode->i_block);
 212 }