view release on metacpan or  search on metacpan

lib/Archive/Ar/Libarchive.xs  view on Meta::CPAN

_write_to_callback(self, callback)
    struct ar *self
    SV *callback
  CODE:
    struct archive *archive;
    int r;

    self->callback = SvREFCNT_inc(callback);

    archive = archive_write_new();
    if(self->opt_type == ARCHIVE_AR_BSD)
      r = archive_write_set_format_ar_bsd(archive);
    else
      r = archive_write_set_format_ar_svr4(archive);
    if(r != ARCHIVE_OK)
      _error(self,archive_error_string(archive));
    archive_write_set_bytes_in_last_block(archive, 1);
    r = archive_write_open(archive, (void*)self, NULL, ar_write_callback, ar_close_callback);
    if(r != ARCHIVE_OK)
      _error(self,archive_error_string(archive));
    if(r == ARCHIVE_OK || r == ARCHIVE_WARN)
      RETVAL = ar_write_archive(archive, self);
    else
      RETVAL = 0;
    archive_write_free(archive);
    SvREFCNT_dec(callback);
    self->callback = NULL;
  OUTPUT:
    RETVAL

int
_remove(self,pathname)
    struct ar *self
    const char *pathname
  CODE:
    struct ar_entry **entry;
    entry = &(self->first);

    RETVAL = 0;

    while(1)
    {
      if(!strcmp(archive_entry_pathname((*entry)->entry),pathname))
      {
        ar_free_entry(*entry);
        *entry = (*entry)->next;
        RETVAL = 1;
        break;
      }

      if((*entry)->next == NULL)
        break;

      entry = &((*entry)->next);
    }

  OUTPUT:
    RETVAL

void
_add_data(self,filename,data,uid,gid,date,mode)
    struct ar *self
    const char *filename
    SV *data
    __LA_INT64_T uid
    __LA_INT64_T gid
    time_t date
    int mode
  CODE:
    struct ar_entry **entry;
    char *buffer;

    entry = &(self->first);

    while(*entry != NULL)
    {
      entry = &((*entry)->next);
    }

    Newx((*entry), 1, struct ar_entry);

    (*entry)->entry = archive_entry_new();
    archive_entry_set_pathname((*entry)->entry, filename);
    archive_entry_set_uid((*entry)->entry, uid);
    archive_entry_set_gid((*entry)->entry, gid);
    archive_entry_set_mtime((*entry)->entry, date, date);
    archive_entry_set_mode((*entry)->entry, mode);

    (*entry)->next          = NULL;
    (*entry)->is_symbol_table = 0;
    if(self->opt_symbols != NULL && !strcmp(SvPV_nolen(self->opt_symbols), filename))
      (*entry)->is_symbol_table = 1;

    buffer = SvPV(data, (*entry)->data_size);
    archive_entry_set_size((*entry)->entry, (*entry)->data_size);

    Newx((*entry)->data, (*entry)->data_size, char);
    Copy(buffer, (*entry)->data, (*entry)->data_size, char);


SV *
_list_files(self)
    struct ar *self
  CODE:
    AV *list;
    struct ar_entry *entry;
    const char *pathname;

    list = newAV();

    for(entry = self->first; entry != NULL; entry = entry->next)
    {
      pathname = archive_entry_pathname(entry->entry);
      av_push(list, newSVpv(pathname, strlen(pathname)));
    }

    RETVAL = newRV_noinc((SV*)list);
  OUTPUT:
    RETVAL

void
DESTROY(self)
    struct ar *self
  CODE:
    ar_reset(self);
    Safefree(self);

SV *
get_content(self, filename)
    struct ar *self
    const char *filename
  CODE:
    struct ar_entry *entry;
    HV *hv;
    int found;

    entry = ar_find_by_name(self, filename);

    if(entry != NULL)
    {
      hv = newHV();
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-value"
      hv_store(hv, "name", 4, newSVpv(filename, strlen(filename)),         0);
      hv_store(hv, "date", 4, newSVi64(archive_entry_mtime(entry->entry)), 0);
      hv_store(hv, "uid",  3, newSVi64(archive_entry_uid(entry->entry)),   0);
      hv_store(hv, "gid",  3, newSVi64(archive_entry_gid(entry->entry)),   0);
      hv_store(hv, "mode", 4, newSViv(archive_entry_mode(entry->entry)),   0);
      hv_store(hv, "size", 4, newSViv(entry->data_size),                   0);
      hv_store(hv, "data", 4, newSVpv(entry->data, entry->data_size),      0);
#pragma clang diagnostic pop
      RETVAL = newRV_noinc((SV*)hv);

    }
    else
    {
      XSRETURN_EMPTY;
    }
  OUTPUT:
    RETVAL

SV *
get_data(self, filename)
    struct ar *self
    const char *filename
  CODE:
    struct ar_entry *entry;
    entry = ar_find_by_name(self, filename);
    if(entry == NULL)
      XSRETURN_EMPTY;
    RETVAL = newSVpv(entry->data, entry->data_size);
  OUTPUT:
    RETVAL


void
rename(self, old, new)
    struct ar *self
    const char *old
    const char *new
  CODE:
    struct ar_entry *entry;
    entry = ar_find_by_name(self, old);
    if(entry != NULL)
      archive_entry_set_pathname(entry->entry, new);

int
extract(self)
    struct ar *self
  CODE:
    struct ar_entry *entry;
    struct archive *disk;
    int ok = 1;

    entry = self->first;

    disk = archive_write_disk_new();
    archive_write_disk_set_options(disk, ar_disk_options(self));
    archive_write_disk_set_standard_lookup(disk);

    while(entry != NULL)
    {
      if(ar_entry_extract(self, entry, disk) == 0)
      {
        ok = 0;
        break;
      }

lib/Archive/Ar/Libarchive.xs  view on Meta::CPAN

    if(ok)
      RETVAL = 1;
    else
      XSRETURN_EMPTY;

  OUTPUT:
    RETVAL


int
type(self)
    struct ar *self
  CODE:
    RETVAL = self->opt_type;
  OUTPUT:
    RETVAL


int
contains_file(self, filename)
    struct ar *self
    const char *filename
  CODE:
    if(ar_find_by_name(self, filename))
      RETVAL = 1;
    else
      XSRETURN_EMPTY;
  OUTPUT:
    RETVAL


void
clear(self)
    struct ar *self
  CODE:
    ar_reset(self);


int
_chmod(self, filename, mode)
    struct ar *self
    const char *filename
    int mode
  CODE:
    struct ar_entry *entry;
    entry = ar_find_by_name(self, filename);
    if(entry != NULL)
    {
      archive_entry_set_mode(entry->entry, mode);
      RETVAL = 1;
    }
    else
    {
      XSRETURN_EMPTY;
    }
  OUTPUT:
    RETVAL


int
_chown(self, filename, uid, gid)
    struct ar *self
    const char *filename
    int uid
    SV *gid
  CODE:
    struct ar_entry *entry;
    entry = ar_find_by_name(self, filename);
    if(entry != NULL)
    {
      if(uid >= 0)
        archive_entry_set_uid(entry->entry, uid);
      if(SvOK(gid) && SvIV(gid) >= 0)
      {
        archive_entry_set_gid(entry->entry, SvIV(gid));
      }
    }
    else
    {
      XSRETURN_EMPTY;
    }

const char *
_libarchive_version()
  CODE:
    RETVAL = ARCHIVE_VERSION_STRING;
  OUTPUT:
    RETVAL