File Manager

003 File Manager

Current Path: /usr/src/contrib/libarchive/libarchive

usr / src / contrib / libarchive / libarchive /

📁 ..
📄 archive.h(51.93 KB)
📄 archive_acl.c(51.2 KB)
📄 archive_acl_private.h(3.13 KB)
📄 archive_blake2.h(6.32 KB)
📄 archive_blake2_impl.h(4.12 KB)
📄 archive_blake2s_ref.c(9.46 KB)
📄 archive_blake2sp_ref.c(9.11 KB)
📄 archive_check_magic.c(4.7 KB)
📄 archive_cmdline.c(5.21 KB)
📄 archive_cmdline_private.h(1.82 KB)
📄 archive_crc32.h(2.97 KB)
📄 archive_cryptor.c(13.46 KB)
📄 archive_cryptor_private.h(6.02 KB)
📄 archive_digest.c(28.79 KB)
📄 archive_digest_private.h(13.88 KB)
📄 archive_disk_acl_freebsd.c(18.86 KB)
📄 archive_endian.h(5.28 KB)
📄 archive_entry.3(4.85 KB)
📄 archive_entry.c(53.48 KB)
📄 archive_entry.h(32.79 KB)
📄 archive_entry_acl.3(14.32 KB)
📄 archive_entry_copy_stat.c(3.73 KB)
📄 archive_entry_link_resolver.c(11.74 KB)
📄 archive_entry_linkify.3(5.9 KB)
📄 archive_entry_locale.h(4.41 KB)
📄 archive_entry_misc.3(2.47 KB)
📄 archive_entry_paths.3(5.53 KB)
📄 archive_entry_perms.3(7.59 KB)
📄 archive_entry_private.h(6.09 KB)
📄 archive_entry_sparse.c(3.95 KB)
📄 archive_entry_stat.3(8.1 KB)
📄 archive_entry_stat.c(4.29 KB)
📄 archive_entry_strmode.c(2.6 KB)
📄 archive_entry_time.3(4.5 KB)
📄 archive_entry_xattr.c(3.86 KB)
📄 archive_getdate.c(29.9 KB)
📄 archive_getdate.h(1.56 KB)
📄 archive_hmac.c(7.32 KB)
📄 archive_hmac_private.h(3.59 KB)
📄 archive_match.c(47.14 KB)
📄 archive_openssl_evp_private.h(1.92 KB)
📄 archive_openssl_hmac_private.h(1.98 KB)
📄 archive_options.c(5.22 KB)
📄 archive_options_private.h(2.02 KB)
📄 archive_pack_dev.c(9.13 KB)
📄 archive_pack_dev.h(2.08 KB)
📄 archive_pathmatch.c(10.64 KB)
📄 archive_pathmatch.h(2.09 KB)
📄 archive_platform.h(5.93 KB)
📄 archive_platform_acl.h(2 KB)
📄 archive_platform_xattr.h(1.82 KB)
📄 archive_ppmd7.c(27.63 KB)
📄 archive_ppmd7_private.h(3.01 KB)
📄 archive_ppmd8.c(31.05 KB)
📄 archive_ppmd8_private.h(3.82 KB)
📄 archive_ppmd_private.h(3.31 KB)
📄 archive_private.h(5.56 KB)
📄 archive_random.c(6.67 KB)
📄 archive_random_private.h(1.6 KB)
📄 archive_rb.c(20.84 KB)
📄 archive_rb.h(4.43 KB)
📄 archive_read.3(7.18 KB)
📄 archive_read.c(48.21 KB)
📄 archive_read_add_passphrase.3(2.48 KB)
📄 archive_read_add_passphrase.c(5.21 KB)
📄 archive_read_append_filter.c(6.1 KB)
📄 archive_read_data.3(4.23 KB)
📄 archive_read_data_into_fd.c(3.94 KB)
📄 archive_read_disk.3(10.36 KB)
📄 archive_read_disk_entry_from_file.c(27.96 KB)
📄 archive_read_disk_posix.c(72.18 KB)
📄 archive_read_disk_private.h(3.31 KB)
📄 archive_read_disk_set_standard_lookup.c(8.03 KB)
📄 archive_read_extract.3(4.39 KB)
📄 archive_read_extract.c(2.21 KB)
📄 archive_read_extract2.c(4.5 KB)
📄 archive_read_filter.3(5.56 KB)
📄 archive_read_format.3(5.97 KB)
📄 archive_read_free.3(3.07 KB)
📄 archive_read_header.3(2.97 KB)
📄 archive_read_new.3(2.08 KB)
📄 archive_read_open.3(6.78 KB)
📄 archive_read_open_fd.c(5.92 KB)
📄 archive_read_open_file.c(4.9 KB)
📄 archive_read_open_filename.c(17.56 KB)
📄 archive_read_open_memory.c(5.43 KB)
📄 archive_read_private.h(9.26 KB)
📄 archive_read_set_format.c(3.43 KB)
📄 archive_read_set_options.3(6.53 KB)
📄 archive_read_set_options.c(4.6 KB)
📄 archive_read_support_filter_all.c(3.5 KB)
📄 archive_read_support_filter_by_code.c(2.76 KB)
📄 archive_read_support_filter_bzip2.c(9.93 KB)
📄 archive_read_support_filter_compress.c(13.44 KB)
📄 archive_read_support_filter_grzip.c(3.52 KB)
📄 archive_read_support_filter_gzip.c(13.48 KB)
📄 archive_read_support_filter_lrzip.c(3.79 KB)
📄 archive_read_support_filter_lz4.c(20.26 KB)
📄 archive_read_support_filter_lzop.c(13.59 KB)
📄 archive_read_support_filter_none.c(1.87 KB)
📄 archive_read_support_filter_program.c(13.21 KB)
📄 archive_read_support_filter_rpm.c(6.84 KB)
📄 archive_read_support_filter_uu.c(18.34 KB)
📄 archive_read_support_filter_xz.c(21.51 KB)
📄 archive_read_support_filter_zstd.c(7.59 KB)
📄 archive_read_support_format_7zip.c(97.12 KB)
📄 archive_read_support_format_all.c(3.47 KB)
📄 archive_read_support_format_ar.c(17.4 KB)
📄 archive_read_support_format_by_code.c(2.99 KB)
📄 archive_read_support_format_cab.c(83 KB)
📄 archive_read_support_format_cpio.c(31.93 KB)
📄 archive_read_support_format_empty.c(2.93 KB)
📄 archive_read_support_format_iso9660.c(92.13 KB)
📄 archive_read_support_format_lha.c(83.33 KB)
📄 archive_read_support_format_mtree.c(51.86 KB)
📄 archive_read_support_format_rar.c(84.34 KB)
📄 archive_read_support_format_rar5.c(107.18 KB)
📄 archive_read_support_format_raw.c(5.43 KB)
📄 archive_read_support_format_tar.c(83.23 KB)
📄 archive_read_support_format_warc.c(21.17 KB)
📄 archive_read_support_format_xar.c(79.96 KB)
📄 archive_read_support_format_zip.c(117.12 KB)
📄 archive_string.c(104.04 KB)
📄 archive_string.h(9.26 KB)
📄 archive_string_composition.h(80.15 KB)
📄 archive_string_sprintf.c(5.13 KB)
📄 archive_util.3(6.97 KB)
📄 archive_util.c(14.54 KB)
📄 archive_version_details.c(3.55 KB)
📄 archive_virtual.c(3.95 KB)
📄 archive_write.3(7.32 KB)
📄 archive_write.c(21.65 KB)
📄 archive_write_add_filter.c(2.63 KB)
📄 archive_write_add_filter_b64encode.c(8.41 KB)
📄 archive_write_add_filter_by_name.c(2.65 KB)
📄 archive_write_add_filter_bzip2.c(11.14 KB)
📄 archive_write_add_filter_compress.c(12.62 KB)
📄 archive_write_add_filter_grzip.c(4.22 KB)
📄 archive_write_add_filter_gzip.c(12.34 KB)
📄 archive_write_add_filter_lrzip.c(5.72 KB)
📄 archive_write_add_filter_lz4.c(18.85 KB)
📄 archive_write_add_filter_lzop.c(13.69 KB)
📄 archive_write_add_filter_none.c(1.67 KB)
📄 archive_write_add_filter_program.c(9.77 KB)
📄 archive_write_add_filter_uuencode.c(8.09 KB)
📄 archive_write_add_filter_xz.c(14.97 KB)
📄 archive_write_add_filter_zstd.c(10.7 KB)
📄 archive_write_blocksize.3(4.13 KB)
📄 archive_write_data.3(3.09 KB)
📄 archive_write_disk.3(11.82 KB)
📄 archive_write_disk_posix.c(123.89 KB)
📄 archive_write_disk_private.h(1.77 KB)
📄 archive_write_disk_set_standard_lookup.c(6.91 KB)
📄 archive_write_filter.3(4.47 KB)
📄 archive_write_finish_entry.3(2.67 KB)
📄 archive_write_format.3(5.99 KB)
📄 archive_write_free.3(3.05 KB)
📄 archive_write_header.3(2.44 KB)
📄 archive_write_new.3(2.02 KB)
📄 archive_write_open.3(8.01 KB)
📄 archive_write_open_fd.c(3.9 KB)
📄 archive_write_open_file.c(2.93 KB)
📄 archive_write_open_filename.c(6.85 KB)
📄 archive_write_open_memory.c(3.61 KB)
📄 archive_write_private.h(5.64 KB)
📄 archive_write_set_format.c(4 KB)
📄 archive_write_set_format_7zip.c(55.14 KB)
📄 archive_write_set_format_ar.c(14.08 KB)
📄 archive_write_set_format_by_name.c(3.35 KB)
📄 archive_write_set_format_cpio.c(14.24 KB)
📄 archive_write_set_format_cpio_newc.c(13.11 KB)
📄 archive_write_set_format_filter_by_ext.c(4.67 KB)
📄 archive_write_set_format_gnutar.c(22.62 KB)
📄 archive_write_set_format_iso9660.c(206.67 KB)
📄 archive_write_set_format_mtree.c(58.1 KB)
📄 archive_write_set_format_pax.c(59.85 KB)
📄 archive_write_set_format_private.h(1.71 KB)
📄 archive_write_set_format_raw.c(3.65 KB)
📄 archive_write_set_format_shar.c(16.93 KB)
📄 archive_write_set_format_ustar.c(21.98 KB)
📄 archive_write_set_format_v7tar.c(18.02 KB)
📄 archive_write_set_format_warc.c(11.2 KB)
📄 archive_write_set_format_xar.c(79.49 KB)
📄 archive_write_set_format_zip.c(48.7 KB)
📄 archive_write_set_options.3(21.85 KB)
📄 archive_write_set_options.c(4.07 KB)
📄 archive_write_set_passphrase.3(2.46 KB)
📄 archive_write_set_passphrase.c(2.89 KB)
📄 archive_xxhash.h(1.86 KB)
📄 cpio.5(10.45 KB)
📄 filter_fork.h(1.68 KB)
📄 filter_fork_posix.c(6.18 KB)
📄 libarchive-formats.5(18.29 KB)
📄 libarchive.3(8.02 KB)
📄 libarchive_changes.3(9.95 KB)
📄 libarchive_internals.3(13.36 KB)
📄 tar.5(31 KB)
📁 test
📄 xxhash.c(15.77 KB)

