Hacktoberfest 2026: as issues que os mantenedores marcaram para outubro, abertas e boas para iniciantes. Ver issues do Hacktoberfest

`add_file_from_memory` silently fails for symbolic links

Aberta
  • Algo errado?
#143 0 comentários 0 reações 0 responsáveis Ver no GitHub

Ninguém assumiu esta issue ainda.

Avaliação

Dificuldade
3/5
Tempo estimado
1-2 dias
Facilidade para iniciantes
52/100
Tipo de issue
Bug
Clareza
Razoavelmente clara
Status de atividade
Estagnada
Stack de tecnologia
python
Domínio
backend

Direção de pesquisa

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.

Escrita pelo modelo de indexação a partir do texto da issue.

Descrição

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.

Linguagem predominante
Python
Estrelas
84
Forks
41
Merge médio
6d 12h
PRs com merge (30d)
1

Preparar o ambiente

Este projeto não oferece contêiner de desenvolvimento, Dockerfile nem guia de contribuição, então a configuração fica por sua conta: comece pelo README e veja nosso guia da primeira contribuição para os passos gerais.

Primeiros passos

  1. Leia a issue inteira e depois o guia de contribuição do projeto.
  2. Comente na issue dizendo que vai assumir — evita que duas pessoas façam o mesmo trabalho.
  3. Faça um fork do repositório e trabalhe em uma branch.
  4. Abra um pull request que referencie o número da issue.

Mais de Changaco/python-libarchive-c

Todas as issues de Changaco/python-libarchive-c

Issues semelhantes

Mais issues de Python

Receba novas issues na sua caixa de entrada

Um resumo curto de issues do GitHub para quem está começando.