src/intel/mda/tar.c - third_party/mesa - Git at Google

 /*
  * Copyright 2023 Intel Corporation
  * SPDX-License-Identifier: MIT
  */

 #include "tar.h"

 #include <assert.h>
 #include <string.h>
 #include <time.h>

 /* A tar archive contain a sequence of files, each files is composed of a
  * sequence of fixed size records.  The first record of a file has header,
  * defined by the table below:
  *
  *     Field Name   Byte Offset     Length in Bytes Field Type
  *     name         0               100             NUL-terminated if NUL fits
  *     mode         100             8
  *     uid          108             8
  *     gid          116             8
  *     size         124             12
  *     mtime        136             12
  *     chksum       148             8
  *     typeflag     156             1               see below
  *     linkname     157             100             NUL-terminated if NUL fits
  *     magic        256             6               must be TMAGIC (NUL term.)
  *     version      263             2               must be TVERSION
  *     uname        265             32              NUL-terminated
  *     gname        297             32              NUL-terminated
  *     devmajor     329             8
  *     devminor     337             8
  *     prefix       345             155             NUL-terminated if NUL fits
  *
  * The subsequent records contain the file contents, with extra padding to
  * fill a full record.  After that the header for the next file starts.
  * There's no archive-wide index.  See the code below for how checksum is
  * calculated.
  *
  * Comprehensive references for the tar archive are available in
  * https://www.loc.gov/preservation/digital/formats/fdd/fdd000531.shtml
  *
  * Note: the tar_writer implementation uses only the features and fields
  * needed for storing debug files.  The archive_reader implementation covers
  * only what's provided by the writer.
  */

 enum {
    HEADER_NAME_OFFSET = 0,
    HEADER_NAME_LENGTH = 100,

    HEADER_MODE_OFFSET = 100,
    HEADER_MODE_LENGTH = 8,

    HEADER_SIZE_OFFSET = 124,
    HEADER_SIZE_LENGTH = 12,

    HEADER_MTIME_OFFSET = 136,
    HEADER_MTIME_LENGTH = 12,

    HEADER_CHECKSUM_OFFSET = 148,
    HEADER_CHECKSUM_LENGTH = 8,

    HEADER_MAGIC_OFFSET = 257,
    HEADER_MAGIC_LENGTH = 6,

    HEADER_VERSION_OFFSET = 263,
    HEADER_VERSION_LENGTH = 2,

    HEADER_PREFIX_OFFSET = 345,
    HEADER_PREFIX_LENGTH = 155,
 };

 static void
 archive_update_size(char *header, unsigned size)
 {
    snprintf(&header[HEADER_SIZE_OFFSET], HEADER_SIZE_LENGTH, "%011o", size);

    /* Checksum of the header assumes the checksum field itself is
     * filled with ASCII spaces (value 32).
     */
    memset(&header[HEADER_CHECKSUM_OFFSET], 32, HEADER_CHECKSUM_LENGTH);
    unsigned checksum = 0;
    for (int i = 0; i < RECORD_SIZE; i++)
       checksum += header[i];
    snprintf(&header[HEADER_CHECKSUM_OFFSET], HEADER_CHECKSUM_LENGTH, "%07o", checksum);
 }

 static void
 archive_start_header(char *header, const char *prefix, const char *filename, time_t timestamp)
 {
    /* NOTE: If we ever need more, implement the more complex `path` extension. */
    assert(!prefix || strlen(prefix) < HEADER_PREFIX_LENGTH);
    assert(strlen(filename) < HEADER_NAME_LENGTH);

    strncpy(&header[HEADER_NAME_OFFSET], filename, HEADER_NAME_LENGTH);

    if (prefix)
       strncpy(&header[HEADER_PREFIX_OFFSET], prefix, HEADER_PREFIX_LENGTH);

    const char *filemode = "0644";
    strcpy(&header[HEADER_MODE_OFFSET], filemode);

    snprintf(&header[HEADER_MTIME_OFFSET], HEADER_MTIME_LENGTH, "%011lo", (unsigned long)timestamp);

    const char *ustar_magic = "ustar";
    strcpy(&header[HEADER_MAGIC_OFFSET], ustar_magic);

    const char *ustar_version = "00";
    strcpy(&header[HEADER_VERSION_OFFSET], ustar_version);
 }

 static unsigned
 archive_calculate_padding(unsigned size)
 {
    const unsigned m = size % RECORD_SIZE;
    return m ? RECORD_SIZE - m : 0;
 }

 static const char archive_empty_records[RECORD_SIZE * 2] = {0};

 static bool
 archive_write_padding(FILE *archive, unsigned contents_size)
 {
    const unsigned padding_size = archive_calculate_padding(contents_size);
    return fwrite(archive_empty_records, padding_size, 1, archive) == 1;
 }

 static void
 archive_prewrite_end_of_archive(FILE *archive)
 {
    /* Two empty records mark the proper end of the file, so always
     * keep them but reposition the cursor so next write overwrites
     * them.
     */
    fwrite(&archive_empty_records, RECORD_SIZE * 2, 1, archive);
    fflush(archive);
    fseek(archive, -RECORD_SIZE * 2, SEEK_END);
 }

 static bool
 archive_file_from_bytes(FILE *archive, const char *prefix, const char *filename,
                         const char *contents, unsigned contents_size, time_t timestamp)
 {
    char header[RECORD_SIZE] = {0};

    archive_start_header(header, prefix, filename, timestamp);
    archive_update_size(header, contents_size);

    if (fwrite(header, RECORD_SIZE, 1, archive) != 1)
       return false;

    if (fwrite(contents, contents_size, 1, archive) != 1)
       return false;

    archive_write_padding(archive, contents_size);
    archive_prewrite_end_of_archive(archive);

    fflush(archive);

    return ferror(archive) == 0;
 }

 void
 tar_writer_init(tar_writer *tw, FILE *f)
 {
    memset(tw, 0, sizeof(*tw));
    tw->file = f;
    tw->header_pos = -1;
    tw->error = false;
    tw->prefix = NULL;
    tw->timestamp = time(NULL);
 }

 void
 tar_writer_start_file(tar_writer *tw, const char *filename)
 {
    assert(tw->header_pos == -1);
    memset(tw->header, 0, RECORD_SIZE);

    archive_start_header(tw->header, tw->prefix, filename, tw->timestamp);
    archive_update_size(tw->header, 0);

    tw->header_pos = ftell(tw->file);
    if (tw->header_pos == -1)
       goto fail;

    if (fwrite(tw->header, RECORD_SIZE, 1, tw->file) != 1)
       goto fail;

    if (fflush(tw->file) != 0)
       goto fail;

    return;

 fail:
    tw->error = true;
 }

 void
 tar_writer_finish_file(tar_writer *tw)
 {
    assert(tw->header_pos >= 0);

    const long end_pos = ftell(tw->file);
    if (end_pos == -1)
       goto fail;

    assert((tw->header_pos + RECORD_SIZE) <= end_pos);
    const unsigned size = end_pos - tw->header_pos - RECORD_SIZE;

    archive_write_padding(tw->file, size);

    archive_update_size(tw->header, size);

    if (fseek(tw->file, tw->header_pos, SEEK_SET) == -1)
       goto fail;
    if (fwrite(tw->header, RECORD_SIZE, 1, tw->file) != 1)
       goto fail;
    if (fseek(tw->file, 0, SEEK_END) == -1)
       goto fail;

    archive_prewrite_end_of_archive(tw->file);

    if (fflush(tw->file) != 0)
       goto fail;

    goto end;

 fail:
    tw->error = true;

 end:
    tw->header_pos = -1;
    memset(tw->header, 0, RECORD_SIZE);
 }

 void
 tar_writer_file_from_bytes(tar_writer *tw, const char *filename,
                            const char *contents, unsigned contents_size)
 {
    assert(tw->header_pos == -1);
    if (!archive_file_from_bytes(tw->file, tw->prefix, filename, contents, contents_size, tw->timestamp))
       tw->error = true;
 }

 void
 tar_reader_init_from_bytes(tar_reader *ar, const char *contents, unsigned contents_size)
 {
    memset(ar, 0, sizeof(*ar));
    ar->contents = (slice){contents, contents_size};
 }

 bool
 tar_reader_next(tar_reader *ar, tar_reader_entry *entry)
 {
    if (ar->error)
       return false;

    if (ar->pos >= ar->contents.len)
       return false;

    if (ar->pos + RECORD_SIZE > ar->contents.len) {
       ar->error = true;
       return false;
    }

    const char *header = &ar->contents.data[ar->pos];
    const char *name   = &header[HEADER_NAME_OFFSET];
    const char *prefix = &header[HEADER_PREFIX_OFFSET];

    ar->pos += RECORD_SIZE;

    /* The current writer enforces the NUL termination and padding, so for
     * now let's rely on it.
     */
    if (name[HEADER_NAME_LENGTH-1] != 0 || prefix[HEADER_PREFIX_LENGTH-1] != 0) {
       ar->error = true;
       return false;
    }

    unsigned size = 0;
    if (sscanf((const char *)&header[HEADER_SIZE_OFFSET], "%011o", &size) == EOF) {
       ar->error = true;
       return false;
    }

    unsigned long mtime = 0;
    if (sscanf((const char *)&header[HEADER_MTIME_OFFSET], "%011lo", &mtime) == EOF) {
       ar->error = true;
       return false;
    }

    const unsigned padded_size = size + archive_calculate_padding(size);
    if (ar->pos + padded_size > ar->contents.len) {
       ar->error = true;
       return false;
    }

    slice contents = slice_substr(ar->contents, ar->pos, ar->pos + size);
    ar->pos += padded_size;

    /* TODO: Verify checksum. */

    entry->prefix   = slice_from_cstr(prefix);
    entry->name     = slice_from_cstr(name);
    entry->contents = contents;
    entry->mtime    = (time_t)mtime;

    return true;
 }
	/*
	* Copyright 2023 Intel Corporation
	* SPDX-License-Identifier: MIT
	*/

	#include "tar.h"

	#include <assert.h>
	#include <string.h>
	#include <time.h>

	/* A tar archive contain a sequence of files, each files is composed of a
	* sequence of fixed size records. The first record of a file has header,
	* defined by the table below:
	*
	* Field Name Byte Offset Length in Bytes Field Type
	* name 0 100 NUL-terminated if NUL fits
	* mode 100 8
	* uid 108 8
	* gid 116 8
	* size 124 12
	* mtime 136 12
	* chksum 148 8
	* typeflag 156 1 see below
	* linkname 157 100 NUL-terminated if NUL fits
	* magic 256 6 must be TMAGIC (NUL term.)
	* version 263 2 must be TVERSION
	* uname 265 32 NUL-terminated
	* gname 297 32 NUL-terminated
	* devmajor 329 8
	* devminor 337 8
	* prefix 345 155 NUL-terminated if NUL fits
	*
	* The subsequent records contain the file contents, with extra padding to
	* fill a full record. After that the header for the next file starts.
	* There's no archive-wide index. See the code below for how checksum is
	* calculated.
	*
	* Comprehensive references for the tar archive are available in
	* https://www.loc.gov/preservation/digital/formats/fdd/fdd000531.shtml
	*
	* Note: the tar_writer implementation uses only the features and fields
	* needed for storing debug files. The archive_reader implementation covers
	* only what's provided by the writer.
	*/

	enum {
	HEADER_NAME_OFFSET = 0,
	HEADER_NAME_LENGTH = 100,

	HEADER_MODE_OFFSET = 100,
	HEADER_MODE_LENGTH = 8,

	HEADER_SIZE_OFFSET = 124,
	HEADER_SIZE_LENGTH = 12,

	HEADER_MTIME_OFFSET = 136,
	HEADER_MTIME_LENGTH = 12,

	HEADER_CHECKSUM_OFFSET = 148,
	HEADER_CHECKSUM_LENGTH = 8,

	HEADER_MAGIC_OFFSET = 257,
	HEADER_MAGIC_LENGTH = 6,

	HEADER_VERSION_OFFSET = 263,
	HEADER_VERSION_LENGTH = 2,

	HEADER_PREFIX_OFFSET = 345,
	HEADER_PREFIX_LENGTH = 155,
	};

	static void
	archive_update_size(char *header, unsigned size)
	{
	snprintf(&header[HEADER_SIZE_OFFSET], HEADER_SIZE_LENGTH, "%011o", size);

	/* Checksum of the header assumes the checksum field itself is
	* filled with ASCII spaces (value 32).
	*/
	memset(&header[HEADER_CHECKSUM_OFFSET], 32, HEADER_CHECKSUM_LENGTH);
	unsigned checksum = 0;
	for (int i = 0; i < RECORD_SIZE; i++)
	checksum += header[i];
	snprintf(&header[HEADER_CHECKSUM_OFFSET], HEADER_CHECKSUM_LENGTH, "%07o", checksum);
	}

	static void
	archive_start_header(char header, const char prefix, const char *filename, time_t timestamp)
	{
	/* NOTE: If we ever need more, implement the more complex `path` extension. */
	assert(!prefix \|\| strlen(prefix) < HEADER_PREFIX_LENGTH);
	assert(strlen(filename) < HEADER_NAME_LENGTH);

	strncpy(&header[HEADER_NAME_OFFSET], filename, HEADER_NAME_LENGTH);

	if (prefix)
	strncpy(&header[HEADER_PREFIX_OFFSET], prefix, HEADER_PREFIX_LENGTH);

	const char *filemode = "0644";
	strcpy(&header[HEADER_MODE_OFFSET], filemode);

	snprintf(&header[HEADER_MTIME_OFFSET], HEADER_MTIME_LENGTH, "%011lo", (unsigned long)timestamp);

	const char *ustar_magic = "ustar";
	strcpy(&header[HEADER_MAGIC_OFFSET], ustar_magic);

	const char *ustar_version = "00";
	strcpy(&header[HEADER_VERSION_OFFSET], ustar_version);
	}

	static unsigned
	archive_calculate_padding(unsigned size)
	{
	const unsigned m = size % RECORD_SIZE;
	return m ? RECORD_SIZE - m : 0;
	}

	static const char archive_empty_records[RECORD_SIZE * 2] = {0};

	static bool
	archive_write_padding(FILE *archive, unsigned contents_size)
	{
	const unsigned padding_size = archive_calculate_padding(contents_size);
	return fwrite(archive_empty_records, padding_size, 1, archive) == 1;
	}

	static void
	archive_prewrite_end_of_archive(FILE *archive)
	{
	/* Two empty records mark the proper end of the file, so always
	* keep them but reposition the cursor so next write overwrites
	* them.
	*/
	fwrite(&archive_empty_records, RECORD_SIZE * 2, 1, archive);
	fflush(archive);
	fseek(archive, -RECORD_SIZE * 2, SEEK_END);
	}

	static bool
	archive_file_from_bytes(FILE archive, const char prefix, const char *filename,
	const char *contents, unsigned contents_size, time_t timestamp)
	{
	char header[RECORD_SIZE] = {0};

	archive_start_header(header, prefix, filename, timestamp);
	archive_update_size(header, contents_size);

	if (fwrite(header, RECORD_SIZE, 1, archive) != 1)
	return false;

	if (fwrite(contents, contents_size, 1, archive) != 1)
	return false;

	archive_write_padding(archive, contents_size);
	archive_prewrite_end_of_archive(archive);

	fflush(archive);

	return ferror(archive) == 0;
	}

	void
	tar_writer_init(tar_writer tw, FILE f)
	{
	memset(tw, 0, sizeof(*tw));
	tw->file = f;
	tw->header_pos = -1;
	tw->error = false;
	tw->prefix = NULL;
	tw->timestamp = time(NULL);
	}

	void
	tar_writer_start_file(tar_writer tw, const char filename)
	{
	assert(tw->header_pos == -1);
	memset(tw->header, 0, RECORD_SIZE);

	archive_start_header(tw->header, tw->prefix, filename, tw->timestamp);
	archive_update_size(tw->header, 0);

	tw->header_pos = ftell(tw->file);
	if (tw->header_pos == -1)
	goto fail;

	if (fwrite(tw->header, RECORD_SIZE, 1, tw->file) != 1)
	goto fail;

	if (fflush(tw->file) != 0)
	goto fail;

	return;

	fail:
	tw->error = true;
	}

	void
	tar_writer_finish_file(tar_writer *tw)
	{
	assert(tw->header_pos >= 0);

	const long end_pos = ftell(tw->file);
	if (end_pos == -1)
	goto fail;

	assert((tw->header_pos + RECORD_SIZE) <= end_pos);
	const unsigned size = end_pos - tw->header_pos - RECORD_SIZE;

	archive_write_padding(tw->file, size);

	archive_update_size(tw->header, size);

	if (fseek(tw->file, tw->header_pos, SEEK_SET) == -1)
	goto fail;
	if (fwrite(tw->header, RECORD_SIZE, 1, tw->file) != 1)
	goto fail;
	if (fseek(tw->file, 0, SEEK_END) == -1)
	goto fail;

	archive_prewrite_end_of_archive(tw->file);

	if (fflush(tw->file) != 0)
	goto fail;

	goto end;

	fail:
	tw->error = true;

	end:
	tw->header_pos = -1;
	memset(tw->header, 0, RECORD_SIZE);
	}

	void
	tar_writer_file_from_bytes(tar_writer tw, const char filename,
	const char *contents, unsigned contents_size)
	{
	assert(tw->header_pos == -1);
	if (!archive_file_from_bytes(tw->file, tw->prefix, filename, contents, contents_size, tw->timestamp))
	tw->error = true;
	}

	void
	tar_reader_init_from_bytes(tar_reader ar, const char contents, unsigned contents_size)
	{
	memset(ar, 0, sizeof(*ar));
	ar->contents = (slice){contents, contents_size};
	}

	bool
	tar_reader_next(tar_reader ar, tar_reader_entry entry)
	{
	if (ar->error)
	return false;

	if (ar->pos >= ar->contents.len)
	return false;

	if (ar->pos + RECORD_SIZE > ar->contents.len) {
	ar->error = true;
	return false;
	}

	const char *header = &ar->contents.data[ar->pos];
	const char *name = &header[HEADER_NAME_OFFSET];
	const char *prefix = &header[HEADER_PREFIX_OFFSET];

	ar->pos += RECORD_SIZE;

	/* The current writer enforces the NUL termination and padding, so for
	* now let's rely on it.
	*/
	if (name[HEADER_NAME_LENGTH-1] != 0 \|\| prefix[HEADER_PREFIX_LENGTH-1] != 0) {
	ar->error = true;
	return false;
	}

	unsigned size = 0;
	if (sscanf((const char *)&header[HEADER_SIZE_OFFSET], "%011o", &size) == EOF) {
	ar->error = true;
	return false;
	}

	unsigned long mtime = 0;
	if (sscanf((const char *)&header[HEADER_MTIME_OFFSET], "%011lo", &mtime) == EOF) {
	ar->error = true;
	return false;
	}

	const unsigned padded_size = size + archive_calculate_padding(size);
	if (ar->pos + padded_size > ar->contents.len) {
	ar->error = true;
	return false;
	}

	slice contents = slice_substr(ar->contents, ar->pos, ar->pos + size);
	ar->pos += padded_size;

	/* TODO: Verify checksum. */

	entry->prefix = slice_from_cstr(prefix);
	entry->name = slice_from_cstr(name);
	entry->contents = contents;
	entry->mtime = (time_t)mtime;

	return true;
	}