Version 1.2.1
[wimlib] / src / symlink.c
index aa54e6b..ccdd6f5 100644 (file)
@@ -1,24 +1,30 @@
+/*
+ * symlink.c
+ *
+ * Code to read and set symbolic links in WIM files.
+ */
+
 /*
  * Copyright (C) 2012 Eric Biggers
  *
  * This file is part of wimlib, a library for working with WIM files.
  *
  * wimlib is free software; you can redistribute it and/or modify it under the
- * terms of the GNU Lesser General Public License as published by the Free
- * Software Foundation; either version 2.1 of the License, or (at your option)
+ * terms of the GNU General Public License as published by the Free
+ * Software Foundation; either version 3 of the License, or (at your option)
  * any later version.
  *
  * wimlib is distributed in the hope that it will be useful, but WITHOUT ANY
  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
- * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
+ * A PARTICULAR PURPOSE. See the GNU General Public License for more
  * details.
  *
- * You should have received a copy of the GNU Lesser General Public License
+ * You should have received a copy of the GNU General Public License
  * along with wimlib; if not, see http://www.gnu.org/licenses/.
  */
 
 #include "dentry.h"
-#include "io.h"
+#include "buffer_io.h"
 #include "lookup_table.h"
 #include "sha1.h"
 #include <errno.h>
@@ -74,9 +80,16 @@ static ssize_t get_symlink_name(const u8 *resource, size_t resource_len,
        }
        if (header_size + substitute_name_offset + substitute_name_len > resource_len)
                return -EIO;
-       link_target = utf16_to_utf8(p + substitute_name_offset,
-                                   substitute_name_len,
-                                   &link_target_len);
+
+       ret = utf16_to_utf8((const char *)p + substitute_name_offset,
+                           substitute_name_len,
+                           &link_target, &link_target_len);
+       if (ret == WIMLIB_ERR_INVALID_UTF16_STRING)
+               return -EILSEQ;
+       else if (ret == WIMLIB_ERR_NOMEM)
+               return -ENOMEM;
+
+       wimlib_assert(ret == 0);
 
        if (!link_target)
                return -EIO;
@@ -99,7 +112,12 @@ static ssize_t get_symlink_name(const u8 *resource, size_t resource_len,
                translated_target += 4;
                link_target_len -= 4;
                /* There's a drive letter, so just leave the backslashes since
-                * it won't go anyhwere on UNIX anyway... */
+                * it won't go anyhwere on UNIX anyway...
+                *
+                * XXX
+                * NTFS-3g tries to re-map these links to actually point to
+                * something, so maybe we could do something like that here
+                * XXX*/
        } else {
                for (size_t i = 0; i < link_target_len; i++)
                        if (translated_target[i] == '\\')
@@ -113,87 +131,72 @@ out:
        return ret;
 }
 
-void *make_symlink_reparse_data_buf(const char *symlink_target, size_t *len_ret)
+static int make_symlink_reparse_data_buf(const char *symlink_target,
+                                        size_t *len_ret, void **buf_ret)
 {
        size_t utf8_len = strlen(symlink_target);
+       char *name_utf16;
        size_t utf16_len;
-       char *name_utf16 = utf8_to_utf16(symlink_target, utf8_len, &utf16_len);
-       if (!name_utf16)
-               return NULL;
-       /*DEBUG("utf16_len = %zu", utf16_len);*/
+       int ret;
+
+       ret = utf8_to_utf16(symlink_target, utf8_len,
+                           &name_utf16, &utf16_len);
+       if (ret != 0)
+               return ret;
+
        for (size_t i = 0; i < utf16_len / 2; i++)
-               if (((u16*)name_utf16)[i] == to_le16('/'))
-                       ((u16*)name_utf16)[i] = to_le16('\\');
+               if (((u16*)name_utf16)[i] == cpu_to_le16('/'))
+                       ((u16*)name_utf16)[i] = cpu_to_le16('\\');
        size_t len = 12 + utf16_len * 2;
        void *buf = MALLOC(len);
-       if (!buf)
-               goto out;
-       /* XXX Fix absolute paths */
-
-       u8 *p = buf;
-       p = put_u16(p, utf16_len); /* Substitute name offset */
-       p = put_u16(p, utf16_len); /* Substitute name length */
-       p = put_u16(p, 0); /* Print name offset */
-       p = put_u16(p, utf16_len); /* Print name length */
-       p = put_u32(p, 1);
-       p = put_bytes(p, utf16_len, name_utf16);
-       p = put_bytes(p, utf16_len, name_utf16);
-       /*DEBUG("utf16_len = %zu, len = %zu", utf16_len, len);*/
-       *len_ret = len;
-out:
+       if (buf) {
+               u8 *p = buf;
+               p = put_u16(p, utf16_len); /* Substitute name offset */
+               p = put_u16(p, utf16_len); /* Substitute name length */
+               p = put_u16(p, 0); /* Print name offset */
+               p = put_u16(p, utf16_len); /* Print name length */
+               p = put_u32(p, 1); /* flags: 0 iff *full* target, including drive letter??? */
+               p = put_bytes(p, utf16_len, (const u8*)name_utf16);
+               p = put_bytes(p, utf16_len, (const u8*)name_utf16);
+               *len_ret = len;
+               *buf_ret = buf;
+               ret = 0;
+       } else {
+               ret = WIMLIB_ERR_NOMEM;
+       }
        FREE(name_utf16);
-       return buf;
+       return ret;
 }
 
 /* Get the symlink target from a dentry.
  *
  * The dentry may be either "real" symlink or a junction point.
  */
