From 4303aa143b408acd3475e01f6ed243d61c559b2b Mon Sep 17 00:00:00 2001
From: Matthias Ruester <ruester@molgen.mpg.de>
Date: Fri, 9 Dec 2011 09:04:20 +0100
Subject: [PATCH 01/11] bee-dep: assign TBLSIZE to a long-int constant

---
 src/hash.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/hash.h b/src/hash.h
index c4faf35..ab9a797 100644
--- a/src/hash.h
+++ b/src/hash.h
@@ -29,7 +29,7 @@
 
 #include "beedep_tree.h"
 
-#define TBLSIZE 2000003 /* prime number */
+#define TBLSIZE 2000003L /* prime number */
 
 struct hash {
     struct tree *tbl[TBLSIZE];

From a8d55f5bca91595aa84c31c599f0b2977be57c3d Mon Sep 17 00:00:00 2001
From: Matthias Ruester <ruester@molgen.mpg.de>
Date: Fri, 9 Dec 2011 09:09:13 +0100
Subject: [PATCH 02/11] bee-dep: add hash_safe_insert and remove unneeded
 struct member variable

---
 src/graph.c |  6 ------
 src/hash.c  | 14 +++++++++++++-
 src/hash.h  |  2 +-
 3 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/src/graph.c b/src/graph.c
index 0643d26..9b31abf 100644
--- a/src/graph.c
+++ b/src/graph.c
@@ -498,7 +498,6 @@ int print_removable(struct hash *hash, char *remove)
 int save_cache(struct hash *hash, char *path)
 {
     int i;
-    unsigned long index;
     struct tree_node *s, *t;
     FILE *file;
 
@@ -507,11 +506,6 @@ int save_cache(struct hash *hash, char *path)
         return EXIT_FAILURE;
     }
 
-    index = 0;
-
-    if (hash->cnt == 0)
-        return EXIT_SUCCESS;
-
     for (i = 0; i < TBLSIZE; i++) {
         if (hash->tbl[i]->root) {
             t = tree_first(hash->tbl[i]->root);
diff --git a/src/hash.c b/src/hash.c
index f3b137e..70d72a9 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -62,8 +62,20 @@ void hash_insert(struct hash *hash, struct node *n)
     unsigned long index = hash_index(n->name);
 
     tree_insert(hash->tbl[index], n);
+}
+
+struct node *hash_safe_insert(struct hash *hash, struct node *n)
+{
+    unsigned long index = hash_index(n->name);
+    struct node *r;
 
-    hash->cnt++;
+    r = tree_search_node(hash->tbl[index], n->name);
+
+    if (r)
+        return r;
+
+    tree_insert(hash->tbl[index], n);
+    return n;
 }
 
 struct node *hash_search(struct hash *hash, char *key)
diff --git a/src/hash.h b/src/hash.h
index ab9a797..f0d0835 100644
--- a/src/hash.h
+++ b/src/hash.h
@@ -33,12 +33,12 @@
 
 struct hash {
     struct tree *tbl[TBLSIZE];
-    unsigned long cnt;
 };
 
 extern struct hash *hash_new(void);
 extern unsigned long hash_index(char *key);
 extern void hash_insert(struct hash *hash, struct node *n);
+extern struct node *hash_safe_insert(struct hash *hash, struct node *n);
 extern struct node *hash_search(struct hash *hash, char *key);
 extern void hash_free(struct hash *hash);
 

From 9b6e6ee558b71f4bed78389b94de880ea609cc53 Mon Sep 17 00:00:00 2001
From: Matthias Ruester <ruester@molgen.mpg.de>
Date: Fri, 9 Dec 2011 09:22:36 +0100
Subject: [PATCH 03/11] bee-dep: use hash_safe_insert to gain a litte speedup

---
 src/graph.c | 37 ++++++++++++++++++++-----------------
 1 file changed, 20 insertions(+), 17 deletions(-)

diff --git a/src/graph.c b/src/graph.c
index 9b31abf..a3db32a 100644
--- a/src/graph.c
+++ b/src/graph.c
@@ -93,7 +93,7 @@ int graph_insert_nodes(struct hash *hash, char *filename)
          pkgname[NODENAME_MAX]  = {0},
          nodename[NODENAME_MAX] = {0};
     int l, line_cnt;
-    struct node *n, *h, *v;
+    struct node *n, *h, *v, *c;
 
     if ((file = fopen(filename, "r")) == NULL) {
         perror("bee-dep: graph_insert_nodes: fopen");
@@ -160,10 +160,10 @@ int graph_insert_nodes(struct hash *hash, char *filename)
                 sprintf(nodename, "%s", s);
             }
 
-            if ((n = hash_search(hash, nodename)) == NULL) {
-                n = node_new(nodename, UNKNOWN);
-                hash_insert(hash, n);
-            }
+            c = node_new(nodename, UNKNOWN);
+            n = hash_safe_insert(hash, c);
+            if (c != n)
+                node_free(c);
 
             type_flag = 0;
             continue;
@@ -215,18 +215,20 @@ int graph_insert_nodes(struct hash *hash, char *filename)
 
             type_flag = 1;
         } else if (strcasecmp(prop, PROVIDES) == 0) {
-            if ((h = hash_search(hash, value)) == NULL) {
-                h = node_new(value, UNKNOWN);
-                hash_insert(hash, h);
-            }
+            c = node_new(value, UNKNOWN);
+            h = hash_safe_insert(hash, c);
+
+            if (c != h)
+                node_free(c);
 
             if (IS_FILE(value)) {
                 sprintf(nodename, "%s%s", pkgname, value);
 
-                if ((v = hash_search(hash, nodename)) == NULL) {
-                    v = node_new(nodename, UNKNOWN);
-                    hash_insert(hash, v);
-                }
+                c = node_new(nodename, UNKNOWN);
+                v = hash_safe_insert(hash, c);
+
+                if (v != c)
+                    node_free(c);
 
                 add_provide(n, v);
                 add_provide(v, h);
@@ -234,10 +236,11 @@ int graph_insert_nodes(struct hash *hash, char *filename)
                 add_provide(n, h);
             }
         } else if (strcasecmp(prop, NEEDS) == 0) {
-            if ((h = hash_search(hash, value)) == NULL) {
-                h = node_new(value, UNKNOWN);
-                hash_insert(hash, h);
-            }
+            c = node_new(value, UNKNOWN);
+            h = hash_safe_insert(hash, c);
+
+            if (c != h)
+                node_free(c);
 
             add_need(n, h);
         }

From cdf2a7697fc8edbfd7fd9586d5d78167c05fe54c Mon Sep 17 00:00:00 2001
From: Matthias Ruester <ruester@molgen.mpg.de>
Date: Fri, 9 Dec 2011 09:20:58 +0100
Subject: [PATCH 04/11] bee-dep: assign often used variables as register
 variables

---
 src/graph.c | 2 +-
 src/hash.c  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/graph.c b/src/graph.c
index a3db32a..b0f3938 100644
--- a/src/graph.c
+++ b/src/graph.c
@@ -85,7 +85,7 @@ char is_virtual_file(char *s)
 int graph_insert_nodes(struct hash *hash, char *filename)
 {
     FILE *file;
-    char *s, *p, *a;
+    register char *s, *p, *a;
     char type_flag, u;
     char line[LINE_MAX],
          prop[LINE_MAX],
diff --git a/src/hash.c b/src/hash.c
index 70d72a9..85bed0b 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -47,7 +47,7 @@ struct hash *hash_new(void)
 
 unsigned long hash_index(char *key)
 {
-    unsigned long index = 0;
+    register unsigned long index = 0;
     char c;
 
     while ((c = *key++))

From e8ab566ceff76eb37869515834073a0127dc6bca Mon Sep 17 00:00:00 2001
From: Matthias Ruester <ruester@molgen.mpg.de>
Date: Fri, 9 Dec 2011 09:29:04 +0100
Subject: [PATCH 05/11] bee-dep: add features and therefore rewrite the option
 logic

---
 src/bee-dep.c | 863 +++++++++++++++++++++++++++++++++++++++-----------
 src/graph.c   | 595 ++++++++++++++++++++++++++++++----
 src/graph.h   |  13 +-
 3 files changed, 1217 insertions(+), 254 deletions(-)

diff --git a/src/bee-dep.c b/src/bee-dep.c
index c94d0fd..27b981f 100644
--- a/src/bee-dep.c
+++ b/src/bee-dep.c
@@ -30,54 +30,205 @@
 #include <string.h>
 #include <limits.h>
 #include <dirent.h>
-#include <sys/file.h>
 #include <libgen.h>
 #include <unistd.h>
 #include <getopt.h>
+#include <fcntl.h>
 
 #include "graph.h"
 
 #define CACHENAME "index.db"
+#define TMPNAME   "index.tmp"
+#define LOCKNAME  "index.lock"
+
+#define REBUILD   1
+#define UPDATE    2
+#define REMOVE    3
+#define LIST      4
+#define CONFLICTS 5
+
+static char *bee_version(void)
+{
+    static char *bee_v = NULL;
+
+    if (!bee_v)
+        bee_v = getenv("BEE_VERSION");
+
+    return bee_v;
+}
+
+static char *bee_metadir(void)
+{
+    static char *bee_md = NULL;
+
+    if (!bee_md)
+        bee_md = getenv("BEE_METADIR");
+
+    return bee_md;
+}
+
+static char *bee_cachedir(void)
+{
+    static char *bee_cd = NULL;
+
+    if (!bee_cd)
+        bee_cd = getenv("BEE_CACHEDIR");
+
+    return bee_cd;
+}
+
+static void get_bee_variables(void)
+{
+    if (!bee_version()) {
+        fprintf(stderr, "BEE-ERROR: please call bee-dep from bee\n");
+        exit(1);
+    }
+
+    if (!bee_metadir()) {
+        fprintf(stderr, "BEE-ERROR: BEE_METADIR not set\n");
+        exit(1);
+    }
+
+    if (!bee_cachedir()) {
+        fprintf(stderr, "BEE_ERROR: BEE_CACHEDIR not set\n");
+        exit(1);
+    }
+}
+
+static char *cache_filename(void)
+{
+    static char cache[PATH_MAX + 1] = {0};
+
+    if (!cache[0])
+        sprintf(cache, "%s/%s", bee_cachedir(), CACHENAME);
+
+    return cache;
+}
+
+static char *lock_filename(void)
+{
+    static char lock[PATH_MAX + 1] = {0};
+
+    if (!lock[0])
+        sprintf(lock, "%s/%s", bee_cachedir(), LOCKNAME);
+
+    return lock;
+}
+
+static void usage_header(void)
+{
+    printf("bee-dep v%s 2011\n"
+           "  by Matthias Ruester and Lucas Schwass\n"
+           "     Max Planck Institute for Molecular Genetics Berlin Dahlem\n\n",
+           getenv("BEE_VERSION"));
+}
 
 static void usage(void)
 {
-     printf("bee-dep v%s 2011\n"
-            "  by Matthias Ruester and Lucas Schwass\n"
-            "     Max Planck Institute for Molecular Genetics Berlin Dahlem\n\n"
-
-            "Usage: bee dep <OPTION> [PKGNAME]\n\n"
-
-            "Options:\n"
-            "    --rebuild                      rebuild the cache\n"
-            "    --update          <PKGNAME>    update the cache\n"
-            "    --print-removable <PKGNAME>    print removable files "
-                                               "from package\n"
-            "    --remove          <PKGNAME>    remove package from cache\n",
-            getenv("BEE_VERSION"));
+    usage_header();
+    printf("Usage: bee dep <command> [<args>]\n\n"
+
+           "Commands:\n"
+           "    rebuild      rebuild the cache\n"
+           "    update       update the cache for a specific package\n"
+           "    remove       remove a package from the cache\n"
+           "    list         list information\n"
+           "    conflicts    show conflicting packages\n");
+}
+
+static void usage_rebuild(void)
+{
+    usage_header();
+    printf("Usage: bee dep rebuild\n");
+}
+
+static void usage_update(void)
+{
+    usage_header();
+    printf("Usage: bee dep update [pkgname]\n");
+}
+
+static void usage_remove(void)
+{
+    usage_header();
+    printf("Usage: bee dep remove [options] <pkgname>\n\n"
+
+           "Options:\n"
+           "    --print    print which files can be deleted from the hard drive\n");
+}
+
+static void usage_list(void)
+{
+    usage_header();
+    printf("Usage: bee dep list [options]\n\n"
+
+           "Options:\n"
+           "    --packages\n"
+           "    --files        <pkg>\n"
+           "    --depending-on <pkg|file>\n"
+           "    --required-by  <pkg|file>\n"
+           "    --removable    <pkg>\n"
+           "    --provider-of  <file>\n"
+           "    --count\n");
+}
+
+static void usage_conflicts(void)
+{
+    usage_header();
+    printf("Usage: bee dep conflicts [pkgname]\n");
 }
 
-int init_cache(struct hash *graph, char *bee_metadir, char *filename)
+void ensure_directories(void)
+{
+    char *c;
+    int i;
+    char dir[PATH_MAX + 1] = {0};
+    struct stat st;
+
+    c = bee_cachedir();
+    i = 0;
+
+    while (*c) {
+        dir[i] = *c;
+        c++;
+
+        if (*c == '/' || !(*c)) {
+            if (stat(dir, &st) == -1 && mkdir(dir, 0755) == -1) {
+                perror("mkdir");
+                exit(1);
+            }
+        }
+
+        i++;
+    }
+}
+
+static struct hash *init_cache(void)
 {
     struct dirent **package;
     int i, pkg_cnt;
     char path[PATH_MAX + 1];
     struct stat st;
+    struct hash *graph;
 
-    if ((pkg_cnt = scandir(bee_metadir, &package, 0, alphasort)) < 0) {
-        perror("bee-dep: create_cache: scandir");
-        return EXIT_FAILURE;
+    if ((pkg_cnt = scandir(bee_metadir(), &package, 0, alphasort)) < 0) {
+        perror("bee-dep: init_cache: scandir");
+        return NULL;
     }
 
+    graph = hash_new();
+
     /* skip . and .. */
     free(package[0]);
     free(package[1]);
 
     for (i = 2; i < pkg_cnt; i++) {
-        sprintf(path, "%s/%s", bee_metadir, package[i]->d_name);
+        sprintf(path, "%s/%s", bee_metadir(), package[i]->d_name);
 
         if (stat(path, &st) == -1) {
-            perror("bee-dep: create_cache: stat");
-            return EXIT_FAILURE;
+            perror("bee-dep: init_cache: stat");
+            hash_free(graph);
+            return NULL;
         }
 
         if (S_ISDIR(st.st_mode)) {
@@ -85,14 +236,17 @@ int init_cache(struct hash *graph, char *bee_metadir, char *filename)
 
             if (stat(path, &st) == -1) {
                 fprintf(stderr,
-                        "bee-dep: create_cache: missing "
-                        "DEPENDENCIES file for package '%s'\n",
+                        "bee-dep: init_cache: missing "
+                        "DEPENDENCIES file for package \"%s\"\n",
                         package[i]->d_name);
-                return EXIT_FAILURE;
+                hash_free(graph);
+                return NULL;
             }
 
-            if (graph_insert_nodes(graph, path) == EXIT_FAILURE)
-                return EXIT_FAILURE;
+            if (graph_insert_nodes(graph, path)) {
+                hash_free(graph);
+                return NULL;
+            }
         }
 
         free(package[i]);
@@ -100,259 +254,600 @@ int init_cache(struct hash *graph, char *bee_metadir, char *filename)
 
     free(package);
 
-    return save_cache(graph, filename);
+    if (save_cache(graph, cache_filename())) {
+        hash_free(graph);
+        return NULL;
+    }
+
+    return graph;
 }
 
-void unlock(FILE *cache)
+static int update_cache(struct hash *graph)
 {
-    if (flock(fileno(cache), LOCK_UN) == -1) {
-        perror("bee-dep: unlock: flock");
-        exit(EXIT_FAILURE);
+    struct dirent **package;
+    int i, pkg_cnt;
+    char path[PATH_MAX + 1];
+    struct stat st;
+    struct tree_node *t;
+
+    if ((pkg_cnt = scandir(bee_metadir(), &package, 0, alphasort)) < 0) {
+        perror("bee-dep: update_cache: scandir");
+        return 1;
     }
 
-    if (fclose(cache) == EOF) {
-        perror("bee-dep: unlock: fclose");
-        exit(EXIT_FAILURE);
+    /* skip . and .. */
+    free(package[0]);
+    free(package[1]);
+
+    /* add new (not known) packages */
+    for (i = 2; i < pkg_cnt; i++) {
+        if (hash_search(graph, package[i]->d_name))
+            continue;
+
+        printf("adding %s\n", package[i]->d_name);
+
+        if (sprintf(path, "%s/%s", bee_metadir(), package[i]->d_name) < 0) {
+            perror("bee-dep: update_cache: sprintf");
+            return 1;
+        }
+
+        if (stat(path, &st) == -1) {
+            perror("bee-dep: update_cache: stat");
+            return 1;
+        }
+
+        if (S_ISDIR(st.st_mode)) {
+            strcat(path, "/DEPENDENCIES");
+
+            if (stat(path, &st) == -1) {
+                fprintf(stderr,
+                        "bee-dep: update_cache: missing "
+                        "DEPENDENCIES file for package \"%s\"\n",
+                        package[i]->d_name);
+                return 1;
+            }
+
+            if (graph_insert_nodes(graph, path))
+                return 1;
+        }
+
+        free(package[i]);
     }
+
+    free(package);
+
+    /* remove packages which not exist anymore */
+    for (i = 0; i < TBLSIZE; i++) {
+        t = tree_first(graph->tbl[i]->root);
+
+        while (t) {
+            if (IS_PKG(t->n)) {
+                if (sprintf(path, "%s/%s", bee_metadir(), t->n->name) < 0) {
+                    perror("bee-dep: update_cache: sprintf");
+                    return 1;
+                }
+
+                if (stat(path, &st) == -1) {
+                    printf("removing %s\n", t->n->name);
+
+                    if (remove_package(graph, t->n->name))
+                        return 1;
+                }
+            }
+
+            t = tree_next(t);
+        }
+    }
+
+    return 0;
 }
 
-void cleanup_and_exit(struct hash *h, FILE *f, int r)
+struct hash *get_cache(void)
 {
-    if (h)
-        hash_free(h);
+    struct hash *graph;
+    struct stat st;
+
+    if (stat(cache_filename(), &st) == -1)
+        graph = init_cache();
+    else
+        graph = load_cache(cache_filename());
 
-    if (f)
-        unlock(f);
+    if (!graph)
+        exit(1);
 
-    exit(r);
+    return graph;
 }
 
-void get_bee_variables(char **bee_cachedir, char **bee_metadir)
+static int bee_dep_rebuild(int argc, char *argv[])
 {
-    if (!(*bee_cachedir = getenv("BEE_CACHEDIR"))) {
-        fprintf(stderr, "BEE-ERROR: BEE_CACHEDIR not set\n");
-        exit(EXIT_FAILURE);
+    int c, help;
+    struct hash *graph;
+    struct option long_options[] = {
+        {"help", 0, &help, 1},
+        {0, 0, 0, 0}
+    };
+
+    help = 0;
+
+    while ((c = getopt_long(argc, argv, "", long_options, NULL)) != -1) {
+        switch (c) {
+            case '?':
+                usage_update();
+                return 1;
+        }
     }
 
-    if (!(*bee_metadir = getenv("BEE_METADIR"))) {
-        fprintf(stderr, "BEE-ERROR: BEE_METADIR not set\n");
-        exit(EXIT_FAILURE);
+    if (help) {
+        usage_rebuild();
+        return 0;
+    }
+
+    if (argc > 1) {
+        fprintf(stderr, "bee-dep: too many arguments\n");
+        return 1;
     }
+
+    graph = init_cache();
+    hash_free(graph);
+
+    return 0;
 }
 
-static FILE *open_and_lock(char *filename, char *mode)
+static int bee_dep_update(int argc, char *argv[])
 {
-    FILE *f;
+    int c, help;
+    char *pkg;
+    char path[PATH_MAX + 1];
+    struct hash *graph;
+    struct stat st;
+    struct option long_options[] = {
+        {"help", 0, &help, 1},
+        {0, 0, 0, 0}
+    };
+
+    help = 0;
+
+    while ((c = getopt_long(argc, argv, "", long_options, NULL)) != -1) {
+        switch (c) {
+            case '?':
+                usage_update();
+                return 1;
+        }
+    }
+
+    if (help) {
+        usage_update();
+        return 0;
+    }
+
+    if (argc == 1) {
+        graph = get_cache();
+
+        if (update_cache(graph) || save_cache(graph, cache_filename())) {
+            hash_free(graph);
+            return 1;
+        }
+
+        hash_free(graph);
+        return 0;
+    }
+
+    if (argc < 2) {
+        fprintf(stderr, "bee-dep: pkgname needed\n");
+        return 1;
+    }
+
+    if (argc > 2) {
+        fprintf(stderr, "bee-dep: too many arguments\n");
+        return 1;
+    }
+
+    pkg = argv[1];
+
+    if (sprintf(path, "%s/%s/DEPENDENCIES", bee_metadir(), pkg) < 0) {
+        perror("bee-dep: sprintf");
+        return 1;
+    }
+
+    graph = get_cache();
 
-    if ((f = fopen(filename, mode)) == NULL) {
-        perror("bee-dep: fopen");
-        exit(EXIT_FAILURE);
+    if (stat(path, &st) != -1) {
+        if (hash_search(graph, pkg)) {
+            fprintf(stderr,
+                    "bee-dep: package \"%s\" is already in the cache\n",
+                    pkg);
+            hash_free(graph);
+            return 0;
+        }
+
+        if (graph_insert_nodes(graph, path)) {
+            hash_free(graph);
+            return 1;
+        }
+    } else {
+        if (remove_package(graph, pkg)) {
+            hash_free(graph);
+            return 1;
+        }
     }
 
-    if (flock(fileno(f), LOCK_EX) == -1) {
-        perror("bee-dep: flock");
-        exit(EXIT_FAILURE);
+    if (save_cache(graph, cache_filename())) {
+        hash_free(graph);
+        return 1;
     }
 
-    return f;
+    hash_free(graph);
+    return 0;
 }
 
-int main(int argc, char *argv[])
+static int bee_dep_remove(int argc, char *argv[])
 {
-    int c, help, rebuild, update, remove, print, options;
-    char found;
-    char cachefile[PATH_MAX + 1], path[PATH_MAX + 1], tmp[PATH_MAX + 1];
-    char *bee_metadir, *bee_cachedir, *dir, *pkgname;
+    int c, help, print;
     struct hash *graph;
-    struct stat st;
-    FILE *cache;
-    struct node *h;
-
+    char *pkg;
     struct option long_options[] = {
-        {"help",            0, &help,    1},
-        {"rebuild",         0, &rebuild, 1},
-        {"update",          0, &update,  1},
-        {"remove",          0, &remove,  1},
-        {"print-removable", 0, &print,   1},
+        {"help",  0, &help,  1},
+        {"print", 0, &print, 1},
         {0, 0, 0, 0}
     };
 
-    if (!getenv("BEE_VERSION")) {
-        fprintf(stderr, "BEE-ERROR: please call beedep from bee\n");
-        exit(EXIT_FAILURE);
+    help = print = 0;
+
+    while ((c = getopt_long(argc, argv, "", long_options, NULL)) != -1) {
+        switch (c) {
+            case '?':
+                usage_remove();
+                return 1;
+        }
     }
 
-    get_bee_variables(&bee_cachedir, &bee_metadir);
+    if (help) {
+        usage_remove();
+        return 0;
+    }
 
-    if (argc == 1) {
-        usage();
-        exit(EXIT_FAILURE);
+    if (optind == argc) {
+        fprintf(stderr, "bee-dep: pkgname needed\n");
+        return 1;
+    }
+
+    if (optind < argc - 1) {
+        fprintf(stderr, "bee-dep: too many arguments\n");
+        return 1;
     }
 
-    help    = rebuild = update = remove = print = options = 0;
-    pkgname = NULL;
+    pkg   = argv[optind];
+    graph = get_cache();
+
+    if (print && print_removable(graph, pkg)) {
+        hash_free(graph);
+        return 1;
+    }
+
+    if (remove_package(graph, pkg)
+        || save_cache(graph, cache_filename())) {
+        hash_free(graph);
+        return 1;
+    }
+
+    hash_free(graph);
+    return 0;
+}
+
+static int bee_dep_list(int argc, char *argv[])
+{
+    int c, i, opt_count, help, files, packages, count,
+        depending_on, required_by, removable, provider_of;
+    struct hash *graph;
+    char *name;
+    struct option long_options[] = {
+        {"help",         0, &help,         1},
+        {"files",        0, &files,        1},
+        {"packages",     0, &packages,     1},
+        {"count",        0, &count,        1},
+        {"depending-on", 0, &depending_on, 1},
+        {"required-by",  0, &required_by,  1},
+        {"removable",    0, &removable,    1},
+        {"provider-of",  0, &provider_of,  1},
+        {0, 0, 0, 0}
+    };
+
+    opt_count = help         = files       = packages  = provider_of =
+    count     = depending_on = required_by = removable = 0;
 
     while ((c = getopt_long(argc, argv, "", long_options, NULL)) != -1) {
         switch (c) {
             case '?':
-                usage();
-                exit(EXIT_FAILURE);
-                break;
+                usage_list();
+                return 1;
 
             default:
-                options++;
+                opt_count++;
         }
     }
 
     if (help) {
-        usage();
-        exit(EXIT_SUCCESS);
+        usage_list();
+        return 0;
     }
 
-    if (argc != optind + !rebuild) {
-        if (argc > optind + !rebuild)
-            fprintf(stderr, "bee-dep: too many arguments\n");
-        else
-            fprintf(stderr, "bee-dep: pkgname needed\n");
-
-        exit(EXIT_FAILURE);
+    if (!opt_count && optind != argc) {
+        fprintf(stderr, "bee-dep: too many arguments\n");
+        return 1;
     }
 
-    if (!rebuild)
-        pkgname = argv[optind];
+    if (!opt_count)
+        packages = 1;
 
-    if (!options) {
-        fprintf(stderr, "bee-dep: no option specified\n");
-        exit(EXIT_FAILURE);
+    if (opt_count > 1 && !count) {
+        fprintf(stderr, "bee-dep: too many options specified\n");
+        return 1;
     }
 
-    if (options > 1 && (options != 2 || !(remove && print))) {
-        fprintf(stderr, "bee-dep: too many options specified\n");
-        exit(EXIT_FAILURE);
+    if (packages) {
+        graph = get_cache();
+
+        if (count)
+            printf("%d\n", count_packages(graph));
+        else
+            list_packages(graph);
+
+        hash_free(graph);
+        return 0;
     }
 
-    if (sprintf(cachefile, "%s/%s", bee_cachedir, CACHENAME) < 0
-        || sprintf(tmp, "%s/index.tmp", bee_cachedir) < 0) {
-        perror("bee-dep: sprintf");
-        exit(EXIT_FAILURE);
+    if (optind == argc) {
+        fprintf(stderr, "bee-dep: arguments needed\n");
+        return 1;
     }
 
-    dir = strdup(cachefile);
-    dir = dirname(dir);
+    if (count && (depending_on || required_by))
+        fprintf(stderr, "bee-dep: ignoring option --count\n");
 
-    if (stat(dir, &st) == -1 && mkdir(dir, 0755) == -1) {
-        perror("bee-dep: mkdir");
-        exit(EXIT_FAILURE);
-    }
+    graph = get_cache();
 
-    free(dir);
+    for (i = optind; i < argc; i++) {
+        name = argv[i];
 
-    graph = NULL;
+        if (optind < argc - 1)
+            printf("%s:\n", name);
 
-    found = (stat(cachefile, &st) != -1 && S_ISREG(st.st_mode));
+        if (files) {
+            if (count) {
+                c = count_files(graph, name);
 
-    graph = hash_new();
+                if (c < 0) {
+                    hash_free(graph);
+                    return 1;
+                }
 
-    if (rebuild) {
-        if (init_cache(graph, bee_metadir, tmp) == EXIT_FAILURE)
-            cleanup_and_exit(graph, NULL, EXIT_FAILURE);
+                printf("%d\n", c);
+            } else if (list_files(graph, name)) {
+                 hash_free(graph);
+                 return 1;
+            }
+        }
 
-        cache = open_and_lock(cachefile, "w");
+        if (removable) {
+            if (count) {
+                c = count_removable(graph, name);
 
-        if (rename(tmp, cachefile) == -1) {
-            perror("bee-dep: rename");
-            cleanup_and_exit(graph, cache, EXIT_FAILURE);
+                if (c < 0) {
+                    hash_free(graph);
+                    return 1;
+                }
+
+                printf("%d\n", c);
+            } else if (print_removable(graph, name)) {
+                hash_free(graph);
+                return 1;
+            }
         }
 
-        cleanup_and_exit(graph, cache, EXIT_SUCCESS);
-    }
+        if (depending_on && print_neededby(graph, name)) {
+            hash_free(graph);
+            return 1;
+        }
 
-    if (found) {
-        cache = open_and_lock(cachefile, "r");
+        if (required_by && print_needs(graph, name)) {
+            hash_free(graph);
+            return 1;
+        }
 
-        if (load_cache(graph, cache) == EXIT_FAILURE)
-            cleanup_and_exit(graph, cache, EXIT_FAILURE);
-    } else {
-        if (init_cache(graph, bee_metadir, tmp) == EXIT_FAILURE)
-            cleanup_and_exit(graph, NULL, EXIT_FAILURE);
+        if (provider_of) {
+            if (count) {
+                c = count_providers(graph, name);
 
-        cache = open_and_lock(cachefile, "w");
+                if (c < 0) {
+                    hash_free(graph);
+                    return 1;
+                }
 
-        if (rename(tmp, cachefile) == -1) {
-            perror("bee-dep: rename");
-            cleanup_and_exit(graph, cache, EXIT_FAILURE);
+                printf("%d\n", c);
+            } else if (print_providers(graph, name)) {
+                hash_free(graph);
+                return 1;
+            }
         }
     }
 
-    if (update) {
-        found = !!hash_search(graph, pkgname);
+    hash_free(graph);
+    return 0;
+}
+
+static int bee_dep_conflicts(int argc, char *argv[])
+{
+    int c, opt_count, help;
+    struct hash *graph;
+    struct option long_options[] = {
+        {"help", 0, &help, 1},
+        {0, 0, 0, 0}
+    };
+
+    help = opt_count = 0;
 
-        if (sprintf(path, "%s/%s/DEPENDENCIES",
-                    bee_metadir, pkgname) < 0) {
-            perror("bee-dep: sprintf");
-            cleanup_and_exit(graph, cache, EXIT_FAILURE);
+    while ((c = getopt_long(argc, argv, "", long_options, NULL)) != -1) {
+        switch (c) {
+            case '?':
+                usage_conflicts();
+                return 1;
+
+            default:
+                opt_count++;
         }
+    }
 
-        if (stat(path, &st) != -1) {
-            if (found) {
-                fprintf(stderr, "bee-dep: package '%s' is "
-                        "already in the cache\n", pkgname);
-                cleanup_and_exit(graph, cache, EXIT_SUCCESS);
-            }
+    if (help) {
+        usage_conflicts();
+        return 0;
+    }
 
-            if (graph_insert_nodes(graph, path) == EXIT_FAILURE)
-                cleanup_and_exit(graph, cache, EXIT_FAILURE);
-        } else {
-            if (!found) {
-                fprintf(stderr,
-                        "bee-dep: unknown package '%s'\n", pkgname);
-                cleanup_and_exit(graph, cache, EXIT_FAILURE);
-            }
+    if (optind < argc) {
+        fprintf(stderr, "bee-dep: too many arguments\n");
+        return 1;
+    }
 
-            if ((h = hash_search(graph, pkgname)) == NULL || !IS_PKG(h)) {
-                fprintf(stderr, "bee-dep: unknown package '%s'\n", pkgname);
-                cleanup_and_exit(graph, cache, EXIT_FAILURE);
-            }
+    graph = get_cache();
 
-            if (remove_package(graph, pkgname) == EXIT_FAILURE)
-                cleanup_and_exit(graph, cache, EXIT_FAILURE);
-        }
+    if (print_conflicts(graph)) {
+        hash_free(graph);
+        return 1;
+    }
+
+    hash_free(graph);
+    return 0;
+}
+
+static int get_command(char *command)
+{
+    if (!strcmp("rebuild", command))
+        return REBUILD;
+
+    if (!strcmp("update", command))
+        return UPDATE;
+
+    if (!strcmp("remove", command))
+        return REMOVE;
+
+    if (!strcmp("list", command))
+        return LIST;
+
+    if (!strcmp("conflicts", command))
+        return CONFLICTS;
+
+    return 0;
+}
+
+static FILE *lockfile(void)
+{
+    static FILE *file = NULL;
 
-        if (save_cache(graph, tmp) == EXIT_FAILURE)
-            cleanup_and_exit(graph, cache, EXIT_FAILURE);
+    if (!file) {
+        ensure_directories();
 
-        if (rename(tmp, cachefile) == -1) {
-            perror("bee-dep: rename");
-            cleanup_and_exit(graph, cache, EXIT_FAILURE);
+        if ((file = fopen(lock_filename(), "w")) == NULL) {
+            perror("bee-dep: lockfile");
+            exit(1);
         }
 
-        cleanup_and_exit(graph, cache, EXIT_SUCCESS);
+        fprintf(file, "locked by pid %d\n", getpid());
+        fflush(file);
     }
 
-    if ((h = hash_search(graph, pkgname)) == NULL || !IS_PKG(h)) {
-        fprintf(stderr, "bee-dep: unknown package '%s'\n", pkgname);
-        cleanup_and_exit(graph, cache, EXIT_FAILURE);
+    return file;
+}
+
+void lock(void)
+{
+    FILE *f;
+    struct flock flo;
+
+    f = lockfile();
+
+    flo.l_start  = flo.l_len = 0;
+    flo.l_whence = SEEK_SET;
+    flo.l_type   = F_WRLCK;
+
+    if (fcntl(fileno(f), F_SETLKW, &flo) == -1) {
+        perror("bee-dep: lock");
+        exit(1);
     }
+}
+
+void unlock(void)
+{
+    FILE *f;
+    struct flock flo;
+
+    f = lockfile();
+
+    if (!f)
+        return;
+
+    flo.l_start  = flo.l_len = 0;
+    flo.l_whence = SEEK_SET;
+    flo.l_type   = F_UNLCK;
 
-    if (print) {
-        if (print_removable(graph, pkgname) == EXIT_FAILURE)
-            cleanup_and_exit(graph, cache, EXIT_FAILURE);
+    rewind(f);
+
+    if (ftruncate(fileno(f), 0) == -1) {
+        perror("bee-dep: unlock: ftruncate");
+        exit(1);
     }
 
-    if (remove) {
-        if (remove_package(graph, pkgname) == EXIT_FAILURE)
-            cleanup_and_exit(graph, cache, EXIT_FAILURE);
+    if (fcntl(fileno(f), F_SETLK, &flo) == -1) {
+        perror("bee-dep: unlock: fcntl");
+        exit(1);
+    }
 
-        if (save_cache(graph, tmp) == EXIT_FAILURE)
-            cleanup_and_exit(graph, cache, EXIT_FAILURE);
+    if (fclose(f) == EOF) {
+        perror("bee-dep: unlock: fclose");
+        exit(1);
+    }
+}
 
-        if (rename(tmp, cachefile) == -1) {
-            perror("bee-dep: rename");
-            cleanup_and_exit(graph, cache, EXIT_FAILURE);
-        }
+int main(int argc, char *argv[])
+{
+    int command;
+
+    get_bee_variables();
+
+    if (argc < 2) {
+        usage();
+        return 1;
+    }
+
+    lock();
+    if (atexit(unlock)) {
+        perror("bee-dep: atexit");
+        return 1;
     }
 
-    cleanup_and_exit(graph, cache, EXIT_SUCCESS);
+    command = get_command(argv[1]);
+
+    argv++;
+    argc--;
+
+    switch (command) {
+        case REBUILD:
+            return bee_dep_rebuild(argc, argv);
+
+        case UPDATE:
+            return bee_dep_update(argc, argv);
+
+        case REMOVE:
+            return bee_dep_remove(argc, argv);
+
+        case LIST:
+            return bee_dep_list(argc, argv);
+
+        case CONFLICTS:
+            return bee_dep_conflicts(argc, argv);
+
+        default:
+            usage();
+            return 1;
+    }
 
-    return EXIT_FAILURE;
+    return 0;
 }
diff --git a/src/graph.c b/src/graph.c
index b0f3938..25ad144 100644
--- a/src/graph.c
+++ b/src/graph.c
@@ -97,7 +97,7 @@ int graph_insert_nodes(struct hash *hash, char *filename)
 
     if ((file = fopen(filename, "r")) == NULL) {
         perror("bee-dep: graph_insert_nodes: fopen");
-        return EXIT_FAILURE;
+        return 1;
     }
 
     line_cnt = type_flag = u = 0;
@@ -134,7 +134,7 @@ int graph_insert_nodes(struct hash *hash, char *filename)
                 fprintf(stderr,
                         "bee-dep: %s: error at line %d: missing bracket\n",
                         filename, line_cnt);
-                return EXIT_FAILURE;
+                return 1;
             }
 
             *p = '\0';
@@ -143,7 +143,7 @@ int graph_insert_nodes(struct hash *hash, char *filename)
                 fprintf(stderr,
                         "bee-dep: %s: error at line %d: empty node name\n",
                         filename, line_cnt);
-                return EXIT_FAILURE;
+                return 1;
             }
 
             if (IS_FILE(s)) {
@@ -152,7 +152,7 @@ int graph_insert_nodes(struct hash *hash, char *filename)
                             "bee-dep: %s: error at line %d: "
                             "dont know to which package"
                             "\"%s\" belongs to\n", filename, line_cnt, s);
-                    return EXIT_FAILURE;
+                    return 1;
                 }
 
                 sprintf(nodename, "%s%s", pkgname, s);
@@ -189,7 +189,7 @@ int graph_insert_nodes(struct hash *hash, char *filename)
             fprintf(stderr,
                     "bee-dep: %s: error at line %d: missing value "
                     "for property \"%s\"\n", filename, line_cnt, prop);
-            return EXIT_FAILURE;
+            return 1;
         }
 
         memset(value, '\0', LINE_MAX);
@@ -201,7 +201,7 @@ int graph_insert_nodes(struct hash *hash, char *filename)
                         "bee-dep: %s: error at line %d: "
                         "ambiguous type \"%s\"\n",
                         filename, line_cnt, value);
-                return EXIT_FAILURE;
+                return 1;
             }
 
             node_set_type(n, value);
@@ -248,21 +248,19 @@ int graph_insert_nodes(struct hash *hash, char *filename)
 
     if (fclose(file) == EOF) {
         perror("bee-dep: graph_insert_nodes: fclose");
-        return EXIT_FAILURE;
+        return 1;
     }
 
-    if(line_cnt == 0) {
-       fprintf(stderr, "bee-dep: error: file '%s' is empty\n", filename);
-       /* WTF: why can't we return 0 here for errors ??? */
-       return EXIT_FAILURE;
+    if (line_cnt == 0) {
+        fprintf(stderr, "bee-dep: error: file '%s' is empty\n", filename);
+        return 1;
     }
 
-    /* we dont't want to exit on success ??? or do we? i don't get it! */
-    /* but works for me now.. 8) */
-    return EXIT_SUCCESS;
+    return 0;
 }
 
-void search_dependencies(struct hash *hash, struct node *n, struct tree *d)
+static void search_dependencies(struct hash *hash, struct node *n,
+                                struct tree *d)
 {
     struct tree_node *t;
     char *pkgname;
@@ -270,10 +268,13 @@ void search_dependencies(struct hash *hash, struct node *n, struct tree *d)
     t = tree_first(n->neededby->root);
 
     while (t) {
-        pkgname = get_pkgname(t->n->name);
-        if (is_virtual_file(t->n->name))
-            tree_insert(d, hash_search(hash, pkgname));
-        free(pkgname);
+        if (is_virtual_file(t->n->name)) {
+            pkgname = get_pkgname(t->n->name);
+            if (!tree_search_node(d, pkgname))
+                tree_insert(d, hash_search(hash, pkgname));
+            free(pkgname);
+        }
+
         t = tree_next(t);
     }
 
@@ -285,43 +286,27 @@ void search_dependencies(struct hash *hash, struct node *n, struct tree *d)
     }
 }
 
-void print_dependencies(struct hash *hash, char *depend)
+static int print_dependencies(struct hash *hash, struct node *n)
 {
-    struct node *n;
     struct tree *t;
     struct tree_node *e;
 
-    if ((n = hash_search(hash, depend)) == NULL) {
-        fprintf(stderr,
-                "bee-dep: print_dependencies: cannot find \"%s\"\n",
-                depend);
-        return;
-    }
-
-    if (strcmp(n->type, PACKAGE)) {
-        fprintf(stderr,
-                "bee-dep: print_dependencies: \"%s\": no such package\n",
-                depend);
-        return;
-    }
-
     t = tree_new();
 
     search_dependencies(hash, n, t);
 
     e = tree_first(t->root);
 
-    if (!e)
-        puts("none");
-
     while (e) {
-        if (strcmp(depend, e->n->name) != 0)
+        if (strcmp(n->name, e->n->name) != 0)
             puts(e->n->name);
 
         e = tree_next(e);
     }
 
     tree_free(t);
+
+    return 0;
 }
 
 void add_all_neededby(struct hash *hash, struct node *n, struct tree *a)
@@ -449,14 +434,14 @@ int print_removable(struct hash *hash, char *remove)
         fprintf(stderr,
                 "bee-dep: print_removable: cannot find \"%s\"\n",
                 remove);
-        return EXIT_FAILURE;
+        return 1;
     }
 
     if (!IS_PKG(n)) {
         fprintf(stderr,
                 "bee-dep: print_removable: \"%s\": no such package\n",
                 remove);
-        return EXIT_FAILURE;
+        return 1;
     }
 
     t = tree_new();
@@ -468,7 +453,7 @@ int print_removable(struct hash *hash, char *remove)
     if ((dirs = calloc(cnt, sizeof(*dirs))) == NULL
         || (files = calloc(cnt, sizeof(*files))) == NULL) {
         perror("bee-dep: print_removable: calloc");
-        return EXIT_FAILURE;
+        return 1;
     }
 
     e = tree_first(t->root);
@@ -495,7 +480,428 @@ int print_removable(struct hash *hash, char *remove)
     free(files);
     tree_free(t);
 
-    return EXIT_SUCCESS;
+    return 0;
+}
+
+int count_removable(struct hash *hash, char *remove)
+{
+    struct node *n;
+    struct tree *t;
+    int c;
+
+    if ((n = hash_search(hash, remove)) == NULL) {
+        fprintf(stderr,
+                "bee-dep: print_removable: cannot find \"%s\"\n",
+                remove);
+        return -1;
+    }
+
+    if (!IS_PKG(n)) {
+        fprintf(stderr,
+                "bee-dep: print_removable: \"%s\": no such package\n",
+                remove);
+        return -1;
+    }
+
+    t = tree_new();
+
+    search_removable(hash, n, t, remove);
+
+    c = tree_count(t);
+
+    tree_free(t);
+
+    return c;
+}
+
+static void list_all_files(struct node *n)
+{
+    struct tree_node *t;
+
+    t = tree_first(n->provide->root);
+
+    while (t) {
+        if (IS_FILE(t->n->name))
+            puts(t->n->name);
+
+        list_all_files(t->n);
+
+        t = tree_next(t);
+    }
+}
+
+static void count_all_files(struct node *n, int *count)
+{
+    struct tree_node *t;
+
+    t = tree_first(n->provide->root);
+
+    while (t) {
+        if (IS_FILE(t->n->name))
+            (*count)++;
+
+        list_all_files(t->n);
+
+        t = tree_next(t);
+    }
+}
+
+int list_files(struct hash *hash, char *pkgname)
+{
+    struct node *n;
+
+    if ((n = hash_search(hash, pkgname)) == NULL) {
+        fprintf(stderr,
+                "bee-dep: list_files: cannot find \"%s\"\n",
+                pkgname);
+        return 1;
+    }
+
+    if (!IS_PKG(n)) {
+        fprintf(stderr,
+                "bee-dep: list_files: \"%s\": no such package\n",
+                pkgname);
+        return 1;
+    }
+
+    list_all_files(n);
+
+    return 0;
+}
+
+int count_files(struct hash *hash, char *pkgname)
+{
+    struct node *n;
+    int c;
+
+    if ((n = hash_search(hash, pkgname)) == NULL) {
+        fprintf(stderr,
+                "bee-dep: count_files: cannot find \"%s\"\n",
+                pkgname);
+        return -1;
+    }
+
+    if (!IS_PKG(n)) {
+        fprintf(stderr,
+                "bee-dep: count_files: \"%s\": no such package\n",
+                pkgname);
+        return -1;
+    }
+
+    c = 0;
+    count_all_files(n, &c);
+
+    return c;
+}
+
+static void get_all_providers(struct node *n, struct tree *all)
+{
+    struct tree_node *t;
+
+    t = tree_first(n->providedby->root);
+
+    while (t) {
+        if (IS_PKG(t->n) && !tree_search_node(all, t->n->name))
+            tree_insert(all, node_new(t->n->name, ""));
+
+        get_all_providers(t->n, all);
+
+        t = tree_next(t);
+    }
+}
+
+int print_providers(struct hash *hash, char *name)
+{
+    struct node *n;
+    struct tree_node *t;
+    struct tree *all;
+
+    if ((n = hash_search(hash, name)) == NULL) {
+        fprintf(stderr,
+                "bee-dep: print_providers: cannot find \"%s\"\n",
+                name);
+        return 1;
+    }
+
+    if (IS_PKG(n)) {
+        fprintf(stderr,
+                "bee-dep: print_providers: \"%s\" is a package\n",
+                name);
+        return 1;
+    }
+
+    all = tree_new();
+
+    get_all_providers(n, all);
+
+    t = tree_first(all->root);
+
+    while (t) {
+        puts(t->n->name);
+        t = tree_next(t);
+    }
+
+    tree_free_all_nodes(all);
+    tree_free(all);
+
+    return 0;
+}
+
+int count_providers(struct hash *hash, char *name)
+{
+    int count;
+    struct node *n;
+    struct tree *all;
+
+    count = 0;
+
+    if ((n = hash_search(hash, name)) == NULL) {
+        fprintf(stderr,
+                "bee-dep: count_providers: cannot find \"%s\"\n",
+                name);
+        return -1;
+    }
+
+    if (IS_PKG(n)) {
+        fprintf(stderr,
+                "bee-dep: count_providers: \"%s\" is a package\n",
+                name);
+        return -1;
+    }
+
+    all = tree_new();
+    get_all_providers(n, all);
+
+    count = tree_count(all);
+
+    tree_free_all_nodes(all);
+    tree_free(all);
+
+    return count;
+}
+
+int get_virtual_files(struct node *n, char *name, struct tree *all)
+{
+    struct tree_node *t;
+
+    t = tree_first(n->providedby->root);
+
+    while (t) {
+        if (!strcmp(name, get_filename(t->n->name))
+            && !tree_search_node(all, t->n->name))
+            tree_insert(all, t->n);
+
+        t = tree_next(t);
+    }
+
+    return tree_count(all);
+}
+
+static void search_requirements(struct hash *hash, struct node *n,
+                                struct tree *d)
+{
+    struct tree_node *t, *u;
+    struct tree *providers;
+
+    t = tree_first(n->need->root);
+
+    while (t) {
+        providers = tree_new();
+
+        get_all_providers(t->n, providers);
+
+        u = tree_first(providers->root);
+
+        while (u) {
+            if (!tree_search_node(d, u->n->name))
+                tree_insert(d, hash_search(hash, u->n->name));
+
+            u = tree_next(u);
+        }
+
+        tree_free_all_nodes(providers);
+        tree_free(providers);
+
+        t = tree_next(t);
+    }
+
+    t = tree_first(n->provide->root);
+
+    while (t) {
+        search_requirements(hash, t->n, d);
+        t = tree_next(t);
+    }
+}
+
+static int print_requirements(struct hash *hash, struct node *n)
+{
+    struct tree *t;
+    struct tree_node *e;
+
+    t = tree_new();
+
+    search_requirements(hash, n, t);
+
+    e = tree_first(t->root);
+
+    while (e) {
+        if (strcmp(n->name, e->n->name) != 0)
+            puts(e->n->name);
+
+        e = tree_next(e);
+    }
+
+    tree_free(t);
+
+    return 0;
+}
+
+int print_needs(struct hash *hash, char *name)
+{
+    struct tree_node *t, *v;
+    struct node *n;
+    struct tree *all, *vf;
+    char *pkgname;
+    int count;
+    char p;
+
+    if ((n = hash_search(hash, name)) == NULL) {
+        fprintf(stderr,
+                "bee-dep: print_needs: cannot find \"%s\"\n",
+                name);
+        return 1;
+    }
+
+    if (IS_PKG(n))
+        return print_requirements(hash, n);
+
+    vf    = tree_new();
+    count = 1;
+
+    if (is_virtual_file(n->name))
+        tree_insert(vf, n);
+    else
+        count = get_virtual_files(n, name, vf);
+
+    if (!count) {
+        fprintf(stderr, "bee-dep: could not get virtual file for \"%s\"\n",
+                name);
+        tree_free(vf);
+        return 1;
+    }
+
+    v = tree_first(vf->root);
+
+    while (v) {
+        all = tree_new();
+
+        t = tree_first(v->n->need->root);
+
+        while (t) {
+            get_all_providers(t->n, all);
+            t = tree_next(t);
+        }
+
+        t = tree_first(all->root);
+        p = (t && count > 1);
+
+        if (p) {
+            pkgname = get_pkgname(v->n->name);
+            printf("%s:\n", pkgname);
+            free(pkgname);
+        }
+
+        while (t) {
+            puts(t->n->name);
+            t = tree_next(t);
+        }
+
+        tree_free_all_nodes(all);
+        tree_free(all);
+
+        v = tree_next(v);
+
+        if (v && p)
+            puts("");
+    }
+
+    tree_free(vf);
+
+    return 0;
+}
+
+int print_neededby(struct hash *hash, char *name)
+{
+    struct node *n;
+    struct tree_node *t;
+    struct tree *all;
+
+    if ((n = hash_search(hash, name)) == NULL) {
+        fprintf(stderr,
+                "bee-dep: print_needs: cannot find \"%s\"\n",
+                name);
+        return 1;
+    }
+
+    if (IS_PKG(n))
+        return print_dependencies(hash, n);
+
+    all = tree_new();
+
+    t = tree_first(n->neededby->root);
+
+    while (t) {
+        get_all_providers(t->n, all);
+        t = tree_next(t);
+    }
+
+    t = tree_first(all->root);
+
+    while (t) {
+        puts(t->n->name);
+        t = tree_next(t);
+    }
+
+    tree_free_all_nodes(all);
+    tree_free(all);
+
+    return 0;
+}
+
+void list_packages(struct hash *hash)
+{
+    int i;
+    struct tree_node *t;
+
+    for (i = 0; i < TBLSIZE; i++) {
+        t = tree_first(hash->tbl[i]->root);
+
+        while (t) {
+            if (IS_PKG(t->n))
+                puts(t->n->name);
+            t = tree_next(t);
+        }
+    }
+}
+
+int count_packages(struct hash *hash)
+{
+    int i, c;
+    struct tree_node *t;
+
+    c = 0;
+
+    for (i = 0; i < TBLSIZE; i++) {
+        t = tree_first(hash->tbl[i]->root);
+
+        while (t) {
+            if (IS_PKG(t->n))
+                c++;
+            t = tree_next(t);
+        }
+    }
+
+    return c;
 }
 
 int save_cache(struct hash *hash, char *path)
@@ -506,7 +912,7 @@ int save_cache(struct hash *hash, char *path)
 
     if ((file = fopen(path, "w")) == NULL) {
         perror("bee-dep: save_cache: fopen");
-        return EXIT_FAILURE;
+        return 1;
     }
 
     for (i = 0; i < TBLSIZE; i++) {
@@ -552,13 +958,13 @@ int save_cache(struct hash *hash, char *path)
 
     if (fclose(file) == EOF) {
         perror("bee-dep: save_cache: fclose");
-        return EXIT_FAILURE;
+        return 1;
     }
 
-    return EXIT_SUCCESS;
+    return 0;
 }
 
-int load_cache(struct hash *hash, FILE *file)
+struct hash *load_cache(char *filename)
 {
     char line[LINE_MAX],
          a[NODENAME_MAX],
@@ -566,8 +972,16 @@ int load_cache(struct hash *hash, FILE *file)
     char c;
     struct node *k, *l;
     int line_cnt;
+    FILE *file;
+    struct hash *hash;
+
+    if ((file = fopen(filename, "r")) == NULL) {
+        perror("bee-dep: load_cache: fopen");
+        return NULL;
+    }
+
+    hash = hash_new();
 
-    rewind(file);
     line_cnt = 0;
 
     while (fgets(line, LINE_MAX, file)) {
@@ -579,7 +993,8 @@ int load_cache(struct hash *hash, FILE *file)
         if (sscanf(line, "%s %s", a, b) == EOF) {
             fprintf(stderr, "beedep: load_cache: "
                             "cache file is broken (line %d)\n", line_cnt);
-            return EXIT_FAILURE;
+            hash_free(hash);
+            return NULL;
         }
 
         hash_insert(hash, node_new(a, b));
@@ -591,7 +1006,8 @@ int load_cache(struct hash *hash, FILE *file)
         if (sscanf(line, "%s %s %c", a, b, &c) == EOF) {
             fprintf(stderr, "beedep: load_cache: "
                             "cache file is broken (line %d)\n", line_cnt);
-            return EXIT_FAILURE;
+            hash_free(hash);
+            return NULL;
         }
 
         k = hash_search(hash, a);
@@ -600,7 +1016,8 @@ int load_cache(struct hash *hash, FILE *file)
         if (!k || !l) {
             fprintf(stderr, "beedep: load_cache: "
                             "cache file is broken (line %d)\n", line_cnt);
-            return EXIT_FAILURE;
+            hash_free(hash);
+            return NULL;
         }
 
         if (c == 'n') {
@@ -612,25 +1029,18 @@ int load_cache(struct hash *hash, FILE *file)
         } else {
             fprintf(stderr, "beedep: load_cache: "
                             "cache file is broken (line %d)\n", line_cnt);
-            return EXIT_FAILURE;
+            hash_free(hash);
+            return NULL;
         }
     }
 
-    return EXIT_SUCCESS;
-}
-
-unsigned long count_providedby(struct hash *hash, char *count)
-{
-    struct node *n;
-
-    if ((n = hash_search(hash, count)) == NULL) {
-        fprintf(stderr,
-                "bee-dep: count_providedby: cannot find \"%s\"\n",
-                count);
-        exit(EXIT_FAILURE);
+    if (fclose(file) == EOF) {
+        perror("bee-dep: load_cache: fclose");
+        hash_free(hash);
+        return NULL;
     }
 
-    return tree_count(n->providedby);
+    return hash;
 }
 
 void remove_all(struct hash *hash, struct node *n)
@@ -674,17 +1084,66 @@ int remove_package(struct hash *hash, char *pkgname)
         fprintf(stderr,
                 "bee-dep: remove_package: cannot find \"%s\"\n",
                 pkgname);
-        return EXIT_FAILURE;
+        return 1;
     }
 
     if (!IS_PKG(n)) {
         fprintf(stderr,
                 "bee-dep: remove_package: \"%s\": no such package\n",
                 pkgname);
-        return EXIT_FAILURE;
+        return 1;
     }
 
     remove_all(hash, n);
 
-    return EXIT_SUCCESS;
+    return 0;
+}
+
+int print_conflicts(struct hash *hash)
+{
+    int i;
+    struct tree_node *t, *s;
+    char *pkgname;
+
+    for (i = 0; i < TBLSIZE; i++) {
+        t = tree_first(hash->tbl[i]->root);
+
+        while (t) {
+            if (!IS_FILE(t->n->name) || IS_DIR(t->n)
+                || tree_count(t->n->providedby) < 2) {
+                t = tree_next(t);
+                continue;
+            }
+
+            printf("%s: ", t->n->name);
+
+            s = tree_first(t->n->providedby->root);
+
+            while (s) {
+                if (IS_PKG(s->n)) {
+                    printf("%s", s->n->name);
+                } else if (is_virtual_file(s->n->name)) {
+                    pkgname = get_pkgname(s->n->name);
+                    printf("%s", pkgname);
+                    free(pkgname);
+                } else {
+                    fprintf(stderr, "bee-dep: print_conflicts: "
+                            "could not get pkgname for \"%s\"\n",
+                            s->n->name);
+                    return 1;
+                }
+
+                s = tree_next(s);
+
+                if (!s)
+                    puts("");
+                else
+                    printf(" ");
+            }
+
+            t = tree_next(t);
+        }
+    }
+
+    return 0;
 }
diff --git a/src/graph.h b/src/graph.h
index 964b83d..6c947c6 100644
--- a/src/graph.h
+++ b/src/graph.h
@@ -43,12 +43,21 @@
 #include "hash.h"
 
 extern int graph_insert_nodes(struct hash *hash, char *filename);
-extern void print_dependencies(struct hash *hash, char *depend);
 extern void print_broken(struct hash *hash, char *remove);
 extern int print_removable(struct hash *hash, char *remove);
+extern int count_removable(struct hash *hash, char *remove);
+extern int list_files(struct hash *hash, char *pkgname);
+extern int count_files(struct hash *hash, char *pkgname);
+extern int print_providers(struct hash *hash, char *name);
+extern int count_providers(struct hash *hash, char *name);
+extern int print_needs(struct hash *hash, char *name);
+extern int print_neededby(struct hash *hash, char *name);
+extern void list_packages(struct hash *hash);
+extern int count_packages(struct hash *hash);
 extern int remove_package(struct hash *hash, char *pkgname);
+extern int print_conflicts(struct hash *hash);
 extern int save_cache(struct hash *hash, char *path);
-extern int load_cache(struct hash *hash, FILE *file);
+extern struct hash *load_cache(char *filename);
 extern unsigned long count_providedby(struct hash *hash, char *count);
 
 #endif

From d6986e7249dd75c925b15b1e36bcb1561373de37 Mon Sep 17 00:00:00 2001
From: Matthias Ruester <ruester@molgen.mpg.de>
Date: Fri, 9 Dec 2011 09:02:50 +0100
Subject: [PATCH 06/11] bee-dep: move macros to their proper location

---
 src/graph.c | 4 ++++
 src/graph.h | 7 ++-----
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/graph.c b/src/graph.c
index 25ad144..dc63850 100644
--- a/src/graph.c
+++ b/src/graph.c
@@ -32,6 +32,10 @@
 
 #include "graph.h"
 
+#define IS_FILE(a)       ((a)[0] == '/')
+#define IS_DIR(a)        (!strcmp((a)->type, DIR))
+#define IS_WHITESPACE(a) ((a) == ' ' || (a) == '\t' || (a) == '\n' || (a) == '\r')
+
 static void add_provide(struct node *a, struct node *b)
 {
     tree_insert(a->provide, b);
diff --git a/src/graph.h b/src/graph.h
index 6c947c6..30edf41 100644
--- a/src/graph.h
+++ b/src/graph.h
@@ -35,13 +35,10 @@
 #define DIR     "DIRECTORY"
 #define UNKNOWN "VOID"
 
-#define IS_FILE(a)       ((a)[0] == '/')
-#define IS_DIR(a)        (!strcmp((a)->type, DIR))
-#define IS_WHITESPACE(a) ((a) == ' ' || (a) == '\t' || (a) == '\n' || (a) == '\r')
-#define IS_PKG(a)        (!strcmp((a)->type, PACKAGE))
-
 #include "hash.h"
 
+#define IS_PKG(a) (!strcmp((a)->type, PACKAGE))
+
 extern int graph_insert_nodes(struct hash *hash, char *filename);
 extern void print_broken(struct hash *hash, char *remove);
 extern int print_removable(struct hash *hash, char *remove);

From 204287020a0fee84f58de74e14d1adf229bb8588 Mon Sep 17 00:00:00 2001
From: Matthias Ruester <ruester@molgen.mpg.de>
Date: Fri, 9 Dec 2011 11:21:21 +0100
Subject: [PATCH 07/11] bee-remove: update call of bee-dep

---
 src/bee-remove.sh.in | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/bee-remove.sh.in b/src/bee-remove.sh.in
index d6d3d83..0ad19dd 100755
--- a/src/bee-remove.sh.in
+++ b/src/bee-remove.sh.in
@@ -60,7 +60,7 @@ pkg_remove() {
 do_remove() {
     pkg=${1}
 
-    FILES=$(${BEE_LIBEXECDIR}/bee/bee.d/bee-dep --remove --print ${pkg##*/})
+    FILES=$(${BEE_LIBEXECDIR}/bee/bee.d/bee-dep remove --print ${pkg##*/})
     if [ $? -ne 0 ] ; then
         echo "removal of ${pkg} failed"
         exit 1

From b5de7169a6a387cfb73649231244fbca7b1d5452 Mon Sep 17 00:00:00 2001
From: Matthias Ruester <ruester@molgen.mpg.de>
Date: Fri, 9 Dec 2011 11:23:06 +0100
Subject: [PATCH 08/11] bee-install: update call of bee-dep

---
 src/bee-install.sh.in | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/bee-install.sh.in b/src/bee-install.sh.in
index 5ab420e..1588382 100755
--- a/src/bee-install.sh.in
+++ b/src/bee-install.sh.in
@@ -286,7 +286,7 @@ do_install() {
 
     if [ "${OPT_NOOP}" != "yes" ]; then
         run_hooks post-install ${pkg}
-        ${BEE_LIBEXECDIR}/bee/bee.d/bee-dep --update ${pkg}
+        ${BEE_LIBEXECDIR}/bee/bee.d/bee-dep update ${pkg}
     fi
 
     if [ "${OPT_UPGRADE}" != "yes" ] ; then

From 1aab47b1933b1d2b5d77126b38c699f48abdfda4 Mon Sep 17 00:00:00 2001
From: Marius Tolzmann <tolzmann@molgen.mpg.de>
Date: Mon, 19 Dec 2011 22:09:20 +0100
Subject: [PATCH 09/11] Revert "Merge branch 'bee-dep-cleanup-pass1'"

This reverts commit 879847b9089e6d2b2310a8ca85d3b4580f9e90bb, reversing
changes made to ca5370abbca944b0479f85ad353dfdba8931e92e.
---
 src/bee-dep.c | 299 +++++++++++++++++---------------------------------
 src/graph.c   |  75 ++++---------
 src/hash.c    |   6 +-
 3 files changed, 124 insertions(+), 256 deletions(-)

diff --git a/src/bee-dep.c b/src/bee-dep.c
index 54d77cf..65f53a0 100644
--- a/src/bee-dep.c
+++ b/src/bee-dep.c
@@ -24,8 +24,6 @@
 ** along with this program; if not, see <http://www.gnu.org/licenses/>.
 */
 
-#define _GNU_SOURCE
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/stat.h>
@@ -43,42 +41,6 @@
 
 #define CACHENAME "index.db"
 
-#define likely(x)       __builtin_expect(!!(x), 1)
-#define unlikely(x)     __builtin_expect(!!(x), 0)
-
-#define BEE_METADIR  env_bee_metadir()
-#define BEE_CACHEDIR env_bee_cachedir()
-
-static char *env_bee_metadir(void)
-{
-    static char *value = NULL;
-
-    if(value)
-        return value;
-
-    value = getenv("BEE_METADIR");
-
-    if(!value)
-        value = "";
-
-    return value;
-}
-
-static char *env_bee_cachedir(void)
-{
-    static char *value = NULL;
-
-    if(value)
-        return value;
-
-    value = getenv("BEE_CACHEDIR");
-
-    if(!value)
-        value = "";
-
-    return value;
-}
-
 static void usage(void)
 {
      printf("bee-dep v%s 2011\n"
@@ -96,32 +58,16 @@ static void usage(void)
             getenv("BEE_VERSION"));
 }
 
-int pkg_to_graph(struct hash *graph, char *pkgname)
-{
-    int ret = 1;
-    char *fname;
-
-    if(asprintf(&fname, "%s/%s/DEPENDENCIES", BEE_METADIR, pkgname) == -1) {
-        perror("bee-dep: pkg_to_graph: asprintf");
-        return -1;
-    }
-
-    ret = graph_insert_nodes(graph, fname);
-
-    free(fname);
-    return ret;
-}
-
-int init_cache(struct hash *graph, char *filename)
+int init_cache(struct hash *graph, char *bee_metadir, char *filename)
 {
     struct dirent **package;
     int i, pkg_cnt;
+    char path[PATH_MAX + 1];
+    struct stat st;
 
-    /* TODO: need to handle all kinds of race conditions here 8) */
-
-    if ((pkg_cnt = scandir(BEE_METADIR, &package, 0, alphasort)) < 0) {
+    if ((pkg_cnt = scandir(bee_metadir, &package, 0, alphasort)) < 0) {
         perror("bee-dep: create_cache: scandir");
-        return 0;
+        return EXIT_FAILURE;
     }
 
     /* skip . and .. */
@@ -129,7 +75,28 @@ int init_cache(struct hash *graph, char *filename)
     free(package[1]);
 
     for (i = 2; i < pkg_cnt; i++) {
-        pkg_to_graph(graph, package[i]->d_name);
+        sprintf(path, "%s/%s", bee_metadir, package[i]->d_name);
+
+        if (stat(path, &st) == -1) {
+            perror("bee-dep: create_cache: stat");
+            return EXIT_FAILURE;
+        }
+
+        if (S_ISDIR(st.st_mode)) {
+            strcat(path, "/DEPENDENCIES");
+
+            if (stat(path, &st) == -1) {
+                fprintf(stderr,
+                        "bee-dep: create_cache: missing "
+                        "DEPENDENCIES file for package '%s'\n",
+                        package[i]->d_name);
+                return EXIT_FAILURE;
+            }
+
+            if (graph_insert_nodes(graph, path) == EXIT_FAILURE)
+                return EXIT_FAILURE;
+        }
+
         free(package[i]);
     }
 
@@ -162,6 +129,19 @@ void cleanup_and_exit(struct hash *h, FILE *f, int r)
     exit(r);
 }
 
+void get_bee_variables(char **bee_cachedir, char **bee_metadir)
+{
+    if (!(*bee_cachedir = getenv("BEE_CACHEDIR"))) {
+        fprintf(stderr, "BEE-ERROR: BEE_CACHEDIR not set\n");
+        exit(EXIT_FAILURE);
+    }
+
+    if (!(*bee_metadir = getenv("BEE_METADIR"))) {
+        fprintf(stderr, "BEE-ERROR: BEE_METADIR not set\n");
+        exit(EXIT_FAILURE);
+    }
+}
+
 static FILE *open_and_lock(char *filename, char *mode)
 {
     FILE *f;
@@ -212,88 +192,16 @@ int mkdirp(char *path, mode_t mode)
   return 0;
 }
 
-/*
- * checks if given filename is a regular file
- * returns:
- *
- *   1 : file exists and is a regular file
- *   0 : file is not a regular file or does not exist
- *       check errno for
- *          EEXIST : file exists but is not a regular file
- *          ENOENT : file does not exist
- *  -1 : error; check errno see(stat(2))
- */
-int regular_file_exists(char *fname)
-{
-    struct stat st;
-    int ret;
-
-    ret = stat(fname, &st);
-
-    if(likely(ret == 0)) {
-        if(likely(S_ISREG(st.st_mode)))
-            return 1;
-
-        /* set errno for file exists but is not a regular file */
-        errno = EEXIST;
-        return 0;
-    }
-
-    if (likely(errno == ENOENT))
-        return 0;
-
-    return -1;
-}
-
-char *get_cachefilename(void)
-{
-    char *cfname;
-
-    if(asprintf(&cfname, "%s/%s", BEE_CACHEDIR, CACHENAME) == -1) {
-        perror("bee-dep: get_cachefilename");
-        return NULL;
-    }
-    return cfname;
-}
-
-int do_rebuild_cachedb(void)
-{
-    char *cfname;
-    struct hash *graph;
-    int ret;
-
-    cfname = get_cachefilename();
-
-    if (!cfname)
-        return 0;
-
-    graph = hash_new();
-
-    if (!graph) {
-        free(cfname);
-        return 0;
-    }
-
-    ret = init_cache(graph, cfname);
-
-    free(cfname);
-    hash_free(graph);
-
-    return ret;
-}
-
 int main(int argc, char *argv[])
 {
     int c, help, rebuild, update, remove, print, options;
-    int ret;
-    char *cachefile = NULL;
-    char *depfile   = NULL;
     char found;
-    char *pkgname;
+    char cachefile[PATH_MAX + 1], path[PATH_MAX + 1], tmp[PATH_MAX + 1];
+    char *bee_metadir, *bee_cachedir, *pkgname;
     struct hash *graph;
     struct stat st;
-    FILE *cache = NULL;
-    struct node *hnode;
+    FILE *cache;
+    struct node *h;
 
     struct option long_options[] = {
         {"help",            0, &help,    1},
@@ -309,6 +217,8 @@ int main(int argc, char *argv[])
         exit(EXIT_FAILURE);
     }
 
+    get_bee_variables(&bee_cachedir, &bee_metadir);
+
     if (argc == 1) {
         usage();
         exit(EXIT_FAILURE);
@@ -356,133 +266,120 @@ int main(int argc, char *argv[])
         exit(EXIT_FAILURE);
     }
 
-    if (mkdirp(BEE_CACHEDIR, 0755) == -1) {
-        perror("bee-dep: mkdirp");
+    if (sprintf(cachefile, "%s/%s", bee_cachedir, CACHENAME) < 0
+        || sprintf(tmp, "%s/index.tmp", bee_cachedir) < 0) {
+        perror("bee-dep: sprintf");
         exit(EXIT_FAILURE);
     }
 
-    if (rebuild) {
-        if(!do_rebuild_cachedb())
-            return EXIT_FAILURE;
-        return EXIT_SUCCESS;
-    }
-
-    if(!(graph = hash_new())) {
-        perror("bee-dep: hash_new");
+    if (mkdirp(bee_cachedir, 0755) == -1) {
+        perror("bee-dep: mkdirp");
         exit(EXIT_FAILURE);
     }
 
-    if(!(cachefile = get_cachefilename())) {
-        hash_free(graph);
-        exit(EXIT_FAILURE);
-    }
+    found = (stat(cachefile, &st) != -1 && S_ISREG(st.st_mode));
 
+    graph = hash_new();
 
-    ret = regular_file_exists(cachefile);
+    if (rebuild) {
+        if (init_cache(graph, bee_metadir, tmp) == EXIT_FAILURE)
+            cleanup_and_exit(graph, NULL, EXIT_FAILURE);
 
-    if (ret == -1 || (ret == 0 && errno != ENOENT)) {
-        perror("bee-dep: regular_file_exists(cachefile)");
-        free(cachefile);
-        cleanup_and_exit(graph, cache, EXIT_FAILURE);
-    } else if (ret) {
-        cache = open_and_lock(cachefile, "r");
+        cache = open_and_lock(cachefile, "w");
 
-        if (!load_cache(graph, cache)) {
-            free(cachefile);
+        if (rename(tmp, cachefile) == -1) {
+            perror("bee-dep: rename");
             cleanup_and_exit(graph, cache, EXIT_FAILURE);
         }
+
+        cleanup_and_exit(graph, cache, EXIT_SUCCESS);
+    }
+
+    if (found) {
+        cache = open_and_lock(cachefile, "r");
+
+        if (load_cache(graph, cache) == EXIT_FAILURE)
+            cleanup_and_exit(graph, cache, EXIT_FAILURE);
     } else {
-        if (!init_cache(graph, cachefile)) {
-            free(cachefile);
-            hash_free(graph);
-            return EXIT_FAILURE;
+        if (init_cache(graph, bee_metadir, tmp) == EXIT_FAILURE)
+            cleanup_and_exit(graph, NULL, EXIT_FAILURE);
+
+        cache = open_and_lock(cachefile, "w");
+
+        if (rename(tmp, cachefile) == -1) {
+            perror("bee-dep: rename");
+            cleanup_and_exit(graph, cache, EXIT_FAILURE);
         }
     }
 
-    hnode = hash_search(graph, pkgname);
-    found = hnode && IS_PKG(hnode);
-
     if (update) {
-        if (asprintf(&depfile, "%s/%s/DEPENDENCIES",
-                    BEE_METADIR, pkgname) == -1) {
-            perror("bee-dep: asprintf");
-            free(cachefile);
+        found = !!hash_search(graph, pkgname);
+
+        if (sprintf(path, "%s/%s/DEPENDENCIES",
+                    bee_metadir, pkgname) < 0) {
+            perror("bee-dep: sprintf");
             cleanup_and_exit(graph, cache, EXIT_FAILURE);
         }
 
-        if (stat(depfile, &st) != -1) {
-            if (hnode) {
+        if (stat(path, &st) != -1) {
+            if (found) {
                 fprintf(stderr, "bee-dep: package '%s' is "
                         "already in the cache\n", pkgname);
-                free(cachefile);
-                free(depfile);
                 cleanup_and_exit(graph, cache, EXIT_SUCCESS);
             }
 
-            if (!graph_insert_nodes(graph, depfile)) {
-                free(cachefile);
-                free(depfile);
+            if (graph_insert_nodes(graph, path) == EXIT_FAILURE)
                 cleanup_and_exit(graph, cache, EXIT_FAILURE);
-            }
         } else {
             if (!found) {
                 fprintf(stderr,
                         "bee-dep: unknown package '%s'\n", pkgname);
-                free(cachefile);
-                free(depfile);
                 cleanup_and_exit(graph, cache, EXIT_FAILURE);
             }
 
-            if (!hnode || !IS_PKG(hnode)) {
+            if ((h = hash_search(graph, pkgname)) == NULL || !IS_PKG(h)) {
                 fprintf(stderr, "bee-dep: unknown package '%s'\n", pkgname);
-                free(cachefile);
-                free(depfile);
                 cleanup_and_exit(graph, cache, EXIT_FAILURE);
             }
 
             if (remove_package(graph, pkgname) == EXIT_FAILURE)
-                free(cachefile);
-                free(depfile);
                 cleanup_and_exit(graph, cache, EXIT_FAILURE);
         }
 
-        if (!save_cache(graph, cachefile)) {
-            free(cachefile);
-            free(depfile);
+        if (save_cache(graph, tmp) == EXIT_FAILURE)
+            cleanup_and_exit(graph, cache, EXIT_FAILURE);
+
+        if (rename(tmp, cachefile) == -1) {
+            perror("bee-dep: rename");
             cleanup_and_exit(graph, cache, EXIT_FAILURE);
         }
 
-        free(cachefile);
-        free(depfile);
         cleanup_and_exit(graph, cache, EXIT_SUCCESS);
     }
 
-    if (!hnode || !IS_PKG(hnode)) {
+    if ((h = hash_search(graph, pkgname)) == NULL || !IS_PKG(h)) {
         fprintf(stderr, "bee-dep: unknown package '%s'\n", pkgname);
-        free(cachefile);
         cleanup_and_exit(graph, cache, EXIT_FAILURE);
     }
 
     if (print) {
-        if (print_removable(graph, pkgname) == EXIT_FAILURE) {
-            free(cachefile);
+        if (print_removable(graph, pkgname) == EXIT_FAILURE)
             cleanup_and_exit(graph, cache, EXIT_FAILURE);
-        }
     }
 
     if (remove) {
-        if (remove_package(graph, pkgname) == EXIT_FAILURE) {
-            free(cachefile);
+        if (remove_package(graph, pkgname) == EXIT_FAILURE)
+            cleanup_and_exit(graph, cache, EXIT_FAILURE);
+
+        if (save_cache(graph, tmp) == EXIT_FAILURE)
             cleanup_and_exit(graph, cache, EXIT_FAILURE);
-        }
 
-        if (!save_cache(graph, cachefile)) {
-            free(cachefile);
+        if (rename(tmp, cachefile) == -1) {
+            perror("bee-dep: rename");
             cleanup_and_exit(graph, cache, EXIT_FAILURE);
         }
     }
 
-    free(cachefile);
     cleanup_and_exit(graph, cache, EXIT_SUCCESS);
 
     return EXIT_FAILURE;
diff --git a/src/graph.c b/src/graph.c
index ca8472e..0643d26 100644
--- a/src/graph.c
+++ b/src/graph.c
@@ -24,14 +24,11 @@
 ** along with this program; if not, see <http://www.gnu.org/licenses/>.
 */
 
-#define _GNU_SOURCE
-
 #include <stdio.h>
 #include <stdlib.h>
 #include <limits.h>
 #include <string.h>
 #include <sys/stat.h>
-#include <unistd.h>
 
 #include "graph.h"
 
@@ -100,7 +97,7 @@ int graph_insert_nodes(struct hash *hash, char *filename)
 
     if ((file = fopen(filename, "r")) == NULL) {
         perror("bee-dep: graph_insert_nodes: fopen");
-        return 0;
+        return EXIT_FAILURE;
     }
 
     line_cnt = type_flag = u = 0;
@@ -137,7 +134,7 @@ int graph_insert_nodes(struct hash *hash, char *filename)
                 fprintf(stderr,
                         "bee-dep: %s: error at line %d: missing bracket\n",
                         filename, line_cnt);
-                return 0;
+                return EXIT_FAILURE;
             }
 
             *p = '\0';
@@ -146,7 +143,7 @@ int graph_insert_nodes(struct hash *hash, char *filename)
                 fprintf(stderr,
                         "bee-dep: %s: error at line %d: empty node name\n",
                         filename, line_cnt);
-                return 0;
+                return EXIT_FAILURE;
             }
 
             if (IS_FILE(s)) {
@@ -155,7 +152,7 @@ int graph_insert_nodes(struct hash *hash, char *filename)
                             "bee-dep: %s: error at line %d: "
                             "dont know to which package"
                             "\"%s\" belongs to\n", filename, line_cnt, s);
-                    return 0;
+                    return EXIT_FAILURE;
                 }
 
                 sprintf(nodename, "%s%s", pkgname, s);
@@ -192,7 +189,7 @@ int graph_insert_nodes(struct hash *hash, char *filename)
             fprintf(stderr,
                     "bee-dep: %s: error at line %d: missing value "
                     "for property \"%s\"\n", filename, line_cnt, prop);
-            return 0;
+            return EXIT_FAILURE;
         }
 
         memset(value, '\0', LINE_MAX);
@@ -204,7 +201,7 @@ int graph_insert_nodes(struct hash *hash, char *filename)
                         "bee-dep: %s: error at line %d: "
                         "ambiguous type \"%s\"\n",
                         filename, line_cnt, value);
-                return 0;
+                return EXIT_FAILURE;
             }
 
             node_set_type(n, value);
@@ -248,15 +245,18 @@ int graph_insert_nodes(struct hash *hash, char *filename)
 
     if (fclose(file) == EOF) {
         perror("bee-dep: graph_insert_nodes: fclose");
-        return 0;
+        return EXIT_FAILURE;
     }
 
     if(line_cnt == 0) {
        fprintf(stderr, "bee-dep: error: file '%s' is empty\n", filename);
-       return 0;
+       /* WTF: why can't we return 0 here for errors ??? */
+       return EXIT_FAILURE;
     }
 
-    return 1;
+    /* we dont't want to exit on success ??? or do we? i don't get it! */
+    /* but works for me now.. 8) */
+    return EXIT_SUCCESS;
 }
 
 void search_dependencies(struct hash *hash, struct node *n, struct tree *d)
@@ -495,24 +495,22 @@ int print_removable(struct hash *hash, char *remove)
     return EXIT_SUCCESS;
 }
 
-static int save_cache_to_file(struct hash *hash, char *path)
+int save_cache(struct hash *hash, char *path)
 {
     int i;
     unsigned long index;
     struct tree_node *s, *t;
     FILE *file;
 
-    /* TODO: need to handle all kinds of race conditions here 8) */
-
     if ((file = fopen(path, "w")) == NULL) {
         perror("bee-dep: save_cache: fopen");
-        return 0;
+        return EXIT_FAILURE;
     }
 
     index = 0;
 
     if (hash->cnt == 0)
-        return 1;
+        return EXIT_SUCCESS;
 
     for (i = 0; i < TBLSIZE; i++) {
         if (hash->tbl[i]->root) {
@@ -557,39 +555,10 @@ static int save_cache_to_file(struct hash *hash, char *path)
 
     if (fclose(file) == EOF) {
         perror("bee-dep: save_cache: fclose");
-        return 0;
-    }
-
-    return 1;
-}
-
-int save_cache(struct hash *hash, char *fname)
-{
-    char *tmpname;
-    int ret = 1;
-
-    /* TODO: need to handle all kinds of race conditions here 8) */
-
-    if(asprintf(&tmpname, "%s.tmp", fname) == -1) {
-        perror("bee-dep: save_cache: asprintf");
-        return 0;
-    }
-
-    if(save_cache_to_file(hash, tmpname)) {
-        if(rename(tmpname, fname) == -1) {
-            perror("bee-dep: save_cache: rename");
-            if(unlink(tmpname) == -1) {
-                perror("bee-dep: save_cache: unlink");
-            }
-            ret = 0;
-        }
-    } else {
-        ret = 0;
+        return EXIT_FAILURE;
     }
 
-    free(tmpname);
-
-    return ret;
+    return EXIT_SUCCESS;
 }
 
 int load_cache(struct hash *hash, FILE *file)
@@ -613,7 +582,7 @@ int load_cache(struct hash *hash, FILE *file)
         if (sscanf(line, "%s %s", a, b) == EOF) {
             fprintf(stderr, "beedep: load_cache: "
                             "cache file is broken (line %d)\n", line_cnt);
-            return 0;
+            return EXIT_FAILURE;
         }
 
         hash_insert(hash, node_new(a, b));
@@ -625,7 +594,7 @@ int load_cache(struct hash *hash, FILE *file)
         if (sscanf(line, "%s %s %c", a, b, &c) == EOF) {
             fprintf(stderr, "beedep: load_cache: "
                             "cache file is broken (line %d)\n", line_cnt);
-            return 0;
+            return EXIT_FAILURE;
         }
 
         k = hash_search(hash, a);
@@ -634,7 +603,7 @@ int load_cache(struct hash *hash, FILE *file)
         if (!k || !l) {
             fprintf(stderr, "beedep: load_cache: "
                             "cache file is broken (line %d)\n", line_cnt);
-            return 0;
+            return EXIT_FAILURE;
         }
 
         if (c == 'n') {
@@ -646,11 +615,11 @@ int load_cache(struct hash *hash, FILE *file)
         } else {
             fprintf(stderr, "beedep: load_cache: "
                             "cache file is broken (line %d)\n", line_cnt);
-            return 0;
+            return EXIT_FAILURE;
         }
     }
 
-    return 1;
+    return EXIT_SUCCESS;
 }
 
 unsigned long count_providedby(struct hash *hash, char *count)
diff --git a/src/hash.c b/src/hash.c
index 54101cd..f3b137e 100644
--- a/src/hash.c
+++ b/src/hash.c
@@ -34,8 +34,10 @@ struct hash *hash_new(void)
     struct hash *h;
     unsigned long i;
 
-    if (!(h = calloc(1, sizeof(struct hash))))
-        return NULL;
+    if ((h = calloc(1, sizeof(struct hash))) == NULL) {
+        perror("bee-dep: hash_new: calloc");
+        exit(EXIT_FAILURE);
+    }
 
     for (i = 0; i < TBLSIZE; i++)
         h->tbl[i] = tree_new();

From f3cd5179bafaa29494fb7c31dd91b79ced3390be Mon Sep 17 00:00:00 2001
From: Marius Tolzmann <tolzmann@molgen.mpg.de>
Date: Mon, 19 Dec 2011 22:10:24 +0100
Subject: [PATCH 10/11] Revert "Merge branch 'bee-dep-fixes'"

This reverts commit ca5370abbca944b0479f85ad353dfdba8931e92e, reversing
changes made to 2f2c48c5eba92834a91e52f2c3dda32b49c497a2.
---
 src/bee-dep.c | 52 ++++++++++++++++++++++-----------------------------
 1 file changed, 22 insertions(+), 30 deletions(-)

diff --git a/src/bee-dep.c b/src/bee-dep.c
index 65f53a0..a40a999 100644
--- a/src/bee-dep.c
+++ b/src/bee-dep.c
@@ -34,8 +34,6 @@
 #include <libgen.h>
 #include <unistd.h>
 #include <getopt.h>
-#include <errno.h>
-#include <assert.h>
 
 #include "graph.h"
 
@@ -159,37 +157,24 @@ static FILE *open_and_lock(char *filename, char *mode)
     return f;
 }
 
-/* create all directories in path with mode mode */
 int mkdirp(char *path, mode_t mode)
 {
-    char *dir, *pdir, *end;
-    int ret;
-
-    assert(path);
-
-    dir = end = path;
-
-    while(*dir) {
-        /* skip "/" */
-        dir = end + strspn(end, "/");
-
-        /* skip non-"/" */
-        end = dir + strcspn(dir, "/");
-
-        /* grab everything in path till current end */
-        if(!(pdir = strndup(path, end - path)))
-            return -1;
+    char *dir, *pdir;
+    struct stat st;
 
-        /* create the directory ; ignore err if it already exists */
-        ret = mkdir(pdir, mode);
+    if(path == NULL) {
+        return -1;
+    }
 
-        free(pdir);
+    dir = strdup(path);
+    pdir = dirname(dir);
+    if(stat(pdir, &st) == -1) {
+        mkdirp(pdir, mode);
+    }
 
-        if(ret == -1 && errno != EEXIST)
-            return -1;
-  }
+    free(dir);
 
-  return 0;
+    return mkdir(path, mode);
 }
 
 int main(int argc, char *argv[])
@@ -197,7 +182,7 @@ int main(int argc, char *argv[])
     int c, help, rebuild, update, remove, print, options;
     char found;
     char cachefile[PATH_MAX + 1], path[PATH_MAX + 1], tmp[PATH_MAX + 1];
-    char *bee_metadir, *bee_cachedir, *pkgname;
+    char *bee_metadir, *bee_cachedir, *dir, *pkgname;
     struct hash *graph;
     struct stat st;
     FILE *cache;
@@ -272,11 +257,18 @@ int main(int argc, char *argv[])
         exit(EXIT_FAILURE);
     }
 
-    if (mkdirp(bee_cachedir, 0755) == -1) {
-        perror("bee-dep: mkdirp");
+    dir = strdup(cachefile);
+    dir = dirname(dir);
+
+    if (stat(dir, &st) == -1 && mkdirp(dir, 0755) == -1) {
+        perror("bee-dep: mkdir");
         exit(EXIT_FAILURE);
     }
 
+    free(dir);
+
+    graph = NULL;
+
     found = (stat(cachefile, &st) != -1 && S_ISREG(st.st_mode));
 
     graph = hash_new();

From 42bd4857e68445aa254f17108638edc4517bcda3 Mon Sep 17 00:00:00 2001
From: Marius Tolzmann <tolzmann@molgen.mpg.de>
Date: Mon, 19 Dec 2011 22:11:07 +0100
Subject: [PATCH 11/11] Revert "bee-dep: fixes creating of cache directory"

This reverts commit 00d9a8d2791a156ab6488fcaee0cc7e50f90bccb.
---
 src/bee-dep.c | 22 +---------------------
 1 file changed, 1 insertion(+), 21 deletions(-)

diff --git a/src/bee-dep.c b/src/bee-dep.c
index a40a999..c94d0fd 100644
--- a/src/bee-dep.c
+++ b/src/bee-dep.c
@@ -157,26 +157,6 @@ static FILE *open_and_lock(char *filename, char *mode)
     return f;
 }
 
-int mkdirp(char *path, mode_t mode)
-{
-    char *dir, *pdir;
-    struct stat st;
-
-    if(path == NULL) {
-        return -1;
-    }
-
-    dir = strdup(path);
-    pdir = dirname(dir);
-    if(stat(pdir, &st) == -1) {
-        mkdirp(pdir, mode);
-    }
-
-    free(dir);
-
-    return mkdir(path, mode);
-}
-
 int main(int argc, char *argv[])
 {
     int c, help, rebuild, update, remove, print, options;
@@ -260,7 +240,7 @@ int main(int argc, char *argv[])
     dir = strdup(cachefile);
     dir = dirname(dir);
 
-    if (stat(dir, &st) == -1 && mkdirp(dir, 0755) == -1) {
+    if (stat(dir, &st) == -1 && mkdir(dir, 0755) == -1) {
         perror("bee-dep: mkdir");
         exit(EXIT_FAILURE);
     }