Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
tree: e02dac4f6e
Fetching contributors…

Cannot retrieve contributors at this time

335 lines (276 sloc) 8.291 kB
/*
* Copyright (C) 2007 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 <dirent.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sha1.h>
#include <unistd.h>
#include <limits.h>
#include <sys/stat.h>
#include <netinet/in.h>
#include <resolv.h>
#include <cutils/dir_hash.h>
/**
* Copies, if it fits within max_output_string bytes, into output_string
* a hash of the contents, size, permissions, uid, and gid of the file
* specified by path, using the specified algorithm. Returns the length
* of the output string, or a negative number if the buffer is too short.
*/
int get_file_hash(HashAlgorithm algorithm, const char *path,
char *output_string, size_t max_output_string) {
SHA1_CTX context;
struct stat sb;
unsigned char md[SHA1_DIGEST_LENGTH];
int used;
size_t n;
if (algorithm != SHA_1) {
errno = EINVAL;
return -1;
}
if (stat(path, &sb) != 0) {
return -1;
}
if (S_ISLNK(sb.st_mode)) {
char buf[PATH_MAX];
int len;
len = readlink(path, buf, sizeof(buf));
if (len < 0) {
return -1;
}
SHA1Init(&context);
SHA1Update(&context, (unsigned char *) buf, len);
SHA1Final(md, &context);
} else if (S_ISREG(sb.st_mode)) {
char buf[10000];
FILE *f = fopen(path, "rb");
int len;
if (f == NULL) {
return -1;
}
SHA1Init(&context);
while ((len = fread(buf, 1, sizeof(buf), f)) > 0) {
SHA1Update(&context, (unsigned char *) buf, len);
}
if (ferror(f)) {
fclose(f);
return -1;
}
fclose(f);
SHA1Final(md, &context);
}
if (S_ISLNK(sb.st_mode) || S_ISREG(sb.st_mode)) {
used = b64_ntop(md, SHA1_DIGEST_LENGTH,
output_string, max_output_string);
if (used < 0) {
errno = ENOSPC;
return -1;
}
n = snprintf(output_string + used, max_output_string - used,
" %d 0%o %d %d", (int) sb.st_size, sb.st_mode,
(int) sb.st_uid, (int) sb.st_gid);
} else {
n = snprintf(output_string, max_output_string,
"- - 0%o %d %d", sb.st_mode,
(int) sb.st_uid, (int) sb.st_gid);
}
if (n >= max_output_string - used) {
errno = ENOSPC;
return -(used + n);
}
return used + n;
}
struct list {
char *name;
struct list *next;
};
static int cmp(const void *a, const void *b) {
struct list *const *ra = a;
struct list *const *rb = b;
return strcmp((*ra)->name, (*rb)->name);
}
static int recurse(HashAlgorithm algorithm, const char *directory_path,
struct list **out) {
struct list *list = NULL;
struct list *f;
struct dirent *de;
DIR *d = opendir(directory_path);
if (d == NULL) {
return -1;
}
while ((de = readdir(d)) != NULL) {
if (strcmp(de->d_name, ".") == 0) {
continue;
}
if (strcmp(de->d_name, "..") == 0) {
continue;
}
char *name = malloc(strlen(de->d_name) + 1);
struct list *node = malloc(sizeof(struct list));
if (name == NULL || node == NULL) {
struct list *next;
for (f = list; f != NULL; f = next) {
next = f->next;
free(f->name);
free(f);
}
free(name);
free(node);
return -1;
}
strcpy(name, de->d_name);
node->name = name;
node->next = list;
list = node;
}
closedir(d);
for (f = list; f != NULL; f = f->next) {
struct stat sb;
char *name;
char outstr[NAME_MAX + 100];
char *keep;
struct list *res;
name = malloc(strlen(f->name) + strlen(directory_path) + 2);
if (name == NULL) {
struct list *next;
for (f = list; f != NULL; f = f->next) {
next = f->next;
free(f->name);
free(f);
}
for (f = *out; f != NULL; f = f->next) {
next = f->next;
free(f->name);
free(f);
}
*out = NULL;
return -1;
}
sprintf(name, "%s/%s", directory_path, f->name);
int len = get_file_hash(algorithm, name,
outstr, sizeof(outstr));
if (len < 0) {
// should not happen
return -1;
}
keep = malloc(len + strlen(name) + 3);
res = malloc(sizeof(struct list));
if (keep == NULL || res == NULL) {
struct list *next;
for (f = list; f != NULL; f = f->next) {
next = f->next;
free(f->name);
free(f);
}
for (f = *out; f != NULL; f = f->next) {
next = f->next;
free(f->name);
free(f);
}
*out = NULL;
free(keep);
free(res);
return -1;
}
sprintf(keep, "%s %s\n", name, outstr);
res->name = keep;
res->next = *out;
*out = res;
if ((stat(name, &sb) == 0) && S_ISDIR(sb.st_mode)) {
if (recurse(algorithm, name, out) < 0) {
struct list *next;
for (f = list; f != NULL; f = next) {
next = f->next;
free(f->name);
free(f);
}
return -1;
}
}
}
struct list *next;
for (f = list; f != NULL; f = next) {
next = f->next;
free(f->name);
free(f);
}
}
/**
* Allocates a string containing the names and hashes of all files recursively
* reached under the specified directory_path, using the specified algorithm.
* The string is returned as *output_string; the return value is the length
* of the string, or a negative number if there was a failure.
*/
int get_recursive_hash_manifest(HashAlgorithm algorithm,
const char *directory_path,
char **output_string) {
struct list *out = NULL;
struct list *r;
struct list **list;
int count = 0;
int len = 0;
int retlen = 0;
int i;
char *buf;
if (recurse(algorithm, directory_path, &out) < 0) {
return -1;
}
for (r = out; r != NULL; r = r->next) {
count++;
len += strlen(r->name);
}
list = malloc(count * sizeof(struct list *));
if (list == NULL) {
struct list *next;
for (r = out; r != NULL; r = next) {
next = r->next;
free(r->name);
free(r);
}
return -1;
}
count = 0;
for (r = out; r != NULL; r = r->next) {
list[count++] = r;
}
qsort(list, count, sizeof(struct list *), cmp);
buf = malloc(len + 1);
if (buf == NULL) {
struct list *next;
for (r = out; r != NULL; r = next) {
next = r->next;
free(r->name);
free(r);
}
free(list);
return -1;
}
for (i = 0; i < count; i++) {
int n = strlen(list[i]->name);
strcpy(buf + retlen, list[i]->name);
retlen += n;
}
free(list);
struct list *next;
for (r = out; r != NULL; r = next) {
next = r->next;
free(r->name);
free(r);
}
*output_string = buf;
return retlen;
}
Jump to Line
Something went wrong with that request. Please try again.