-ssize_t dentry_readlink(const struct dentry *dentry, char *buf, size_t buf_len,
-                       const WIMStruct *w)
+ssize_t inode_readlink(const struct inode *inode, char *buf, size_t buf_len,
+                      const WIMStruct *w, int read_resource_flags)
 {
        const struct lookup_table_entry *lte;
        int ret;
 
-       wimlib_assert(dentry_is_symlink(dentry));
+       wimlib_assert(inode_is_symlink(inode));
 
-       lte = dentry_first_lte(dentry, w->lookup_table);
+       lte = inode_unnamed_lte(inode, w->lookup_table);
        if (!lte)
                return -EIO;
 
        if (wim_resource_size(lte) > 10000)
                return -EIO;
 
-       char res_buf[wim_resource_size(lte)];
-       ret = read_full_wim_resource(lte, res_buf);
+       u8 res_buf[wim_resource_size(lte)];
+       ret = read_full_wim_resource(lte, res_buf, read_resource_flags);
        if (ret != 0)
                return -EIO;
        return get_symlink_name(res_buf, wim_resource_size(lte), buf,
-                               buf_len, dentry->reparse_tag);
+                               buf_len, inode->reparse_tag);
 }
 
-static int dentry_set_symlink_buf(struct dentry *dentry,
-                                 struct lookup_table_entry *lte)
-{
-       struct ads_entry *ads_entries;
-
-       ads_entries = CALLOC(2, sizeof(struct ads_entry));
-       if (!ads_entries)
-               return WIMLIB_ERR_NOMEM;
-
-       wimlib_assert(dentry->num_ads == 0);
-       wimlib_assert(dentry->ads_entries == NULL);
-
-       ads_entries[0].lte = lte;
-
-       /*dentry_free_ads_entries(dentry);*/
-       dentry->num_ads = 2;
-       dentry->ads_entries = ads_entries;
-       return 0;
-}
-
-/* 
- * Sets @dentry to be a symbolic link pointing to @target.
+/*
+ * Sets @inode to be a symbolic link pointing to @target.
  *
  * A lookup table entry for the symbolic link data buffer is created and
  * inserted into @lookup_table, unless there is an existing lookup table entry
@@ -203,9 +206,9 @@ static int dentry_set_symlink_buf(struct dentry *dentry,
  *
  * On failure @dentry and @lookup_table are not modified.
  */
-int dentry_set_symlink(struct dentry *dentry, const char *target,
-                      struct lookup_table *lookup_table,
-                      struct lookup_table_entry **lte_ret)
+int inode_set_symlink(struct inode *inode, const char *target,
+                     struct lookup_table *lookup_table,
+                     struct lookup_table_entry **lte_ret)
 
 {
        int ret;
@@ -213,14 +216,15 @@ int dentry_set_symlink(struct dentry *dentry, const char *target,
        struct lookup_table_entry *lte = NULL, *existing_lte;
        u8 symlink_buf_hash[SHA1_HASH_SIZE];
        void *symlink_buf;
-       
-       symlink_buf = make_symlink_reparse_data_buf(target, &symlink_buf_len);
-       if (!symlink_buf)
-               return WIMLIB_ERR_NOMEM;
+
+       ret = make_symlink_reparse_data_buf(target, &symlink_buf_len,
+                                           &symlink_buf);
+       if (ret != 0)
+               return ret;
 
        DEBUG("Made symlink reparse data buf (len = %zu, name len = %zu)",
                        symlink_buf_len, symlink_buf_len);
-       
+
        sha1_buffer(symlink_buf, symlink_buf_len, symlink_buf_hash);
 
        existing_lte = __lookup_resource(lookup_table, symlink_buf_hash);
@@ -240,16 +244,11 @@ int dentry_set_symlink(struct dentry *dentry, const char *target,
                lte->attached_buffer              = symlink_buf;
                lte->resource_entry.original_size = symlink_buf_len;
                lte->resource_entry.size          = symlink_buf_len;
-               lte->resource_entry.flags         = 0;
                copy_hash(lte->hash, symlink_buf_hash);
        }
 
-       ret = dentry_set_symlink_buf(dentry, lte);
-
-       if (ret != 0)
-               goto out_free_lte;
-
-       dentry->resolved = true;
+       inode->lte = lte;
+       inode->resolved = true;
 
        DEBUG("Loaded symlink buf");
 
@@ -260,9 +259,6 @@ int dentry_set_symlink(struct dentry *dentry, const char *target,
        if (lte_ret)
                *lte_ret = lte;
        return 0;
-out_free_lte:
-       if (lte != existing_lte)
-               FREE(lte);
 out_free_symlink_buf:
        FREE(symlink_buf);
        return ret;