static int ar_entry_birthtime(lua_State *L) {
struct archive_entry* self = *ar_entry_check(L, 1);
int is_set;
int num_results;
if ( NULL == self ) return 0;
is_set = ( lua_gettop(L) >= 2 );
num_results = 0;
if ( archive_entry_birthtime_is_set(self) ) {
num_results = 2;
lua_pushnumber(L, archive_entry_birthtime(self));
lua_pushnumber(L, archive_entry_birthtime_nsec(self));
}
if ( is_set ) {
if ( lua_isnil(L, 2) ) {
archive_entry_unset_birthtime(self);
} else if ( lua_istable(L, 2) ) {
lua_rawgeti(L, 2, 1);
lua_rawgeti(L, 2, 2);
archive_entry_set_birthtime(self,
lua_tonumber(L, -2),
lua_tonumber(L, -1));
} else {
archive_entry_set_birthtime(self,
lua_tonumber(L, 2),
lua_tonumber(L, 3));
}
}
return num_results;
}
void
archive_entry_copy_stat(struct archive_entry *entry, const struct stat *st)
{
#if HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC
archive_entry_set_atime(entry, st->st_atime, st->st_atimespec.tv_nsec);
archive_entry_set_ctime(entry, st->st_ctime, st->st_ctimespec.tv_nsec);
archive_entry_set_mtime(entry, st->st_mtime, st->st_mtimespec.tv_nsec);
#elif HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC
archive_entry_set_atime(entry, st->st_atime, st->st_atim.tv_nsec);
archive_entry_set_ctime(entry, st->st_ctime, st->st_ctim.tv_nsec);
archive_entry_set_mtime(entry, st->st_mtime, st->st_mtim.tv_nsec);
#elif HAVE_STRUCT_STAT_ST_MTIME_N
archive_entry_set_atime(entry, st->st_atime, st->st_atime_n);
archive_entry_set_ctime(entry, st->st_ctime, st->st_ctime_n);
archive_entry_set_mtime(entry, st->st_mtime, st->st_mtime_n);
#elif HAVE_STRUCT_STAT_ST_UMTIME
archive_entry_set_atime(entry, st->st_atime, st->st_uatime * 1000);
archive_entry_set_ctime(entry, st->st_ctime, st->st_uctime * 1000);
archive_entry_set_mtime(entry, st->st_mtime, st->st_umtime * 1000);
#elif HAVE_STRUCT_STAT_ST_MTIME_USEC
archive_entry_set_atime(entry, st->st_atime, st->st_atime_usec * 1000);
archive_entry_set_ctime(entry, st->st_ctime, st->st_ctime_usec * 1000);
archive_entry_set_mtime(entry, st->st_mtime, st->st_mtime_usec * 1000);
#else
archive_entry_set_atime(entry, st->st_atime, 0);
archive_entry_set_ctime(entry, st->st_ctime, 0);
archive_entry_set_mtime(entry, st->st_mtime, 0);
#endif
#if HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC
archive_entry_set_birthtime(entry, st->st_birthtime, st->st_birthtimespec.tv_nsec);
#elif HAVE_STRUCT_STAT_ST_BIRTHTIME
archive_entry_set_birthtime(entry, st->st_birthtime, 0);
#else
archive_entry_unset_birthtime(entry);
#endif
archive_entry_set_dev(entry, st->st_dev);
archive_entry_set_gid(entry, st->st_gid);
archive_entry_set_uid(entry, st->st_uid);
archive_entry_set_ino(entry, st->st_ino);
archive_entry_set_nlink(entry, st->st_nlink);
archive_entry_set_rdev(entry, st->st_rdev);
archive_entry_set_size(entry, st->st_size);
archive_entry_set_mode(entry, st->st_mode);
}
int createArchiveofFilesPC(char** files, unsigned long * size,
unsigned int fileCount, const char* filename, const char* tarHostDir) {
unsigned int ctr = 0;
struct timespec ts;
struct archive_entry* entry;
struct archive* archive = archive_write_new();
int dirlen = strlen(tarHostDir);
if ((archive_write_set_compression_gzip(archive) != ARCHIVE_OK)
|| (archive_write_set_format_ustar(archive) != ARCHIVE_OK)
|| (archive_write_open_filename(archive, filename) != ARCHIVE_OK)) {
printf("%s\n", archive_error_string(archive));
return -1;
}
int tarHostDirLen = strlen(tarHostDir);
for (ctr = 0; ctr < fileCount; ctr++) {
entry = archive_entry_new();
clock_gettime(CLOCK_REALTIME, &ts);
//Set entry to be stored under the tarHostDir directory
const char* path = files[ctr];
int pathlength = dirlen + strlen(path) + 2; //One for / and the other for '\0'
char newPath[pathlength];
if(tarHostDirLen>0)
snprintf(newPath, pathlength, "%s/%s", tarHostDir, boost::filesystem::path(path).filename().c_str());
else
snprintf(newPath, pathlength, "%s", boost::filesystem::path(path).filename().c_str());
archive_entry_set_pathname(entry, newPath);
archive_entry_set_size(entry, size[ctr]);
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_perm(entry, 0444);
archive_entry_set_atime(entry, ts.tv_sec, ts.tv_nsec);
archive_entry_set_birthtime(entry, ts.tv_sec, ts.tv_nsec);
archive_entry_set_ctime(entry, ts.tv_sec, ts.tv_nsec);
archive_entry_set_mtime(entry, ts.tv_sec, ts.tv_nsec);
int rc = archive_write_header(archive, entry);
char *contents = new char[size[ctr]+1];
FILE* fp = fopen(files[ctr],"rb");
fread((void *)contents, size[ctr], 1, fp);
fclose(fp);
archive_write_data(archive, contents, size[ctr]);
archive_entry_free(entry);
entry = NULL;
delete[] contents;
if (ARCHIVE_OK != rc) {
printf("%s\n", archive_error_string(archive));
return -1;
}
}
archive_write_finish(archive);
}
/*
* Check that an ISO 9660 image is correctly created.
*/
static void
add_entry(struct archive *a, const char *fname, const char *sym)
{
struct archive_entry *ae;
assert((ae = archive_entry_new()) != NULL);
archive_entry_set_birthtime(ae, 2, 20);
archive_entry_set_atime(ae, 3, 30);
archive_entry_set_ctime(ae, 4, 40);
archive_entry_set_mtime(ae, 5, 50);
archive_entry_copy_pathname(ae, fname);
if (sym != NULL)
archive_entry_set_symlink(ae, sym);
archive_entry_set_mode(ae, S_IFREG | 0555);
archive_entry_set_size(ae, 0);
assertEqualIntA(a, ARCHIVE_OK, archive_write_header(a, ae));
archive_entry_free(ae);
}
void
archive_entry_copy_bhfi(struct archive_entry *entry,
BY_HANDLE_FILE_INFORMATION *bhfi)
{
time_t secs;
long nsecs;
fileTimeToUtc(&bhfi->ftLastAccessTime, &secs, &nsecs);
archive_entry_set_atime(entry, secs, nsecs);
fileTimeToUtc(&bhfi->ftLastWriteTime, &secs, &nsecs);
archive_entry_set_mtime(entry, secs, nsecs);
fileTimeToUtc(&bhfi->ftCreationTime, &secs, &nsecs);
archive_entry_set_birthtime(entry, secs, nsecs);
archive_entry_set_dev(entry, bhfi->dwVolumeSerialNumber);
archive_entry_set_ino64(entry, (((int64_t)bhfi->nFileIndexHigh) << 32)
+ bhfi->nFileIndexLow);
archive_entry_set_nlink(entry, bhfi->nNumberOfLinks);
archive_entry_set_size(entry, (((int64_t)bhfi->nFileSizeHigh) << 32)
+ bhfi->nFileSizeLow);
}
int createArchiveofFiles(char** files, unsigned long * size,
unsigned int fileCount, const char* filename) {
unsigned int ctr = 0;
struct timespec ts;
struct archive_entry* entry;
struct archive* archive = archive_write_new();
if ((archive_write_set_compression_gzip(archive) != ARCHIVE_OK)
|| (archive_write_set_format_ustar(archive) != ARCHIVE_OK)
|| (archive_write_open_filename(archive, filename) != ARCHIVE_OK)) {
printf("%s\n", archive_error_string(archive));
return -1;
}
for (ctr = 0; ctr < fileCount; ctr++) {
entry = archive_entry_new();
clock_gettime(CLOCK_REALTIME, &ts);
archive_entry_set_pathname(entry, files[ctr]);
archive_entry_set_size(entry, size[ctr]);
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_perm(entry, 0444);
archive_entry_set_atime(entry, ts.tv_sec, ts.tv_nsec);
archive_entry_set_birthtime(entry, ts.tv_sec, ts.tv_nsec);
archive_entry_set_ctime(entry, ts.tv_sec, ts.tv_nsec);
archive_entry_set_mtime(entry, ts.tv_sec, ts.tv_nsec);
int rc = archive_write_header(archive, entry);
char *contents = new char[size[ctr]+1];
FILE* fp = fopen(files[ctr],"rb");
fread((void *)contents, size[ctr], 1, fp);
fclose(fp);
archive_write_data(archive, contents, size[ctr]);
archive_entry_free(entry);
entry = NULL;
delete[] contents;
if (ARCHIVE_OK != rc) {
printf("%s\n", archive_error_string(archive));
return -1;
}
}
archive_write_finish(archive);
}
int
packing_append_file_attr(struct packing *pack, const char *filepath,
const char *newpath, const char *uname, const char *gname, mode_t perm,
u_long fflags)
{
int fd;
int retcode = EPKG_OK;
int ret;
time_t source_time;
struct stat st;
struct archive_entry *entry, *sparse_entry;
bool unset_timestamp;
const char *source_date_epoch;
char buf[32768];
int len;
entry = archive_entry_new();
archive_entry_copy_sourcepath(entry, filepath);
pkg_debug(2, "Packing file '%s'", filepath);
if (lstat(filepath, &st) != 0) {
pkg_emit_errno("lstat", filepath);
retcode = EPKG_FATAL;
goto cleanup;
}
ret = archive_read_disk_entry_from_file(pack->aread, entry, -1,
&st);
if (ret != ARCHIVE_OK) {
pkg_emit_error("%s: %s", filepath,
archive_error_string(pack->aread));
retcode = EPKG_FATAL;
goto cleanup;
}
if (newpath != NULL)
archive_entry_set_pathname(entry, newpath);
if (archive_entry_filetype(entry) != AE_IFREG) {
archive_entry_set_size(entry, 0);
}
if (uname != NULL && uname[0] != '\0') {
archive_entry_set_uname(entry, uname);
}
if (gname != NULL && gname[0] != '\0') {
archive_entry_set_gname(entry, gname);
}
if (fflags > 0)
archive_entry_set_fflags(entry, fflags, 0);
if (perm != 0)
archive_entry_set_perm(entry, perm);
unset_timestamp = pkg_object_bool(pkg_config_get("UNSET_TIMESTAMP"));
if (unset_timestamp) {
archive_entry_unset_atime(entry);
archive_entry_unset_ctime(entry);
archive_entry_unset_mtime(entry);
archive_entry_unset_birthtime(entry);
}
if ((source_date_epoch = getenv("SOURCE_DATE_EPOCH")) != NULL) {
if (source_date_epoch[strspn(source_date_epoch, "0123456789")] != '\0') {
pkg_emit_error("Bad environment variable "
"SOURCE_DATE_EPOCH: %s", source_date_epoch);
retcode = EPKG_FATAL;
goto cleanup;
}
source_time = strtoll(source_date_epoch, NULL, 10);
archive_entry_set_atime(entry, source_time, 0);
archive_entry_set_ctime(entry, source_time, 0);
archive_entry_set_mtime(entry, source_time, 0);
archive_entry_set_birthtime(entry, source_time, 0);
}
archive_entry_linkify(pack->resolver, &entry, &sparse_entry);
if (sparse_entry != NULL && entry == NULL)
entry = sparse_entry;
archive_write_header(pack->awrite, entry);
if (archive_entry_size(entry) <= 0)
goto cleanup;
if ((fd = open(filepath, O_RDONLY)) < 0) {
pkg_emit_errno("open", filepath);
retcode = EPKG_FATAL;
goto cleanup;
}
while ((len = read(fd, buf, sizeof(buf))) > 0) {
if (archive_write_data(pack->awrite, buf, len) == -1) {
pkg_emit_errno("archive_write_data", "archive write error");
retcode = EPKG_FATAL;
break;
}
}
if (len == -1) {
pkg_emit_errno("read", "file read error");
retcode = EPKG_FATAL;
}
close(fd);
cleanup:
archive_entry_free(entry);
return (retcode);
}
void
archive_entry_unset_birthtime(struct archive_entry *entry)
{
archive_entry_set_birthtime(entry, 0, 0);
entry->ae_set &= ~AE_SET_BIRTHTIME;
}
void TarUtils::write(std::ostream &output, const io::ObservedFile &root, const std::set<ObservedFile> &files_to_send)
{
bool processed = false;
//create new archive, set format to tar, use callbacks (above this method)
struct archive *a;
a = archive_write_new();
archive_write_set_format_ustar(a);
archive_write_open(a, &output, &__tar_utils_open_callback, &__tar_utils_write_callback, &__tar_utils_close_callback);
for(std::set<ObservedFile>::const_iterator of_iter = files_to_send.begin(); of_iter != files_to_send.end(); ++of_iter)
{
const ObservedFile &of = (*of_iter);
const ibrcommon::File &file = of.getFile();
struct archive_entry *entry;
entry = archive_entry_new();
archive_entry_set_size(entry, file.size());
if(file.isDirectory())
{
archive_entry_set_filetype(entry, AE_IFDIR);
archive_entry_set_perm(entry, 0755);
}
else
{
archive_entry_set_filetype(entry, AE_IFREG);
archive_entry_set_perm(entry, 0644);
}
archive_entry_set_pathname(entry, rel_filename(root, of).c_str());
//set timestamps
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
archive_entry_set_atime(entry, ts.tv_sec, ts.tv_nsec); //accesstime
archive_entry_set_birthtime(entry, ts.tv_sec, ts.tv_nsec); //creationtime
archive_entry_set_ctime(entry, ts.tv_sec, ts.tv_nsec); //time, inode changed
archive_entry_set_mtime(entry, ts.tv_sec, ts.tv_nsec); //modification time
archive_write_header(a, entry);
try {
#ifdef HAVE_LIBTFFS
//read file on vfat-image
try {
const FATFile &ffile = dynamic_cast<const FATFile&>(file);
processed = true;
// get image reader
const FatImageReader &reader = ffile.getReader();
// open fat file
io::FatImageReader::FileHandle fh = reader.open(ffile);
char buff[BUFF_SIZE];
ssize_t ret = 0;
size_t len = 0;
// read file
len = fh.read((unsigned char*)&buff, BUFF_SIZE);
//write buffer to archive
while (len > 0)
{
if( (ret = archive_write_data(a, buff, len)) < 0)
{
IBRCOMMON_LOGGER_TAG("TarUtils", error) << "archive_write_data failed" << IBRCOMMON_LOGGER_ENDL;
break;
}
// read next chunk
len = fh.read((unsigned char*)&buff, BUFF_SIZE);
}
} catch (const std::bad_cast&) { };
#endif
if (!processed)
{
char buff[BUFF_SIZE];
ssize_t ret = 0;
// open file for reading
std::ifstream fs(file.getPath().c_str());
// write buffer to archive
while (fs.good())
{
// read bytes
fs.read(buff, BUFF_SIZE);
// write bytes to archive
if( (ret = archive_write_data(a, buff, fs.gcount())) < 0)
{
IBRCOMMON_LOGGER_TAG("TarUtils", error) << "archive write failed" << IBRCOMMON_LOGGER_ENDL;
break;
}
}
}
} catch (const ibrcommon::IOException &e) {
// write failed
IBRCOMMON_LOGGER_TAG("TarUtils", error) << "archive write failed: " << e.what() << IBRCOMMON_LOGGER_ENDL;
archive_entry_free(entry);
archive_write_close(a);
archive_write_free(a);
throw;
}
archive_entry_free(entry);
}
archive_write_close(a);
archive_write_free(a);
}