static foreign_t archive_next_header(term_t archive, term_t name) { archive_wrapper *ar; int rc; if ( !get_archive(archive, &ar) ) return FALSE; if ( ar->status == AR_NEW_ENTRY ) archive_read_data_skip(ar->archive); if ( ar->status == AR_OPENED_ENTRY ) return PL_permission_error("next_header", "archive", archive); while ( (rc=archive_read_next_header(ar->archive, &ar->entry)) == ARCHIVE_OK ) { if ( PL_unify_wchars(name, PL_ATOM, -1, archive_entry_pathname_w(ar->entry)) ) { ar->status = AR_NEW_ENTRY; return TRUE; } if ( PL_exception(0) ) return FALSE; } if ( rc == ARCHIVE_EOF ) return FALSE; /* simply at the end */ return archive_error(ar); }
static foreign_t archive_property(term_t archive, term_t prop, term_t value) { archive_wrapper *ar; atom_t pn; const char *s; if ( !get_archive(archive, &ar) || !PL_get_atom_ex(prop, &pn) ) return FALSE; #ifdef HAVE_ARCHIVE_FILTER_COUNT if ( pn == ATOM_filter ) { int i, fcount = archive_filter_count(ar->archive); term_t tail = PL_copy_term_ref(value); term_t head = PL_new_term_ref(); for(i=0; i<fcount; i++) { s = archive_filter_name(ar->archive, i); if ( !s || strcmp(s, "none") == 0 ) continue; if ( !PL_unify_list(tail, head, tail) || !PL_unify_atom_chars(head, s) ) return FALSE; } return PL_unify_nil(tail); } #endif return FALSE; }
static foreign_t archive_open_entry(term_t archive, term_t stream) { archive_wrapper *ar; IOSTREAM *s; if ( !get_archive(archive, &ar) ) return FALSE; if ( (s=Snew(ar, SIO_INPUT|SIO_RECORDPOS, &ar_entry_functions)) ) { ar->status = AR_OPENED_ENTRY; if ( PL_unify_stream(stream, s) ) { PL_register_atom(ar->symbol); /* We may no longer reference the */ return TRUE; /* archive itself */ } Sclose(s); return FALSE; } return PL_resource_error("memory"); }
static foreign_t archive_close(term_t archive) { archive_wrapper *ar; int rc; if ( !get_archive(archive, &ar) ) return FALSE; if ( ar->status == AR_OPENED_ENTRY ) { ar->closed_archive = TRUE; return TRUE; } else if ( (rc=archive_read_free(ar->archive)) == ARCHIVE_OK ) { ar->entry = NULL; ar->archive = NULL; ar->symbol = 0; return TRUE; } return archive_error(ar); }
/* Decide if the dependency identified by item is in a onedir or onfile archive * then call the appropriate function. */ static int extractDependency(ARCHIVE_STATUS *status_list[], const char *item) { ARCHIVE_STATUS *status = NULL; char path[_MAX_PATH + 1]; char filename[_MAX_PATH + 1]; char srcpath[_MAX_PATH + 1]; char archive_path[_MAX_PATH + 1]; char *dirname = NULL; VS("Extracting dependencies\n"); if (splitName(path, filename, item) == -1) return -1; dirname = dirName(path); if (dirname[0] == 0) { free(dirname); return -1; } /* We need to identify three situations: 1) dependecies are in a onedir archive * next to the current onefile archive, 2) dependencies are in a onedir/onefile * archive next to the current onedir archive, 3) dependencies are in a onefile * archive next to the current onefile archive. */ VS("Checking if file exists\n"); if (checkFile(srcpath, "%s/%s/%s", status_list[SELF]->homepath, dirname, filename) == 0) { VS("File %s found, assuming is onedir\n", srcpath); if (copyDependencyFromDir(status_list[SELF], srcpath, filename) == -1) { FATALERROR("Error coping %s\n", filename); free(dirname); return -1; } } else if (checkFile(srcpath, "%s../%s/%s", status_list[SELF]->homepath, dirname, filename) == 0) { VS("File %s found, assuming is onedir\n", srcpath); if (copyDependencyFromDir(status_list[SELF], srcpath, filename) == -1) { FATALERROR("Error coping %s\n", filename); free(dirname); return -1; } } else { VS("File %s not found, assuming is onefile.\n", srcpath); if ((checkFile(archive_path, "%s%s.pkg", status_list[SELF]->homepath, path) != 0) && (checkFile(archive_path, "%s%s.exe", status_list[SELF]->homepath, path) != 0) && (checkFile(archive_path, "%s%s", status_list[SELF]->homepath, path) != 0)) { FATALERROR("Archive not found: %s\n", archive_path); return -1; } if ((status = get_archive(status_list, archive_path)) == NULL) { FATALERROR("Archive not found: %s\n", archive_path); return -1; } if (extractDependencyFromArchive(status, filename) == -1) { FATALERROR("Error extracting %s\n", filename); free(status); return -1; } } free(dirname); return 0; }
/** * backend_download_packages_thread: */ static gboolean backend_download_packages_thread (PkBackend *backend) { gchar **package_ids; string directory; package_ids = pk_backend_get_strv(backend, "package_ids"); directory = _config->FindDir("Dir::Cache::archives") + "partial/"; pk_backend_set_allow_cancel (backend, true); aptcc *m_apt = new aptcc(backend, _cancel); pk_backend_set_pointer(backend, "aptcc_obj", m_apt); if (m_apt->init()) { egg_debug ("Failed to create apt cache"); delete m_apt; pk_backend_finished (backend); return false; } pk_backend_set_status (backend, PK_STATUS_ENUM_QUERY); // Create the progress AcqPackageKitStatus Stat(m_apt, backend, _cancel); // get a fetcher pkgAcquire fetcher(&Stat); string filelist; gchar *pi; // TODO this might be useful when the item is in the cache // for (pkgAcquire::ItemIterator I = fetcher.ItemsBegin(); I < fetcher.ItemsEnd();) // { // if ((*I)->Local == true) // { // I++; // continue; // } // // // Close the item and check if it was found in cache // (*I)->Finished(); // if ((*I)->Complete == false) { // Transient = true; // } // // // Clear it out of the fetch list // delete *I; // I = fetcher.ItemsBegin(); // } for (uint i = 0; i < g_strv_length(package_ids); i++) { pi = package_ids[i]; if (pk_package_id_check(pi) == false) { pk_backend_error_code (backend, PK_ERROR_ENUM_PACKAGE_ID_INVALID, pi); delete m_apt; pk_backend_finished (backend); return false; } if (_cancel) { break; } pair<pkgCache::PkgIterator, pkgCache::VerIterator> pkg_ver; pkg_ver = m_apt->find_package_id(pi); // Ignore packages that could not be found or that exist only due to dependencies. if (pkg_ver.second.end() == true) { _error->Error("Can't find this package id \"%s\".", pi); continue; } else { if(!pkg_ver.second.Downloadable()) { _error->Error("No downloadable files for %s," "perhaps it is a local or obsolete" "package?", pi); continue; } string storeFileName; if (get_archive(&fetcher, m_apt->packageSourceList, m_apt->packageRecords, pkg_ver.second, directory, storeFileName)) { Stat.addPackagePair(pkg_ver); } string destFile = directory + "/" + flNotDir(storeFileName); if (filelist.empty()) { filelist = destFile; } else { filelist.append(";" + destFile); } } } if (fetcher.Run() != pkgAcquire::Continue && _cancel == false) // We failed and we did not cancel { show_errors(backend, PK_ERROR_ENUM_PACKAGE_DOWNLOAD_FAILED); delete m_apt; pk_backend_finished (backend); return _cancel; } // send the filelist pk_backend_files(backend, NULL, filelist.c_str()); delete m_apt; pk_backend_finished (backend); return true; }
static foreign_t archive_header_prop(term_t archive, term_t field) { archive_wrapper *ar; functor_t prop; if ( !get_archive(archive, &ar) ) return FALSE; if ( !PL_get_functor(field, &prop) ) return PL_type_error("compound", field); if ( ar->status != AR_NEW_ENTRY ) return PL_permission_error("access", "archive_entry", archive); if ( prop == FUNCTOR_filetype1 ) { __LA_MODE_T type = archive_entry_filetype(ar->entry); atom_t name; term_t arg = PL_new_term_ref(); _PL_get_arg(1, field, arg); switch(type&AE_IFMT) { case AE_IFREG: name = ATOM_file; break; case AE_IFLNK: name = ATOM_link; break; case AE_IFSOCK: name = ATOM_socket; break; case AE_IFCHR: name = ATOM_character_device; break; case AE_IFBLK: name = ATOM_block_device; break; case AE_IFDIR: name = ATOM_directory; break; case AE_IFIFO: name = ATOM_fifo; break; default: return PL_unify_integer(arg, (type&AE_IFMT)); } return PL_unify_atom(arg, name); } else if ( prop == FUNCTOR_mtime1 ) { time_t stamp = archive_entry_mtime(ar->entry); term_t arg = PL_new_term_ref(); _PL_get_arg(1, field, arg); return PL_unify_float(arg, (double)stamp); } else if ( prop == FUNCTOR_size1 ) { int64_t size = archive_entry_size(ar->entry); term_t arg = PL_new_term_ref(); _PL_get_arg(1, field, arg); return PL_unify_int64(arg, size); } else if ( prop == FUNCTOR_link_target1 ) { __LA_MODE_T type = archive_entry_filetype(ar->entry); const wchar_t *target = NULL; switch(type&AE_IFMT) { case AE_IFLNK: target = archive_entry_symlink_w(ar->entry); break; } if ( target ) { term_t arg = PL_new_term_ref(); _PL_get_arg(1, field, arg); return PL_unify_wchars(arg, PL_ATOM, (size_t)-1, target); } return FALSE; } else if ( prop == FUNCTOR_format1 ) { const char *s = archive_format_name(ar->archive); if ( s ) { char lwr[50]; char *o; term_t arg = PL_new_term_ref(); _PL_get_arg(1, field, arg); for(o=lwr; *s && o < lwr+sizeof(lwr); ) *o++ = tolower(*s++); *o = '\0'; return PL_unify_atom_chars(arg, lwr); } } return PL_domain_error("archive_header_property", field); }