Merge "Remove dead code."
This commit is contained in:
Elliott Hughes
Gerrit Code Review
commit
9f2944aab0
2 changed files with 0 additions and 361 deletions
|
|
@ -1,26 +0,0 @@
|
|||
/*
|
||||
* 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.
|
||||
*/
|
||||
|
||||
typedef enum {
|
||||
SHA_1,
|
||||
} HashAlgorithm;
|
||||
|
||||
int get_file_hash(HashAlgorithm algorithm, const char *path,
|
||||
char *output_string, size_t max_output_string);
|
||||
|
||||
int get_recursive_hash_manifest(HashAlgorithm algorithm,
|
||||
const char *directory_path,
|
||||
char **output_string);
|
||||
|
|
@ -1,335 +0,0 @@
|
|||
/*
|
||||
* 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);
|
||||
closedir(d);
|
||||
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;
|
||||
}
|
||||
Loading…
Reference in a new issue