thodg/got/lib/fileindex.c

Branch : - branch - main - tag - 0.1 0.10 0.11 0.12 0.13 0.14 0.15 0.16 0.17 0.18 0.19 0.2 0.20 0.21 0.22 0.23 0.24 0.25 0.26 0.27 0.28 0.29 0.3 0.30 0.31 0.32 0.33 0.34 0.35 0.36 0.37 0.38 0.39 0.4 0.40 0.41 0.42 0.43 0.44 0.45 0.46 0.47 0.48 0.49 0.5 0.50 0.51 0.52 0.53 0.54 0.55 0.56 0.57 0.58 0.59 0.6 0.60 0.61 0.62 0.63 0.64 0.65 0.66 0.67 0.68 0.69 0.7 0.70 0.71 0.72 0.8 0.9

• Show log

  Commit

• Author : Stefan Sperling
  Date : 2018-03-12 14:08:37
  Hash : 23b19d00
  Message : fix worktree test build: remove more unused variables

• lib/fileindex.c

• /*
   * Copyright (c) 2018 Stefan Sperling <stsp@openbsd.org>
   *
   * Permission to use, copy, modify, and distribute this software for any
   * purpose with or without fee is hereby granted, provided that the above
   * copyright notice and this permission notice appear in all copies.
   *
   * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
   * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
   * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
   * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
   * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   */
  
  #include <sys/queue.h>
  #include <sys/stat.h>
  
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  #include <sha1.h>
  #include <endian.h>
  
  #include "got_error.h"
  
  #include "got_fileindex_lib.h"
  
  const struct got_error *
  got_fileindex_entry_open(struct got_fileindex_entry **entry,
      const char *ondisk_path, const char *relpath, uint8_t *blob_sha1)
  {
  	struct stat sb;
  	size_t len;
  
  	if (lstat(ondisk_path, &sb) != 0)
  		return got_error_from_errno();
  
  	*entry = calloc(1, sizeof(**entry));
  	if (*entry == NULL)
  		return got_error(GOT_ERR_NO_MEM);
  
  	(*entry)->path = strdup(relpath);
  	if ((*entry)->path == NULL) {
  		free(*entry);
  		*entry = NULL;
  		return got_error(GOT_ERR_NO_MEM);
  	}
  	
  	(*entry)->ctime_sec = sb.st_ctime;
  	(*entry)->ctime_nsec = sb.st_ctimensec;
  	(*entry)->mtime_sec = sb.st_mtime;
  	(*entry)->mtime_nsec = sb.st_mtimensec;
  	(*entry)->uid = sb.st_uid;
  	(*entry)->gid = sb.st_gid;
  	(*entry)->size = (sb.st_size & 0xffffffff);
  	if (sb.st_mode & S_IFLNK)
  		(*entry)->mode = GOT_INDEX_ENTRY_MODE_SYMLINK;
  	else
  		(*entry)->mode = GOT_INDEX_ENTRY_MODE_REGULAR_FILE;
  	(*entry)->mode |= ((sb.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO)) <<
  	    GOT_INDEX_ENTRY_MODE_PERMS_SHIFT);
  	memcpy((*entry)->blob_sha1, blob_sha1, SHA1_DIGEST_LENGTH);
  	len = strlen(relpath);
  	if (len > GOT_INDEX_ENTRY_F_PATH_LEN)
  		len = GOT_INDEX_ENTRY_F_PATH_LEN;
  	(*entry)->flags |= len;
  
  	return NULL;
  }
  
  void
  got_fileindex_entry_close(struct got_fileindex_entry *entry)
  {
  	free(entry->path);
  	free(entry);
  }
  
  const struct got_error *
  got_fileindex_entry_add(struct got_fileindex *fileindex,
      struct got_fileindex_entry *entry)
  {
  	/* TODO keep entries sorted by name */
  	TAILQ_INSERT_TAIL(&fileindex->entries, entry, entry);
  	fileindex->nentries++;
  	return NULL;
  }
  
  struct got_fileindex *
  got_fileindex_open(void)
  {
  	struct got_fileindex *fileindex;
  
  	fileindex = calloc(1, sizeof(*fileindex));
  	if (fileindex)
  		TAILQ_INIT(&fileindex->entries);
  	return fileindex;
  }
  
  void
  got_fileindex_close(struct got_fileindex *fileindex)
  {
  	struct got_fileindex_entry *entry;
  
  	while (!TAILQ_EMPTY(&fileindex->entries)) {
  		entry = TAILQ_FIRST(&fileindex->entries);
  		TAILQ_REMOVE(&fileindex->entries, entry, entry);
  		got_fileindex_entry_close(entry);
  		fileindex->nentries--;
  	}
  	free(fileindex);
  }
  
  static const struct got_error *
  write_fileindex_val64(SHA1_CTX *ctx, uint64_t val, FILE *outfile)
  {
  	uint8_t buf[sizeof(uint64_t)];
  	size_t n;
  
  	val = htobe64(val);
  	memcpy(buf, &val, sizeof(val));
  	SHA1Update(ctx, buf, sizeof(val));
  	n = fwrite(buf, 1, sizeof(val), outfile);
  	if (n != sizeof(val))
  		return got_ferror(outfile, GOT_ERR_IO);
  	return NULL;
  }
  
  static const struct got_error *
  write_fileindex_val32(SHA1_CTX *ctx, uint32_t val, FILE *outfile)
  {
  	uint8_t buf[sizeof(uint32_t)];
  	size_t n;
  
  	val = htobe32(val);
  	memcpy(buf, &val, sizeof(val));
  	SHA1Update(ctx, buf, sizeof(val));
  	n = fwrite(buf, 1, sizeof(val), outfile);
  	if (n != sizeof(val))
  		return got_ferror(outfile, GOT_ERR_IO);
  	return NULL;
  }
  
  static const struct got_error *
  write_fileindex_val16(SHA1_CTX *ctx, uint16_t val, FILE *outfile)
  {
  	uint8_t buf[sizeof(uint16_t)];
  	size_t n;
  
  	val = htobe16(val);
  	memcpy(buf, &val, sizeof(val));
  	SHA1Update(ctx, buf, sizeof(val));
  	n = fwrite(buf, 1, sizeof(val), outfile);
  	if (n != sizeof(val))
  		return got_ferror(outfile, GOT_ERR_IO);
  	return NULL;
  }
  
  static const struct got_error *
  write_fileindex_path(SHA1_CTX *ctx, const char *path, FILE *outfile)
  {
  	size_t n, len, pad;
  	static const uint8_t zero[8] = { 0 };
  
  	len = strlen(path);
  	pad = (len % 8);
  
  	SHA1Update(ctx, path, len);
  	n = fwrite(path, 1, len, outfile);
  	if (n != len)
  		return got_ferror(outfile, GOT_ERR_IO);
  	if (pad == 0)
  		return NULL;
  	SHA1Update(ctx, zero, pad);
  	n = fwrite(zero, 1, pad, outfile);
  	if (n != pad)
  		return got_ferror(outfile, GOT_ERR_IO);
  	return NULL;
  }
  
  static const struct got_error *
  write_fileindex_entry(SHA1_CTX *ctx, struct got_fileindex_entry *entry,
      FILE *outfile)
  {
  	const struct got_error *err;
  	size_t n;
  
  	err = write_fileindex_val64(ctx, entry->ctime_sec, outfile);
  	if (err)
  		return err;
  	err = write_fileindex_val64(ctx, entry->ctime_nsec, outfile);
  	if (err)
  		return err;
  	err = write_fileindex_val64(ctx, entry->mtime_sec, outfile);
  	if (err)
  		return err;
  	err = write_fileindex_val64(ctx, entry->mtime_nsec, outfile);
  	if (err)
  		return err;
  
  	err = write_fileindex_val32(ctx, entry->uid, outfile);
  	if (err)
  		return err;
  	err = write_fileindex_val32(ctx, entry->gid, outfile);
  	if (err)
  		return err;
  	err = write_fileindex_val32(ctx, entry->size, outfile);
  	if (err)
  		return err;
  
  	err = write_fileindex_val16(ctx, entry->mode, outfile);
  	if (err)
  		return err;
  
  	SHA1Update(ctx, entry->blob_sha1, SHA1_DIGEST_LENGTH);
  	n = fwrite(entry->blob_sha1, 1, SHA1_DIGEST_LENGTH, outfile);
  	if (n != SHA1_DIGEST_LENGTH)
  		return got_ferror(outfile, GOT_ERR_IO);
  
  	err = write_fileindex_val32(ctx, entry->flags, outfile);
  	if (err)
  		return err;
  
  	err = write_fileindex_path(ctx, entry->path, outfile);
  	return err;
  }
  
  const struct got_error *
  got_fileindex_write(struct got_fileindex *fileindex, FILE *outfile)
  {
  	struct got_fileindex_hdr hdr;
  	struct got_fileindex_entry *entry;
  	SHA1_CTX ctx;
  	uint8_t sha1[SHA1_DIGEST_LENGTH];
  	size_t n;
  	const size_t len = sizeof(hdr.signature) + sizeof(hdr.version) +
  	    sizeof(hdr.nentries);
  	uint8_t buf[len];
  
  	SHA1Init(&ctx);
  
  	hdr.signature = htobe32(GOT_FILE_INDEX_SIGNATURE);
  	hdr.version = htobe32(GOT_FILE_INDEX_VERSION);
  	hdr.nentries = htobe32(fileindex->nentries);
  
  	memcpy(buf, &hdr, len);
  	SHA1Update(&ctx, buf, len);
  	n = fwrite(buf, 1, len, outfile);
  	if (n != len)
  		return got_ferror(outfile, GOT_ERR_IO);
  
  	TAILQ_FOREACH(entry, &fileindex->entries, entry) {
  		const struct got_error *err;
  		err = write_fileindex_entry(&ctx, entry, outfile);
  		if (err)
  			return err;
  	}
  
  	SHA1Final(sha1, &ctx);
  	n = fwrite(sha1, 1, sizeof(sha1), outfile);
  	if (n != sizeof(sha1))
  		return got_ferror(outfile, GOT_ERR_IO);
  
  	return NULL;
  }