`add_file_from_memory` silently fails for symbolic links

Ouverte
  • Quelque chose ne va pas ?
#143 0 commentaires 0 réactions 0 personnes assignées Voir sur GitHub

Personne n'a encore pris cette issue.

Évaluation

Difficulté
3/5
Temps estimé
1-2 jours
Accessibilité débutants
52/100
Type d'issue
Bug
Clarté
Plutôt claire
Activité
À l'abandon
Stack technique
python
Domaine
backend

Piste de recherche

Start with the linkpath setter in libarchive/entry.py and trace how add_file_from_memory prepares entries for the CPIO writer. The report identifies entry_set_symlink as a possible fix and explains that older system libarchive versions may lack entry_set_link_to_symlink. Check the behavior with the reproduction script; done means the resulting CPIO entry retains the symlink target and its size.

Rédigé par le modèle d'indexation à partir du texte de l'issue.

Description

When creating CPIO archives, symlinks are discarded.

How to reproduce?

I created this simple test:

import libarchive
from ctypes import c_void_p

def print_archive_info(test_name, archive_bytes):
    print(test_name)
    with libarchive.memory_reader(archive_bytes) as archive:
        for entry in archive:
            print(f"    entry.path: {entry.path}")
            print(f"    entry.size: {entry.size}")
            print(f"    entry.filetype: 0o{entry.filetype:o}")
            print(f"    entry.linkpath: {entry.linkpath}")

packed_chunks = []

def write_func(data):
    packed_chunks.append(bytes(data))
    return len(data)

path = "sbin"
linkpath = "usr/sbin"
entry_size = len(linkpath)

with libarchive.custom_writer(write_func, "cpio_newc") as archive:
    archive.add_file_from_memory(
        entry_path=path,
        entry_size=len(linkpath),
        entry_data=b"",
        filetype=libarchive.entry.FileType.SYMBOLINK_LINK,
        linkpath=linkpath.encode("utf-8"),
    )

packed_bytes = b"".join(packed_chunks)
print_archive_info("libarchive standard method:", packed_bytes)

# fix that works:
packed_chunks = []

with libarchive.custom_writer(write_func, "cpio_newc") as archive:
    new_entry = libarchive.entry.ArchiveEntry(
        pathname=path,
        size=len(linkpath),
        filetype=libarchive.entry.FileType.SYMBOLINK_LINK,
        linkpath=linkpath.encode("utf-8"),
    )
    libarchive.ffi.ffi('entry_set_symlink', [c_void_p], None)
    libarchive.ffi.entry_set_symlink(new_entry._entry_p, linkpath.encode("utf-8"))
    libarchive.ffi.write_header(archive._pointer, new_entry._entry_p)
    libarchive.ffi.write_finish_entry(archive._pointer)

packed_bytes = b"".join(packed_chunks)
print_archive_info("libarchive fix method:", packed_bytes)

Which outputs the following:

$ python3 libarchive_symlink.py
libarchive standard method:
    entry.path: sbin
    entry.size: 0
    entry.filetype: 0o120000
    entry.linkpath:
libarchive fix method:
    entry.path: sbin
    entry.size: 8
    entry.filetype: 0o120000
    entry.linkpath: usr/sbin

You can see that using add_file_from_memory with the linkpath argument, the resulting symlink size is 0, and the symlink doesn't actually point to anything.

Investigations

I spent some time investigated this. Here is what happens when using add_file_from_memory:

  • in the @linkpath.setter, ffi.entry_update_link_utf8(self._entry_p, value) is called
    • in libarchive, this corresponds to archive_entry_update_link_utf8. As some other comments hint: "Set symlink if symlink is already set, else set hardlink". So at this point it sets the file to a hardlink.
  • when the entry header is created, the CPIO writer runs into this in write_header:
	/* Non-regular files don't store bodies. */
	if (archive_entry_filetype(entry) != AE_IFREG)
		archive_entry_set_size(entry, 0);
  • then only if the file is a symlink, it will get its size and write the linkpath, etc
  • as we mentioned, our file is a hardlink at this point, so its size gets set to 0, and no linkpath is inserted

Fix

As you can see in the test script above, I found a fix for this issue: if we call ffi.entry_set_symlink before writing the header file, then the file is converted from hardlink to symlink, and the CPIO writer actually writes the right size and linkpath as you would expect.

This entry_set_symlink needs to be imported from the C libarchive library. entry_set_link_to_symlink is also available in the latest libarchive, which would avoid having to copy the linkpath again. But older libarchive binaries won't have this function (was testing on MacOS 15.7.1 and the system libarchive didn't have it), which is why I used entry_set_symlink.

I am not sure if this issue also affect other format writers other than CPIO. If so, I think the call to entry_set_symlink could happen at the end of @linkpath.setter. If this issue is specific to the CPIO writers, then a more targeted fix should be developed.

Langage dominant
Python
Étoiles
84
Forks
41
Merge moyen
6 j 12 h
PR mergées (30 j)
1

Préparer son environnement

Ce projet ne fournit ni conteneur de développement, ni Dockerfile, ni guide de contribution : l'installation est à votre charge. Commencez par son README, et consultez notre guide de la première contribution pour les étapes générales.

Par où commencer

  1. Lisez l'issue en entier, puis le guide de contribution du projet.
  2. Signalez en commentaire que vous la prenez — cela évite que deux personnes fassent le même travail.
  3. Forkez le dépôt et travaillez sur une branche.
  4. Ouvrez une pull request qui référence le numéro de l'issue.

Autres issues de Changaco/python-libarchive-c

Toutes les issues de Changaco/python-libarchive-c

Issues similaires

Plus d'issues Python

Recevez les nouvelles issues par e-mail

Un résumé court des issues GitHub adaptées aux débutants.