Editing: archive_write_set_format_warc.c

/*-
 * Copyright (c) 2014 Sebastian Freundt
 * Author: Sebastian Freundt  <devel@fresse.org>
 *
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "archive_platform.h"
__FBSDID("$FreeBSD$");

#ifdef HAVE_ERRNO_H
#include <errno.h>
#endif
#include <stdio.h>
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif
#ifdef HAVE_TIME_H
#include <time.h>
#endif

#include "archive.h"
#include "archive_entry.h"
#include "archive_entry_locale.h"
#include "archive_private.h"
#include "archive_random_private.h"
#include "archive_write_private.h"
#include "archive_write_set_format_private.h"

struct warc_s {
	unsigned int omit_warcinfo:1;

time_t now;
	mode_t typ;
	unsigned int rng;
	/* populated size */
	uint64_t populz;
};

static const char warcinfo[] =
    "software: libarchive/" ARCHIVE_VERSION_ONLY_STRING "\r\n"
    "format: WARC file version 1.0\r\n";

typedef enum {
	WT_NONE,
	/* warcinfo */
	WT_INFO,
	/* metadata */
	WT_META,
	/* resource */
	WT_RSRC,
	/* request, unsupported */
	WT_REQ,
	/* response, unsupported */
	WT_RSP,
	/* revisit, unsupported */
	WT_RVIS,
	/* conversion, unsupported */
	WT_CONV,
	/* continuation, unsupported at the moment */
	WT_CONT,
	/* invalid type */
	LAST_WT
} warc_type_t;

