scripts/feeds

   1 #!/usr/bin/env perl
   2 use Getopt::Std;
   3 use FindBin;
   4 use Cwd;
   5 use lib "$FindBin::Bin";
   6 use metadata;
   7 use warnings;
   8 use strict;
   9 use Cwd 'abs_path';
  10
  11 chdir "$FindBin::Bin/..";
  12 $ENV{TOPDIR} //= getcwd();
  13 chdir $ENV{TOPDIR};
  14 $ENV{GIT_CONFIG_PARAMETERS}="'core.autocrlf=false'";
  15 $ENV{GREP_OPTIONS}="";
  16
  17 my $mk=`which gmake 2>/dev/null`;       # select the right 'make' program
  18 chomp($mk);             # trim trailing newline
  19 $mk or $mk = "make";    # default to 'make'
  20
  21 # check version of make
  22 my @mkver = split /\s+/, `$mk -v`, 4;
  23 my $valid_mk = 1;
  24 $mkver[0] =~ /^GNU/ or $valid_mk = 0;
  25 $mkver[1] =~ /^Make/ or $valid_mk = 0;
  26
  27 my ($mkv1, $mkv2) = split /\./, $mkver[2];
  28 ($mkv1 >= 4 || ($mkv1 == 3 && $mkv2 >= 81)) or $valid_mk = 0;
  29
  30 $valid_mk or die "Unsupported version of make found: $mk\n";
  31
  32 my @feeds;
  33 my %build_packages;
  34 my %installed;
  35 my %installed_pkg;
  36 my %installed_targets;
  37 my %feed_cache;
  38
  39 my $feed_package = {};
  40 my $feed_src = {};
  41 my $feed_target = {};
  42 my $feed_vpackage = {};
  43
  44 sub parse_file($$);
  45
  46 sub parse_file($$) {
  47         my ($fname, $name) = @_;
  48         my $line = 0;
  49         my $fh;
  50
  51         open $fh, $fname or return undef;
  52         while (<$fh>) {
  53                 chomp;
  54                 s/#.+$//;
  55                 $line++;
  56                 next unless /\S/;
  57                 my @line = split /\s+/, $_, 3;
  58                 my @src;
  59
  60                 my $valid = 1;
  61                 $line[0] =~ /^src-[\w-]+$/ or $valid = 0;
  62                 $line[1] =~ /^\w+$/ or $valid = 0;
  63                 @src = split /\s+/, ($line[2] or '');
  64                 @src = ('') if @src == 0;
  65                 $valid or die "Syntax error in $fname, line: $line\n";
  66
  67                 $name->{$line[1]} and die "Duplicate feed name '$line[1]' in '$fname' line: $line\n";
  68                 $name->{$line[1]} = 1;
  69
  70                 if ($line[0] eq "src-include") {
  71                         parse_file($line[2], $name) or
  72                             die "Unable to open included file '$line[2]'";
  73                         next;
  74                 }
  75
  76                 push @feeds, [$line[0], $line[1], \@src];
  77         }
  78         close $fh;
  79         return 1;
  80 }
  81
  82 sub parse_config() {
  83         my %name;
  84         parse_file("feeds.conf", \%name) or
  85             parse_file("feeds.conf.default", \%name)  or
  86             die "Unable to open feeds configuration";
  87 }
  88
  89 sub update_location($$)
  90 {
  91         my $name = shift;
  92         my $url  = shift;
  93         my $old_url;
  94
  95         -d "./feeds/$name.tmp" or mkdir "./feeds/$name.tmp" or return 1;
  96
  97         if( open LOC, "< ./feeds/$name.tmp/location" )
  98         {
  99                 chomp($old_url = readline LOC);
 100                 close LOC;
 101         }
 102
 103         if( !$old_url || $old_url ne $url )
 104         {
 105                 if( open LOC, "> ./feeds/$name.tmp/location" )
 106                 {
 107                         print LOC $url, "\n";
 108                         close LOC;
 109                 }
 110                 return $old_url ? 1 : 0;
 111         }
 112
 113         return 0;
 114 }
 115
 116 sub update_index($)
 117 {
 118         my $name = shift;
 119
 120         -d "./feeds/$name.tmp" or mkdir "./feeds/$name.tmp" or return 1;
 121         -d "./feeds/$name.tmp/info" or mkdir "./feeds/$name.tmp/info" or return 1;
 122
 123         system("$mk -s prepare-mk OPENWRT_BUILD= TMP_DIR=\"$ENV{TOPDIR}/feeds/$name.tmp\"");
 124         system("$mk -s -f include/scan.mk IS_TTY=1 SCAN_TARGET=\"packageinfo\" SCAN_DIR=\"feeds/$name\" SCAN_NAME=\"package\" SCAN_DEPTH=5 SCAN_EXTRA=\"\" TMP_DIR=\"$ENV{TOPDIR}/feeds/$name.tmp\"");
 125         system("$mk -s -f include/scan.mk IS_TTY=1 SCAN_TARGET=\"targetinfo\" SCAN_DIR=\"feeds/$name\" SCAN_NAME=\"target\" SCAN_DEPTH=5 SCAN_EXTRA=\"\" SCAN_MAKEOPTS=\"TARGET_BUILD=1\" TMP_DIR=\"$ENV{TOPDIR}/feeds/$name.tmp\"");
 126         system("ln -sf $name.tmp/.packageinfo ./feeds/$name.index");
 127         system("ln -sf $name.tmp/.targetinfo ./feeds/$name.targetindex");
 128
 129         return 0;
 130 }
 131
 132 my %update_method = (
 133         'src-svn' => {
 134                 'init'          => "svn checkout '%s' '%s'",
 135                 'update'        => "svn update",
 136                 'controldir'    => ".svn",
 137                 'revision'      => "svn info | grep 'Revision' | cut -d ' ' -f 2 | tr -d '\n'"},
 138         'src-cpy' => {
 139                 'init'          => "cp -Rf '%s' '%s'",
 140                 'update'        => "",
 141                 'revision'      => "echo -n 'local'"},
 142         'src-link' => {
 143                 'init'          => "ln -s '%s' '%s'",
 144                 'update'        => "",
 145                 'revision'      => "echo -n 'local'"},
 146         'src-dummy' => {
 147                 'init'          => "true '%s' && mkdir '%s'",
 148                 'update'        => "",
 149                 'revision'      => "echo -n 'dummy'"},
 150         'src-git' => {
 151                 'init'          => "git clone --depth 1 '%s' '%s'",
 152                 'init_branch'   => "git clone --depth 1 --branch '%s' '%s' '%s'",
 153                 'init_commit'   => "git clone '%s' '%s' && cd '%s' && git checkout -b '%s' '%s' && cd -",
 154                 'update'        => "git pull --ff",
 155                 'update_force'  => "git pull --ff || (git reset --hard HEAD; git pull --ff; exit 1)",
 156                 'post_update'   => "git submodule update --init --recursive",
 157                 'controldir'    => ".git",
 158                 'revision'      => "git rev-parse --short HEAD | tr -d '\n'"},
 159         'src-git-full' => {
 160                 'init'          => "git clone '%s' '%s'",
 161                 'init_branch'   => "git clone --branch '%s' '%s' '%s'",
 162                 'init_commit'   => "git clone '%s' '%s' && cd '%s' && git checkout -b '%s' '%s' && cd -",
 163                 'update'        => "git pull --ff",
 164                 'update_force'  => "git pull --ff || (git reset --hard HEAD; git pull --ff; exit 1)",
 165                 'post_update'   => "git submodule update --init --recursive",
 166                 'controldir'    => ".git",
 167                 'revision'      => "git rev-parse --short HEAD | tr -d '\n'"},
 168         'src-gitsvn' => {
 169                 'init'  => "git svn clone -r HEAD '%s' '%s'",
 170                 'update'        => "git svn rebase",
 171                 'controldir'    => ".git",
 172                 'revision'      => "git rev-parse --short HEAD | tr -d '\n'"},
 173         'src-bzr' => {
 174                 'init'          => "bzr checkout --lightweight '%s' '%s'",
 175                 'update'        => "bzr update",
 176                 'controldir'    => ".bzr"},
 177         'src-hg' => {
 178                 'init'          => "hg clone '%s' '%s'",
 179                 'update'        => "hg pull --update",
 180                 'controldir'    => ".hg"},
 181         'src-darcs' => {
 182                 'init'    => "darcs get '%s' '%s'",
 183                 'update'  => "darcs pull -a",
 184                 'controldir' => "_darcs"},
 185 );
 186
 187 # src-git: pull broken
 188 # src-cpy: broken if `basename $src` != $name
 189
 190 sub update_feed_via($$$$$) {
 191         my $type = shift;
 192         my $name = shift;
 193         my $src = shift;
 194         my $relocate = shift;
 195         my $force = shift;
 196
 197         my $m = $update_method{$type};
 198         my $localpath = "./feeds/$name";
 199         my $safepath = $localpath;
 200         $safepath =~ s/'/'\\''/;
 201         my ($base_branch, $branch) = split(/;/, $src, 2);
 202         my ($base_commit, $commit) = split(/\^/, $src, 2);
 203
 204         if( $relocate || !$m->{'update'} || !-d "$localpath/$m->{'controldir'}" ) {
 205                 system("rm -rf '$safepath'");
 206                 if ($m->{'init_branch'} and $branch) {
 207                         system(sprintf($m->{'init_branch'}, $branch, $base_branch, $safepath)) == 0 or return 1;
 208                 } elsif ($m->{'init_commit'} and $commit) {
 209                         system(sprintf($m->{'init_commit'}, $base_commit, $safepath, $safepath, $commit, $commit)) == 0 or return 1;
 210                 } else {
 211                         system(sprintf($m->{'init'}, $src, $safepath)) == 0 or return 1;
 212                 }
 213         } elsif ($m->{'init_commit'} and $commit) {
 214                 # in case git hash has been provided don't update the feed
 215         } else {
 216                 my $update_cmd = $m->{'update'};
 217                 if ($force && exists $m->{'update_force'}) {
 218                         $update_cmd = $m->{'update_force'};
 219                 }
 220                 system("cd '$safepath'; $update_cmd") == 0 or return 1;
 221         }
 222         if ($m->{'post_update'}) {
 223                 my $cmd = $m->{'post_update'};
 224                 system("cd '$safepath'; $cmd") == 0 or return 1;
 225         }
 226
 227         return 0;
 228 }
 229
 230 sub get_targets($) {
 231         my $file = shift;
 232         my @target = parse_target_metadata($file);
 233         my %target;
 234         foreach my $target (@target) {
 235                 $target{$target->{id}} = $target;
 236         }
 237         return %target
 238 }
 239
 240 sub get_feed($) {
 241         my $feed = shift;
 242
 243         if (!defined($feed_cache{$feed})) {
 244                 my $file = "./feeds/$feed.index";
 245
 246                 clear_packages();
 247                 -f $file or do {
 248                         print "Ignoring feed '$feed' - index missing\n";
 249                         return;
 250                 };
 251                 parse_package_metadata($file) or return;
 252                 my %target = get_targets("./feeds/$feed.targetindex");
 253
 254                 $feed_cache{$feed} = [ { %package }, { %srcpackage }, { %target }, { %vpackage } ];
 255         }
 256
 257         $feed_package = $feed_cache{$feed}->[0];
 258         $feed_src = $feed_cache{$feed}->[1];
 259         $feed_target = $feed_cache{$feed}->[2];
 260         $feed_vpackage = $feed_cache{$feed}->[3];
 261 }
 262
 263 sub get_installed() {
 264         system("$mk -s prepare-tmpinfo OPENWRT_BUILD=");
 265         clear_packages();
 266         parse_package_metadata("./tmp/.packageinfo");
 267         %installed_pkg = %vpackage;
 268         %installed = %srcpackage;
 269         %installed_targets = get_targets("./tmp/.targetinfo");
 270 }
 271
 272 sub search_feed {
 273         my $feed = shift;
 274         my @substr = @_;
 275         my $display;
 276
 277         return unless @substr > 0;
 278         get_feed($feed);
 279         foreach my $name (sort { lc($a) cmp lc($b) } keys %$feed_package) {
 280                 my $pkg = $feed_package->{$name};
 281                 my $substr;
 282                 my $pkgmatch = 1;
 283
 284                 foreach my $substr (@substr) {
 285                         my $match;
 286                         foreach my $key (qw(name title description src)) {
 287                                 $pkg->{$key} and $substr and $pkg->{$key} =~ m/$substr/i and $match = 1;
 288                         }
 289                         $match or undef $pkgmatch;
 290                 };
 291                 $pkgmatch and do {
 292                         $display or do {
 293                                 print "Search results in feed '$feed':\n";
 294                                 $display = 1;
 295                         };
 296                         printf "\%-25s\t\%s\n", $pkg->{name}, $pkg->{title};
 297                 };
 298         }
 299
 300         foreach my $name (sort { lc($a) cmp lc($b) } keys %$feed_target) {
 301                 my $target = $feed_target->{$name};
 302                 my $targetmatch = 1;
 303
 304                 foreach my $substr (@substr) {
 305                         my $match;
 306                         foreach my $key (qw(id name description)) {
 307                                 $target->{$key} and $substr and $target->{$key} =~ m/$substr/i and $match = 1;
 308                         }
 309                         $match or undef $targetmatch;
 310                 };
 311                 $targetmatch and do {
 312                         $display or do {
 313                                 print "Search results in feed '$feed':\n";
 314                                 $display = 1;
 315                         };
 316                         printf "TARGET: \%-17s\t\%s\n", $target->{id}, $target->{name};
 317                 };
 318         }
 319         return 0;
 320 }
 321
 322 sub search {
 323         my %opts;
 324
 325         getopt('r:', \%opts);
 326         foreach my $feed (@feeds) {
 327                 search_feed($feed->[1], @ARGV) if (!defined($opts{r}) or $opts{r} eq $feed->[1]);
 328         }
 329 }
 330
 331 sub list_feed {
 332         my $feed = shift;
 333
 334         get_feed($feed);
 335         foreach my $name (sort { lc($a) cmp lc($b) } keys %$feed_package) {
 336                 my $pkg = $feed_package->{$name};
 337                 if($pkg->{name}) {
 338                         printf "\%-32s\t\%s\n", $pkg->{name}, $pkg->{title};
 339                 }
 340         }
 341
 342         foreach my $name (sort { lc($a) cmp lc($b) } keys %$feed_target) {
 343                 my $target = $feed_target->{$name};
 344                 if($target->{name}) {
 345                         printf "TARGET: \%-24s\t\%s\n", $target->{id}, $target->{name};
 346                 }
 347         }
 348
 349         return 0;
 350 }
 351
 352 sub list {
 353         my %opts;
 354
 355         getopts('r:d:nshf', \%opts);
 356         if ($opts{h}) {
 357                 usage();
 358                 return 0;
 359         }
 360         if ($opts{n}) {
 361                 foreach my $feed (@feeds) {
 362                         printf "%s\n", $feed->[1];
 363                 }
 364                 return 0;
 365         }
 366         if ($opts{s}) {
 367                 foreach my $feed (@feeds) {
 368                         my $localpath = "./feeds/$feed->[1]";
 369                         my $m = $update_method{$feed->[0]};
 370                         my $revision;
 371                         if (!-d "$localpath" || !$m->{'revision'}) {
 372                                 $revision = "X";
 373                         }
 374                         elsif( $m->{'controldir'} && -d "$localpath/$m->{'controldir'}" ) {
 375                                 $revision = `cd '$localpath'; $m->{'revision'}`;
 376                         }
 377                         else {
 378                                 $revision = "local";
 379                         }
 380                         if ($opts{d}) {
 381                                 printf "%s%s%s%s%s%s%s\n", $feed->[1], $opts{d}, $feed->[0], $opts{d}, $revision, $opts{d}, join(", ", @{$feed->[2]});
 382                         }
 383                         elsif ($opts{f}) {
 384                                 my $uri = join(", ", @{$feed->[2]});
 385                                 if ($revision ne "local" && $revision ne "X") {
 386                                         $uri =~ s/[;^].*//;
 387                                         $uri .= "^" . $revision;
 388                                 }
 389                                 printf "%s %s %s\n", $feed->[0], $feed->[1], $uri;
 390                         }
 391                         else {
 392                                 printf "\%-10s \%-8s \%-8s \%s\n", $feed->[1], $feed->[0], $revision, join(", ", @{$feed->[2]});
 393                         }
 394                 }
 395                 return 0;
 396         }
 397         foreach my $feed (@feeds) {
 398                 list_feed($feed->[1], @ARGV) if (!defined($opts{r}) or $opts{r} eq $feed->[1]);
 399         }
 400         return 0;
 401 }
 402
 403 sub do_install_src($$) {
 404         my $feed = shift;
 405         my $src = shift;
 406
 407         my $path = $src->{makefile};
 408         if ($path) {
 409                 $path =~ s/\/Makefile$//;
 410
 411                 -d "./package/feeds" or mkdir "./package/feeds";
 412                 -d "./package/feeds/$feed->[1]" or mkdir "./package/feeds/$feed->[1]";
 413                 system("ln -sf ../../../$path ./package/feeds/$feed->[1]/");
 414         } else {
 415                 warn "Package is not valid\n";
 416                 return 1;
 417         }
 418
 419         return 0;
 420 }
 421
 422 sub do_install_target($) {
 423         my $target = shift;
 424         my $path = $target->{makefile};
 425
 426         if ($path) {
 427                 $path =~ s/\/Makefile$//;
 428                 my $name = $path;
 429                 $name =~ s/.*\///;
 430                 my $dest = "./target/linux/$name";
 431
 432                 -e $dest and do {
 433                         warn "Path $dest already exists";
 434                         return 1;
 435                 };
 436
 437                 system("ln -sf ../../$path ./target/linux/");
 438         } else {
 439                 warn "Target is not valid\n";
 440                 return 1;
 441         }
 442
 443         return 0;
 444 }
 445
 446 sub lookup_src($$) {
 447         my $feed = shift;
 448         my $src = shift;
 449
 450         foreach my $feed ($feed, @feeds) {
 451                 next unless $feed->[1];
 452                 next unless $feed_cache{$feed->[1]};
 453                 $feed_cache{$feed->[1]}->[1]->{$src} and return $feed;
 454         }
 455         return;
 456 }
 457
 458 sub lookup_package($$) {
 459         my $feed = shift;
 460         my $package = shift;
 461
 462         foreach my $feed ($feed, @feeds) {
 463                 next unless $feed->[1];
 464                 next unless $feed_cache{$feed->[1]};
 465                 $feed_cache{$feed->[1]}->[3]->{$package} and return $feed;
 466         }
 467         return;
 468 }
 469
 470 sub lookup_target($$) {
 471         my $feed = shift;
 472         my $target = shift;
 473
 474         foreach my $feed ($feed, @feeds) {
 475                 next unless $feed->[1];
 476                 next unless $feed_cache{$feed->[1]};
 477                 $feed_cache{$feed->[1]}->[2]->{$target} and return $feed;
 478         }
 479         return;
 480 }
 481
 482 sub is_core_src($) {
 483         my $src = shift;
 484         foreach my $file ("tmp/info/.packageinfo-$src", glob("tmp/info/.packageinfo-*_$src")) {
 485                 next unless index($file, "tmp/info/.packageinfo-feeds_");
 486                 return 1 if -s $file;
 487         }
 488         return 0;
 489 }
 490
 491 sub install_target {
 492         my $feed = shift;
 493         my $name = shift;
 494
 495         $installed_targets{$name} and return 0;
 496
 497         $feed = $feed_cache{$feed->[1]}->[2];
 498         $feed or return 0;
 499
 500         my $target = $feed->{$name};
 501         $target or return 0;
 502
 503         warn "Installing target '$name'\n";
 504         return do_install_target($target);
 505 }
 506
 507 sub install_src {
 508         my $feed = shift;
 509         my $name = shift;
 510         my $force = shift;
 511         my $ret = 0;
 512
 513         $feed = lookup_src($feed, $name);
 514         unless ($feed) {
 515                 $installed{$name} and return 0;
 516                 $feed_src->{$name} or warn "WARNING: No feed for source package '$name' found\n";
 517                 return 0;
 518         }
 519
 520         # switch to the metadata for the selected feed
 521         get_feed($feed->[1]);
 522         my $src = $feed_src->{$name} or return 1;
 523
 524         # If it's a core package and we don't want to override, just return
 525         my $override = 0;
 526         if (is_core_src($name)) {
 527                 return 0 unless $force;
 528                 $override = 1;
 529         }
 530
 531         if ($installed{$name}) {
 532                 # newly installed packages set the source package to 1
 533                 return 0 if ($installed{$name} == 1);
 534                 return 0 unless ($override);
 535         }
 536
 537         $installed{$name} = 1;
 538         foreach my $pkg (@{$src->{packages}}) {
 539                 foreach my $vpkg (@{$pkg->{provides}}) {
 540                         $installed_pkg{$vpkg} = 1;
 541                 }
 542         }
 543
 544         if ($override) {
 545                 warn "Overriding core package '$name' with version from $feed->[1]\n";
 546         } else {
 547                 warn "Installing package '$name' from $feed->[1]\n";
 548         }
 549
 550         do_install_src($feed, $src) == 0 or do {
 551                 warn "failed.\n";
 552                 return 1;
 553         };
 554
 555         # install all dependencies referenced from the source package
 556         foreach my $dep (
 557                 @{$src->{builddepends}},
 558                 @{$src->{'builddepends/host'}},
 559         ) {
 560                 next if $dep =~ /@/;
 561                 $dep =~ s/^.+://;
 562                 $dep =~ s/\/.+$//;
 563                 next unless $dep;
 564                 install_src($feed, $dep, 0) == 0 or $ret = 1;
 565         }
 566
 567         foreach my $pkg (@{$src->{packages}}) {
 568                 foreach my $dep (@{$pkg->{depends}}) {
 569                         next if $dep =~ /@/;
 570                         $dep =~ s/^\+//;
 571                         $dep =~ s/^.+://;
 572                         next unless $dep;
 573                         install_package($feed, $dep, 0) == 0 or $ret = 1;
 574                 }
 575         }
 576
 577         return $ret;
 578 }
 579
 580 sub install_package {
 581         my $feed = shift;
 582         my $name = shift;
 583         my $force = shift;
 584
 585         $feed = lookup_package($feed, $name);
 586         unless ($feed) {
 587                 $installed_pkg{$name} and return 0;
 588                 $feed_vpackage->{$name} or warn "WARNING: No feed for package '$name' found\n";
 589                 return 0;
 590         }
 591
 592         # switch to the metadata for the selected feed
 593         get_feed($feed->[1]);
 594         my $pkg = $feed_vpackage->{$name} or return 1;
 595         return install_src($feed, $pkg->[0]{src}{name}, $force);
 596 }
 597
 598 sub install_target_or_package {
 599         my $feed = shift;
 600         my $name = shift;
 601         my $force = shift;
 602
 603         my $this_feed_target = lookup_target($feed, $name);
 604         $this_feed_target and do {
 605                 return install_target($this_feed_target, $name);
 606         };
 607
 608         my $this_feed_src = lookup_src($feed, $name);
 609         $this_feed_src and do {
 610                 return install_src($this_feed_src, $name, $force);
 611         };
 612
 613         return install_package($feed, $name, $force);
 614 }
 615
 616 sub refresh_config {
 617         my $default = shift;
 618
 619         # Don't create .config if it doesn't already exist so that making a
 620         # config only occurs when the user intends it do (however we do
 621         # want to refresh an existing config).
 622         return if not (-e '.config');
 623
 624         # workaround for timestamp check
 625         system("rm -f tmp/.packageinfo");
 626
 627         # refresh the config
 628         if ($default) {
 629                 system("$mk oldconfig CONFDEFAULT=\"$default\" Config.in >/dev/null 2>/dev/null");
 630         } else {
 631                 system("$mk defconfig Config.in >/dev/null 2>/dev/null");
 632         }
 633 }
 634
 635 sub install {
 636         my $name;
 637         my %opts;
 638         my $feed;
 639         my $ret = 0;
 640
 641         getopts('ap:d:fh', \%opts);
 642
 643         if ($opts{h}) {
 644                 usage();
 645                 return 0;
 646         }
 647
 648         get_installed();
 649
 650         foreach my $f (@feeds) {
 651                 # fetch all feeds
 652                 get_feed($f->[1]);
 653
 654                 # look up the preferred feed
 655                 $opts{p} and $f->[1] eq $opts{p} and $feed = $f;
 656         }
 657
 658         if($opts{a}) {
 659                 foreach my $f (@feeds) {
 660                         if (!defined($opts{p}) or $opts{p} eq $f->[1]) {
 661                                 printf "Installing all packages from feed %s.\n", $f->[1];
 662                                 get_feed($f->[1]);
 663                                 foreach my $name (sort { lc($a) cmp lc($b) } keys %$feed_src) {
 664                                         install_src($feed, $name, exists($opts{f})) == 0 or $ret = 1;
 665                                         get_feed($f->[1]);
 666                                 }
 667                         }
 668                 }
 669         } else {
 670                 while ($name = shift @ARGV) {
 671                         install_target_or_package($feed, $name, exists($opts{f})) == 0 or $ret = 1;
 672                 }
 673         }
 674
 675         # workaround for timestamp check
 676
 677         # set the defaults
 678         if ($opts{d} and $opts{d} =~ /^[ymn]$/) {
 679                 refresh_config($opts{d});
 680         }
 681
 682         return $ret;
 683 }
 684
 685 sub uninstall_target($) {
 686         my $dir = shift;
 687         my $name = $dir;
 688         $name =~ s/.*\///g;
 689
 690         my $dest = readlink $dir;
 691         return unless $dest =~ /..\/..\/feeds/;
 692         warn "Uninstalling target '$name'\n";
 693         unlink "$dir";
 694 }
 695
 696 sub uninstall {
 697         my %opts;
 698         my $name;
 699         my $uninstall;
 700
 701         getopts('ah', \%opts);
 702
 703         if ($opts{h}) {
 704                 usage();
 705                 return 0;
 706         }
 707
 708         if ($opts{a}) {
 709                 system("rm -rvf ./package/feeds");
 710                 foreach my $dir (glob "target/linux/*") {
 711                         next unless -l $dir;
 712                         uninstall_target($dir);
 713                 }
 714                 $uninstall = 1;
 715         } else {
 716                 if($#ARGV == -1) {
 717                         warn "WARNING: no package to uninstall\n";
 718                         return 0;
 719                 }
 720                 get_installed();
 721                 while ($name = shift @ARGV) {
 722                         my $target = "target/linux/$name";
 723                         -l "$target" and do {
 724                                 uninstall_target($target);
 725                                 $uninstall = 1;
 726                                 next;
 727                         };
 728
 729                         my $pkg = $installed{$name};
 730                         $pkg or do {
 731                                 warn "WARNING: $name not installed\n";
 732                                 next;
 733                         };
 734                         $pkg->{src} and $name = $pkg->{src}{name};
 735                         warn "Uninstalling package '$name'\n";
 736                         system("rm -f ./package/feeds/*/$name");
 737                         $uninstall = 1;
 738                 }
 739         }
 740         $uninstall and refresh_config();
 741         return 0;
 742 }
 743
 744 sub update_feed($$$$$)
 745 {
 746         my $type=shift;
 747         my $name=shift;
 748         my $src=shift;
 749         my $perform_update=shift;
 750         my $force_update=shift;
 751         my $force_relocate=update_location( $name, "@$src" );
 752         my $rv=0;
 753
 754         if( $force_relocate ) {
 755                 warn "Source of feed $name has changed, replacing copy\n";
 756         }
 757         $update_method{$type} or do {
 758                 warn "Unknown type '$type' in feed $name\n";
 759                 return 1;
 760         };
 761         $perform_update and do {
 762                 my $failed = 1;
 763                 foreach my $feedsrc (@$src) {
 764                         warn "Updating feed '$name' from '$feedsrc' ...\n";
 765                         if (update_feed_via($type, $name, $feedsrc, $force_relocate, $force_update) != 0) {
 766                                 if ($force_update) {
 767                                         $rv=1;
 768                                         $failed=0;
 769                                         warn "failed, ignore.\n";
 770                                         next;
 771                                 }
 772                                 last;
 773                         }
 774                         $failed = 0;
 775                 }
 776                 $failed and do {
 777                         warn "failed.\n";
 778                         return 1;
 779                 };
 780         };
 781         warn "Create index file './feeds/$name.index' \n";
 782         update_index($name) == 0 or do {
 783                 warn "failed.\n";
 784                 return 1;
 785         };
 786         return $rv;
 787 }
 788
 789 sub update {
 790         my %opts;
 791         my $feed_name;
 792         my $perform_update=1;
 793         my $failed=0;
 794
 795         $ENV{SCAN_COOKIE} = $$;
 796         $ENV{OPENWRT_VERBOSE} = 's';
 797
 798         getopts('ahif', \%opts);
 799
 800         if ($opts{h}) {
 801                 usage();
 802                 return 0;
 803         }
 804
 805         if ($opts{i}) {
 806                 # don't update from (remote) repository
 807                 # only re-create index information
 808                 $perform_update=0;
 809         }
 810
 811         -d "feeds" or do {
 812                         mkdir "feeds" or die "Unable to create the feeds directory";
 813                 };
 814
 815         if ( ($#ARGV == -1) or $opts{a}) {
 816                 foreach my $feed (@feeds) {
 817                         my ($type, $name, $src) = @$feed;
 818                         update_feed($type, $name, $src, $perform_update, $opts{f}) == 0 or $failed=1;
 819                 }
 820         } else {
 821                 while ($feed_name = shift @ARGV) {
 822                         foreach my $feed (@feeds) {
 823                                 my ($type, $name, $src) = @$feed;
 824                                 if($feed_name ne $name) {
 825                                         next;
 826                                 }
 827                                 update_feed($type, $name, $src, $perform_update, $opts{f}) == 0 or $failed=1;
 828                         }
 829                 }
 830         }
 831
 832         refresh_config();
 833
 834         return $failed;
 835 }
 836
 837 sub feed_config() {
 838         foreach my $feed (@feeds) {
 839                 my $installed = (-f "feeds/$feed->[1].index");
 840
 841                 printf "\tconfig FEED_%s\n", $feed->[1];
 842                 printf "\t\ttristate \"Enable feed %s\"\n", $feed->[1];
 843                 printf "\t\tdepends on PER_FEED_REPO\n";
 844                 printf "\t\tdefault y\n" if $installed;
 845                 printf "\t\thelp\n";
 846                 printf "\t\t Enable the \\\"%s\\\" feed in opkg distfeeds.conf.\n", $feed->[1];
 847                 printf "\t\t Say M to add the feed commented out.\n";
 848                 printf "\n";
 849         }
 850
 851         return 0;
 852 }
 853
 854 sub usage() {
 855         print <<EOF;
 856 Usage: $0 <command> [options]
 857
 858 Commands:
 859         list [options]: List feeds, their content and revisions (if installed)
 860         Options:
 861             -n :            List of feed names.
 862             -s :            List of feed names and their URL.
 863             -r <feedname>:  List packages of specified feed.
 864             -d <delimiter>: Use specified delimiter to distinguish rows (default: spaces)
 865             -f :            List feeds in feeds.conf compatible format (when using -s).
 866
 867         install [options] <package>: Install a package
 868         Options:
 869             -a :           Install all packages from all feeds or from the specified feed using the -p option.
 870             -p <feedname>: Prefer this feed when installing packages.
 871             -d <y|m|n>:    Set default for newly installed packages.
 872             -f :           Install will be forced even if the package exists in core OpenWrt (override)
 873
 874         search [options] <substring>: Search for a package
 875         Options:
 876             -r <feedname>: Only search in this feed
 877
 878         uninstall -a|<package>: Uninstall a package
 879         Options:
 880             -a :           Uninstalls all packages.
 881
 882         update -a|<feedname(s)>: Update packages and lists of feeds in feeds.conf .
 883         Options:
 884             -a :           Update all feeds listed within feeds.conf. Otherwise the specified feeds will be updated.
 885             -i :           Recreate the index only. No feed update from repository is performed.
 886             -f :           Force updating feeds even if there are changed, uncommitted files.
 887
 888         clean:             Remove downloaded/generated files.
 889
 890 EOF
 891         exit(1);
 892 }
 893
 894 my %commands = (
 895         'list' => \&list,
 896         'update' => \&update,
 897         'install' => \&install,
 898         'search' => \&search,
 899         'uninstall' => \&uninstall,
 900         'feed_config' => \&feed_config,
 901         'clean' => sub {
 902                 system("rm -rf ./feeds ./package/feeds");
 903         }
 904 );
 905
 906 my $arg = shift @ARGV;
 907 $arg or usage();
 908 parse_config;
 909 foreach my $cmd (keys %commands) {
 910         $arg eq $cmd and do {
 911                 exit(&{$commands{$cmd}}());
 912         };
 913 }
 914 usage();