xref: /system/core/libcutils/dir_hash.c

/*
 * 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;
}