typedef struct {
	warc_type_t type;
	const char *tgturi;
	const char *recid;
	time_t rtime;
	time_t mtime;
	const char *cnttyp;
	uint64_t cntlen;
} warc_essential_hdr_t;

typedef struct {
	unsigned int u[4U];
} warc_uuid_t;

static int _warc_options(struct archive_write*, const char *key, const char *v);
static int _warc_header(struct archive_write *a, struct archive_entry *entry);
static ssize_t _warc_data(struct archive_write *a, const void *buf, size_t sz);
static int _warc_finish_entry(struct archive_write *a);
static int _warc_close(struct archive_write *a);
static int _warc_free(struct archive_write *a);

/* private routines */
static ssize_t _popul_ehdr(struct archive_string *t, size_t z, warc_essential_hdr_t);
static int _gen_uuid(warc_uuid_t *tgt);

/*
 * Set output format to ISO 28500 (aka WARC) format.
 */
int
archive_write_set_format_warc(struct archive *_a)
{
	struct archive_write *a = (struct archive_write *)_a;
	struct warc_s *w;

archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
	    ARCHIVE_STATE_NEW, "archive_write_set_format_warc");

/* If another format was already registered, unregister it. */
	if (a->format_free != NULL) {
		(a->format_free)(a);
	}

