src/util/pactree.c

   1 /*
   2  *  pactree.c - a simple dependency tree viewer
   3  *
   4  *  Copyright (c) 2010-2011 Pacman Development Team <pacman-dev@archlinux.org>
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "config.h"
  21
  22 #include <getopt.h>
  23 #include <stdio.h>
  24 #include <string.h>
  25
  26 #include <alpm.h>
  27 #include <alpm_list.h>
  28
  29 /* output */
  30 char *provides     = " provides";
  31 char *unresolvable = " [unresolvable]";
  32 char *branch_tip1  = "|--";
  33 char *branch_tip2  = "+--";
  34 int   indent_size  = 3;
  35
  36 /* color */
  37 char *branch1_color = "\033[0;33m"; /* yellow */
  38 char *branch2_color = "\033[0;37m"; /* white */
  39 char *leaf1_color   = "\033[1;32m"; /* bold green */
  40 char *leaf2_color   = "\033[0;32m"; /* green */
  41 char *color_off     = "\033[0m";
  42
  43 /* globals */
  44 pmdb_t *db_local;
  45 alpm_list_t *walked = NULL;
  46 alpm_list_t *provisions = NULL;
  47
  48 /* options */
  49 int color = 0;
  50 int graphviz = 0;
  51 int linear = 0;
  52 int max_depth = -1;
  53 int reverse = 0;
  54 int unique = 0;
  55 char *dbpath = NULL;
  56
  57 static int alpm_local_init(void)
  58 {
  59         int ret;
  60
  61         ret = alpm_initialize();
  62         if(ret != 0) {
  63                 return(ret);
  64         }
  65
  66         ret = alpm_option_set_root(ROOTDIR);
  67         if(ret != 0) {
  68                 return(ret);
  69         }
  70
  71         if(dbpath) {
  72                 ret = alpm_option_set_dbpath(dbpath);
  73         } else {
  74                 ret = alpm_option_set_dbpath(DBPATH);
  75         }
  76         if(ret != 0) {
  77                 return(ret);
  78         }
  79
  80         db_local = alpm_option_get_localdb();
  81         if(!db_local) {
  82                 return(1);
  83         }
  84
  85         return(0);
  86 }
  87
  88 static int parse_options(int argc, char *argv[])
  89 {
  90         int opt, option_index = 0;
  91         char *endptr = NULL;
  92
  93         static struct option opts[] = {
  94                 {"dbpath",  required_argument,    0, 'b'},
  95                 {"color",   no_argument,          0, 'c'},
  96                 {"depth",   required_argument,    0, 'd'},
  97                 {"graph",   no_argument,          0, 'g'},
  98                 {"help",    no_argument,          0, 'h'},
  99                 {"linear",  no_argument,          0, 'l'},
 100                 {"reverse", no_argument,          0, 'r'},
 101                 {"unique",  no_argument,          0, 'u'},
 102                 {0, 0, 0, 0}
 103         };
 104
 105         while((opt = getopt_long(argc, argv, "b:cd:ghlru", opts, &option_index))) {
 106                 if(opt < 0) {
 107                         break;
 108                 }
 109
 110                 switch(opt) {
 111                         case 'b':
 112                                 dbpath = strdup(optarg);
 113                                 break;
 114                         case 'c':
 115                                 color = 1;
 116                                 break;
 117                         case 'd':
 118                                 /* validate depth */
 119                                 max_depth = (int)strtol(optarg, &endptr, 10);
 120                                 if(*endptr != '\0') {
 121                                         fprintf(stderr, "error: invalid depth -- %s\n", optarg);
 122                                         return 1;
 123                                 }
 124                                 break;
 125                         case 'g':
 126                                 graphviz = 1;
 127                                 break;
 128                         case 'l':
 129                                 linear = 1;
 130                                 break;
 131                         case 'r':
 132                                 reverse = 1;
 133                                 break;
 134                         case 'u':
 135                                 unique = linear = 1;
 136                                 break;
 137                         case 'h':
 138                         case '?':
 139                         default:
 140                                 return(1);
 141                 }
 142         }
 143
 144         if(!argv[optind]) {
 145                 return(1);
 146         }
 147
 148         if(!color) {
 149                 branch1_color = "";
 150                 branch2_color = "";
 151                 leaf1_color   = "";
 152                 leaf2_color   = "";
 153                 color_off     = "";
 154         }
 155         if(linear) {
 156                 provides     = "";
 157                 branch_tip1  = "";
 158                 branch_tip2  = "";
 159                 indent_size  = 0;
 160         }
 161
 162         return(0);
 163 }
 164
 165 static void usage(void)
 166 {
 167         fprintf(stderr, "pactree v" PACKAGE_VERSION "\n"
 168                         "Usage: pactree [options] PACKAGE\n\n"
 169                         "  -b, --dbpath <path>  set an alternate database location\n"
 170                         "  -c, --color          colorize output\n"
 171                         "  -d, --depth <#>      limit the depth of recursion\n"
 172                         "  -g, --graph          generate output for graphviz's dot\n"
 173                         "  -l, --linear         enable linear output\n"
 174                         "  -r, --reverse        show reverse dependencies\n"
 175                         "  -u, --unique         show dependencies with no duplicates (implies -l)\n\n"
 176                         "  -h, --help           display this help message\n");
 177 }
 178
 179 static void cleanup(void)
 180 {
 181         if(dbpath) {
 182                 free(dbpath);
 183         }
 184
 185         alpm_list_free(walked);
 186         alpm_list_free(provisions);
 187         alpm_release();
 188 }
 189
 190 /* pkg provides provision */
 191 static void print_text(const char *pkg, const char *provision, int depth)
 192 {
 193         int indent_sz = (depth + 1) * indent_size;
 194
 195         if(!pkg && !provision) {
 196                 /* not much we can do */
 197                 return;
 198         }
 199
 200         if(!pkg && provision) {
 201                 /* we failed to resolve provision */
 202                 printf("%s%*s%s%s%s%s%s\n", branch1_color, indent_sz, branch_tip1,
 203                                 leaf1_color, provision, branch1_color, unresolvable, color_off);
 204         } else if(provision && strcmp(pkg, provision) != 0) {
 205                 /* pkg provides provision */
 206                 printf("%s%*s%s%s%s%s %s%s%s\n", branch2_color, indent_sz, branch_tip2,
 207                                 leaf1_color, pkg, leaf2_color, provides, leaf1_color, provision,
 208                                 color_off);
 209         } else {
 210                 /* pkg is a normal package */
 211                 printf("%s%*s%s%s%s\n", branch1_color, indent_sz, branch_tip1, leaf1_color,
 212                                 pkg, color_off);
 213         }
 214 }
 215
 216 static void print_graph(const char *parentname, const char *pkgname, const char *depname)
 217 {
 218         if(depname) {
 219                 printf("\"%s\" -> \"%s\" [color=chocolate4];\n", parentname, depname);
 220                 if(pkgname && strcmp(depname, pkgname) != 0 && !alpm_list_find_str(provisions, depname)) {
 221                         printf("\"%s\" -> \"%s\" [arrowhead=none, color=grey];\n", depname, pkgname);
 222                         provisions = alpm_list_add(provisions, (char *)depname);
 223                 }
 224         } else if(pkgname) {
 225                 printf("\"%s\" -> \"%s\" [color=chocolate4];\n", parentname, pkgname);
 226         }
 227 }
 228
 229 /* parent depends on dep which is satisfied by pkg */
 230 static void print(const char *parentname, const char *pkgname, const char *depname, int depth)
 231 {
 232         if(graphviz) {
 233                 print_graph(parentname, pkgname, depname);
 234         } else {
 235                 print_text(pkgname, depname, depth);
 236         }
 237 }
 238
 239 static void print_start(const char *pkgname, const char *provname)
 240 {
 241         if(graphviz) {
 242                 printf("digraph G { START [color=red, style=filled];\n"
 243                                 "node [style=filled, color=green];\n"
 244                                 " \"START\" -> \"%s\";\n", pkgname);
 245         } else {
 246                 print_text(pkgname, provname, 0);
 247         }
 248 }
 249
 250 static void print_end(void)
 251 {
 252         if(graphviz) {
 253                 /* close graph output */
 254                 printf("}\n");
 255         }
 256 }
 257
 258
 259 /**
 260  * walk dependencies in reverse, showing packages which require the target
 261  */
 262 static void walk_reverse_deps(pmpkg_t *pkg, int depth)
 263 {
 264         alpm_list_t *required_by, *i;
 265
 266         if((max_depth >= 0) && (depth == max_depth + 1)) {
 267                 return;
 268         }
 269
 270         walked = alpm_list_add(walked, (void*)alpm_pkg_get_name(pkg));
 271         required_by = alpm_pkg_compute_requiredby(pkg);
 272
 273         for(i = required_by; i; i = alpm_list_next(i)) {
 274                 const char *pkgname = alpm_list_getdata(i);
 275
 276                 if(alpm_list_find_str(walked, pkgname)) {
 277                         /* if we've already seen this package, don't print in "unique" output
 278                          * and don't recurse */
 279                         if(!unique) {
 280                                 print(alpm_pkg_get_name(pkg), pkgname, NULL, depth);
 281                         }
 282                 } else {
 283                         print(alpm_pkg_get_name(pkg), pkgname, NULL, depth);
 284                         walk_reverse_deps(alpm_db_get_pkg(db_local, pkgname), depth + 1);
 285                 }
 286         }
 287
 288         FREELIST(required_by);
 289 }
 290
 291 /**
 292  * walk dependencies, showing dependencies of the target
 293  */
 294 static void walk_deps(pmpkg_t *pkg, int depth)
 295 {
 296         alpm_list_t *i;
 297
 298         if((max_depth >= 0) && (depth == max_depth + 1)) {
 299                 return;
 300         }
 301
 302         walked = alpm_list_add(walked, (void*)alpm_pkg_get_name(pkg));
 303
 304         for(i = alpm_pkg_get_depends(pkg); i; i = alpm_list_next(i)) {
 305                 pmdepend_t *depend = alpm_list_getdata(i);
 306                 pmpkg_t *provider = alpm_find_satisfier(alpm_db_get_pkgcache_list(db_local),
 307                                 alpm_dep_get_name(depend));
 308
 309                 if(provider) {
 310                         const char *provname = alpm_pkg_get_name(provider);
 311
 312                         if(alpm_list_find_str(walked, provname)) {
 313                                 /* if we've already seen this package, don't print in "unique" output
 314                                  * and don't recurse */
 315                                 if(!unique) {
 316                                         print(alpm_pkg_get_name(pkg), provname, alpm_dep_get_name(depend), depth);
 317                                 }
 318                         } else {
 319                                 print(alpm_pkg_get_name(pkg), provname, alpm_dep_get_name(depend), depth);
 320                                 walk_deps(provider, depth + 1);
 321                         }
 322                 } else {
 323                         /* unresolvable package */
 324                         print(alpm_pkg_get_name(pkg), NULL, alpm_dep_get_name(depend), depth);
 325                 }
 326         }
 327 }
 328
 329 int main(int argc, char *argv[])
 330 {
 331         int ret;
 332         const char *target_name;
 333         pmpkg_t *pkg;
 334
 335         ret = parse_options(argc, argv);
 336         if(ret != 0) {
 337                 usage();
 338                 goto finish;
 339         }
 340
 341         ret = alpm_local_init();
 342         if(ret != 0) {
 343                 fprintf(stderr, "error: cannot initialize alpm: %s\n", alpm_strerrorlast());
 344                 goto finish;
 345         }
 346
 347         /* we only care about the first non option arg for walking */
 348         target_name = argv[optind];
 349
 350         pkg = alpm_find_satisfier(alpm_db_get_pkgcache_list(db_local), target_name);
 351         if(!pkg) {
 352                 fprintf(stderr, "error: package '%s' not found\n", target_name);
 353                 ret = 1;
 354                 goto finish;
 355         }
 356
 357         print_start(alpm_pkg_get_name(pkg), target_name);
 358
 359         if(reverse) {
 360                 walk_reverse_deps(pkg, 1);
 361         } else {
 362                 walk_deps(pkg, 1);
 363         }
 364
 365         print_end();
 366
 367 finish:
 368         cleanup();
 369         return(ret);
 370 }
 371
 372 /* vim: set ts=2 sw=2 noet: */