You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
120 lines
2.9 KiB
120 lines
2.9 KiB
/*
|
|
* Copyright (C) 2016 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <inttypes.h>
|
|
#include <stdint.h>
|
|
#include <stdbool.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
|
|
#include <nanohub/nanoapp.h>
|
|
|
|
void *reallocOrDie(void *buf, size_t bufSz)
|
|
{
|
|
void *newBuf = realloc(buf, bufSz);
|
|
if (!newBuf) {
|
|
fprintf(stderr, "Failed to allocate %zu bytes\n", bufSz);
|
|
exit(2);
|
|
}
|
|
return newBuf;
|
|
}
|
|
|
|
void assertMem(size_t used, size_t total)
|
|
{
|
|
if (used <= total)
|
|
return;
|
|
fprintf(stderr, "Buffer size %zu is not big enough to complete operation; we need %zu bytes\n", total, used);
|
|
exit(2);
|
|
}
|
|
|
|
// read file of known size, make sure the size is correct
|
|
bool readFile(void *dst, uint32_t len, const char *fileName)
|
|
{
|
|
FILE *f = fopen(fileName, "rb");
|
|
bool ret = false;
|
|
|
|
if (!f)
|
|
return false;
|
|
|
|
if (len != fread(dst, 1, len, f))
|
|
goto out;
|
|
|
|
if (fread(&len, 1, 1, f)) //make sure file is actually over
|
|
goto out;
|
|
|
|
ret = true;
|
|
|
|
out:
|
|
fclose(f);
|
|
return ret;
|
|
}
|
|
|
|
// read complete file of unknown size, return malloced buffer and size
|
|
void *loadFile(const char *fileName, uint32_t *size)
|
|
{
|
|
FILE *f = fopen(fileName, "rb");
|
|
uint8_t *dst = NULL;
|
|
uint32_t len = 0, grow = 16384, total = 0;
|
|
uint32_t block;
|
|
|
|
if (!f) {
|
|
fprintf(stderr, "couldn't open %s: %s\n", fileName, strerror(errno));
|
|
exit(2);
|
|
}
|
|
|
|
do {
|
|
len += grow; dst = reallocOrDie(dst, len);
|
|
|
|
block = fread(dst + total, 1, grow, f);
|
|
total += block;
|
|
} while (block == grow);
|
|
|
|
*size = total;
|
|
if (!feof(f)) {
|
|
fprintf(stderr, "Failed to read entire file %s: %s\n",
|
|
fileName, strerror(errno));
|
|
free(dst);
|
|
fclose(f);
|
|
dst = NULL;
|
|
exit(2);
|
|
}
|
|
|
|
fclose(f);
|
|
return dst;
|
|
}
|
|
|
|
static void doPrintHash(FILE *out, const char *pfx, const uint32_t *hash, size_t size, int increment)
|
|
{
|
|
size_t i;
|
|
int pos;
|
|
fprintf(out, "%s: ", pfx);
|
|
for (i = 0, pos = 0; i < size; ++i, pos += increment)
|
|
fprintf(out, "%08" PRIx32, hash[pos]);
|
|
fprintf(out, "\n");
|
|
}
|
|
|
|
void printHash(FILE *out, const char *pfx, const uint32_t *hash, size_t size)
|
|
{
|
|
doPrintHash(out, pfx, hash, size, 1);
|
|
}
|
|
|
|
void printHashRev(FILE *out, const char *pfx, const uint32_t *hash, size_t size)
|
|
{
|
|
doPrintHash(out, pfx, hash + size - 1, size, -1);
|
|
}
|