w = malloc(sizeof(*w));
	if (w == NULL) {
		archive_set_error(&a->archive, ENOMEM,
		    "Can't allocate warc data");
		return (ARCHIVE_FATAL);
	}
	/* by default we're emitting a file wide header */
	w->omit_warcinfo = 0U;
	/* obtain current time for date fields */
	w->now = time(NULL);
	/* reset file type info */
	w->typ = 0;
	/* also initialise our rng */
	w->rng = (unsigned int)w->now;

a->format_data = w;
	a->format_name = "WARC/1.0";
	a->format_options = _warc_options;
	a->format_write_header = _warc_header;
	a->format_write_data = _warc_data;
	a->format_close = _warc_close;
	a->format_free = _warc_free;
	a->format_finish_entry = _warc_finish_entry;
	a->archive.archive_format = ARCHIVE_FORMAT_WARC;
	a->archive.archive_format_name = "WARC/1.0";
	return (ARCHIVE_OK);
}

/* archive methods */
static int
_warc_options(struct archive_write *a, const char *key, const char *val)
{
	struct warc_s *w = a->format_data;

if (strcmp(key, "omit-warcinfo") == 0) {
		if (val == NULL || strcmp(val, "true") == 0) {
			/* great */
			w->omit_warcinfo = 1U;
			return (ARCHIVE_OK);
		}
	}

/* Note: The "warn" return is just to inform the options
	 * supervisor that we didn't handle it.  It will generate
	 * a suitable error if no one used this option. */
	return (ARCHIVE_WARN);
}

static int
_warc_header(struct archive_write *a, struct archive_entry *entry)
{
	struct warc_s *w = a->format_data;
	struct archive_string hdr;
#define MAX_HDR_SIZE 512

/* check whether warcinfo record needs outputting */
	if (!w->omit_warcinfo) {
		ssize_t r;
		warc_essential_hdr_t wi = {
			WT_INFO,
			/*uri*/NULL,
			/*urn*/NULL,
			/*rtm*/0,
			/*mtm*/0,
			/*cty*/"application/warc-fields",
			/*len*/sizeof(warcinfo) - 1U,
		};
		wi.rtime = w->now;
		wi.mtime = w->now;

archive_string_init(&hdr);
		r = _popul_ehdr(&hdr, MAX_HDR_SIZE, wi);
		if (r >= 0) {
			/* jackpot! */
			/* now also use HDR buffer for the actual warcinfo */
			archive_strncat(&hdr, warcinfo, sizeof(warcinfo) -1);

/* append end-of-record indicator */
			archive_strncat(&hdr, "\r\n\r\n", 4);

/* write to output stream */
			__archive_write_output(a, hdr.s, archive_strlen(&hdr));
		}
		/* indicate we're done with file header writing */
		w->omit_warcinfo = 1U;
		archive_string_free(&hdr);
	}

if (archive_entry_pathname(entry) == NULL) {
		archive_set_error(&a->archive, EINVAL,
		    "Invalid filename");
		return (ARCHIVE_WARN);
	}

w->typ = archive_entry_filetype(entry);
	w->populz = 0U;
	if (w->typ == AE_IFREG) {
		warc_essential_hdr_t rh = {
			WT_RSRC,
			/*uri*/NULL,
			/*urn*/NULL,
			/*rtm*/0,
			/*mtm*/0,
			/*cty*/NULL,
			/*len*/0,
		};
		ssize_t r;
		rh.tgturi = archive_entry_pathname(entry);
		rh.rtime = w->now;
		rh.mtime = archive_entry_mtime(entry);
		rh.cntlen = (size_t)archive_entry_size(entry);

archive_string_init(&hdr);
		r = _popul_ehdr(&hdr, MAX_HDR_SIZE, rh);
		if (r < 0) {
			/* don't bother */
			archive_set_error(
				&a->archive,
				ARCHIVE_ERRNO_FILE_FORMAT,
				"cannot archive file");
			return (ARCHIVE_WARN);
		}
		/* otherwise append to output stream */
		__archive_write_output(a, hdr.s, r);
		/* and let subsequent calls to _data() know about the size */
		w->populz = rh.cntlen;
		archive_string_free(&hdr);
		return (ARCHIVE_OK);
	}
	/* just resort to erroring as per Tim's advice */
	__archive_write_entry_filetype_unsupported(
	    &a->archive, entry, "WARC");
	return (ARCHIVE_FAILED);
}

static ssize_t
_warc_data(struct archive_write *a, const void *buf, size_t len)
{
	struct warc_s *w = a->format_data;

if (w->typ == AE_IFREG) {
		int rc;

/* never write more bytes than announced */
		if (len > w->populz) {
			len = (size_t)w->populz;
		}

/* now then, out we put the whole shebang */
		rc = __archive_write_output(a, buf, len);
		if (rc != ARCHIVE_OK) {
			return rc;
		}
	}
	return len;
}

static int
_warc_finish_entry(struct archive_write *a)
{
	static const char _eor[] = "\r\n\r\n";
	struct warc_s *w = a->format_data;

if (w->typ == AE_IFREG) {
		int rc = __archive_write_output(a, _eor, sizeof(_eor) - 1U);

if (rc != ARCHIVE_OK) {
			return rc;
		}
	}
	/* reset type info */
	w->typ = 0;
	return (ARCHIVE_OK);
}

static int
_warc_close(struct archive_write *a)
{
	(void)a; /* UNUSED */
	return (ARCHIVE_OK);
}

static int
_warc_free(struct archive_write *a)
{
	struct warc_s *w = a->format_data;

free(w);
	a->format_data = NULL;
	return (ARCHIVE_OK);
}

/* private routines */
static void
xstrftime(struct archive_string *as, const char *fmt, time_t t)
{
/** like strftime(3) but for time_t objects */
	struct tm *rt;
#if defined(HAVE_GMTIME_R) || defined(HAVE__GMTIME64_S)
	struct tm timeHere;
#endif
#if defined(HAVE__GMTIME64_S)
	errno_t terr;
	__time64_t tmptime;
#endif
	char strtime[100];
	size_t len;

#ifdef HAVE_GMTIME_R
	if ((rt = gmtime_r(&t, &timeHere)) == NULL)
		return;
#elif defined(HAVE__GMTIME64_S)
	tmptime = t;
	terr = _gmtime64_s(&timeHere, &tmptime);
	if (terr)
		rt = NULL;
	else
		rt = &timeHere;
#else
	if ((rt = gmtime(&t)) == NULL)
		return;
#endif
	/* leave the hard yacker to our role model strftime() */
	len = strftime(strtime, sizeof(strtime)-1, fmt, rt);
	archive_strncat(as, strtime, len);
}

static ssize_t
_popul_ehdr(struct archive_string *tgt, size_t tsz, warc_essential_hdr_t hdr)
{
	static const char _ver[] = "WARC/1.0\r\n";
	static const char * const _typ[LAST_WT] = {
		NULL, "warcinfo", "metadata", "resource", NULL
	};
	char std_uuid[48U];

if (hdr.type == WT_NONE || hdr.type > WT_RSRC) {
		/* brilliant, how exactly did we get here? */
		return -1;
	}

archive_strcpy(tgt, _ver);

archive_string_sprintf(tgt, "WARC-Type: %s\r\n", _typ[hdr.type]);

if (hdr.tgturi != NULL) {
		/* check if there's a xyz:// */
		static const char _uri[] = "";
		static const char _fil[] = "file://";
		const char *u;
		char *chk = strchr(hdr.tgturi, ':');

if (chk != NULL && chk[1U] == '/' && chk[2U] == '/') {
			/* yep, it's definitely a URI */
			u = _uri;
		} else {
			/* hm, best to prepend file:// then */
			u = _fil;
		}
		archive_string_sprintf(tgt,
			"WARC-Target-URI: %s%s\r\n", u, hdr.tgturi);
	}

/* record time is usually when the http is sent off,
	 * just treat the archive writing as such for a moment */
	xstrftime(tgt, "WARC-Date: %Y-%m-%dT%H:%M:%SZ\r\n", hdr.rtime);

/* while we're at it, record the mtime */
	xstrftime(tgt, "Last-Modified: %Y-%m-%dT%H:%M:%SZ\r\n", hdr.mtime);

if (hdr.recid == NULL) {
		/* generate one, grrrr */
		warc_uuid_t u;

_gen_uuid(&u);
		/* Unfortunately, archive_string_sprintf does not
		 * handle the minimum number following '%'.
		 * So we have to use snprintf function here instead
		 * of archive_string_snprintf function. */
#if defined(_WIN32) && !defined(__CYGWIN__) && !( defined(_MSC_VER) && _MSC_VER >= 1900)
#define snprintf _snprintf
#endif
		snprintf(
			std_uuid, sizeof(std_uuid),
			"<urn:uuid:%08x-%04x-%04x-%04x-%04x%08x>",
			u.u[0U],
			u.u[1U] >> 16U, u.u[1U] & 0xffffU,
			u.u[2U] >> 16U, u.u[2U] & 0xffffU,
			u.u[3U]);
		hdr.recid = std_uuid;
	}

/* record-id is mandatory, fingers crossed we won't fail */
	archive_string_sprintf(tgt, "WARC-Record-ID: %s\r\n", hdr.recid);

if (hdr.cnttyp != NULL) {
		archive_string_sprintf(tgt, "Content-Type: %s\r\n", hdr.cnttyp);
	}

/* next one is mandatory */
	archive_string_sprintf(tgt, "Content-Length: %ju\r\n", (uintmax_t)hdr.cntlen);
	/**/
	archive_strncat(tgt, "\r\n", 2);

return (archive_strlen(tgt) >= tsz)? -1: (ssize_t)archive_strlen(tgt);
}

static int
_gen_uuid(warc_uuid_t *tgt)
{
	archive_random(tgt->u, sizeof(tgt->u));
	/* obey uuid version 4 rules */
	tgt->u[1U] &= 0xffff0fffU;
	tgt->u[1U] |= 0x4000U;
	tgt->u[2U] &= 0x3fffffffU;
	tgt->u[2U] |= 0x80000000U;
	return 0;
}

/* archive_write_set_format_warc.c ends here */

003 File Manager

Editing: archive_write_set_format_warc.c

Upload File

Create Folder