← Back to branch summary

~vcs-imports/ipfire/ipfire-2.x

« back to all changes in this revision

Viewing changes to src/pakfire/lib/functions.pl

  • Committer: Peter Müller
  • Date: 2022-04-23 14:27:56 UTC
  • mto: This revision was merged to the branch mainline in revision 9750.
  • Revision ID: git-v1:7a981d94cb2c3e48ecaf07c506c8353a2c839d79
SSH: do not send spoofable TCP keep alive messages

By default, both SSH server and client rely on TCP-based keep alive
messages to detect broken sessions, which can be spoofed rather easily
in order to keep a broken session opened (and vice versa).

Since we rely on SSH-based keep alive messages, which are not vulnerable
to this kind of tampering, there is no need to double-check connections
via TCP keep alive as well.

This patch thereof disables using TCP keep alive for both SSH client and
server scenario. For usability reasons, a timeout of 5 minutes (10
seconds * 30 keep alive messages = 300 seconds) will be used for both
client and server configuration, as 60 seconds were found to be too
short for unstable connectivity scenarios.

Signed-off-by: Peter Müller <peter.mueller@ipfire.org>

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/pakfire/lib/functions.pl
2
2
###############################################################################
3
3
#                                                                             #
4
4
# IPFire.org - A linux based firewall                                         #
5
 
# Copyright (C) 2007-2022   IPFire Team   <info@ipfire.org>                   #
 
5
# Copyright (C) 2007-2021   IPFire Team   <info@ipfire.org>                   #
6
6
#                                                                             #
7
7
# This program is free software: you can redistribute it and/or modify        #
8
8
# it under the terms of the GNU General Public License as published by        #
44
44
);
45
45
 
46
46
# A small color-hash :D
47
 
our %color;
 
47
my %color;
48
48
        $color{'normal'}      = "\033[0m";
49
49
        $color{'black'}       = "\033[0;30m";
50
50
        $color{'darkgrey'}    = "\033[1;30m";
114
114
  &Pakfire::message("Usage: pakfire <install|remove> [options] <pak(s)>");
115
115
  &Pakfire::message("               <update> - Contacts the servers for new lists of paks.");
116
116
  &Pakfire::message("               <upgrade> - Installs the latest version of all paks.");
117
 
  &Pakfire::message("               <list> [installed/notinstalled/upgrade] - Outputs a list with all, installed, available or upgradeable paks.");
118
 
  &Pakfire::message("               <info> <pak> [<pak> ...] - Output pak metadata.");
 
117
  &Pakfire::message("               <list> - Outputs a short list with all available paks.");
119
118
  &Pakfire::message("               <status> - Outputs a summary about available core upgrades, updates and a required reboot");
120
119
  &Pakfire::message("");
121
120
  &Pakfire::message("       Global options:");
205
204
                my $log = $response->status_line;
206
205
                logger("DOWNLOAD INFO: HTTP-Status-Code: $code - $log");
207
206
 
 
207
                if ( $code eq "500" ) {
 
208
                        message("Giving up: There was no chance to get the file \"$getfile\" from any available server.\nThere was an error on the way. Please fix it.");
 
209
                        return 1;
 
210
                }
 
211
 
208
212
                if ($response->is_success) {
209
213
                        if (open(FILE, ">$Conf::tmpdir/$bfile")) {
210
214
                                print FILE $final_data;
222
226
                                }
223
227
                                logger("DOWNLOAD FINISHED: $file");
224
228
                                $allok = 1;
225
 
                                return 1;
 
229
                                return 0;
226
230
                        } else {
227
231
                                logger("DOWNLOAD ERROR: Could not open $Conf::tmpdir/$bfile for writing.");
228
232
                        }
231
235
                }
232
236
        }
233
237
        message("DOWNLOAD ERROR: There was no chance to get the file \"$getfile\" from any available server.\nMay be you should run \"pakfire update\" to get some new servers.");
234
 
        return 0;
 
238
        return 1;
235
239
}
236
240
 
237
241
sub getmirrors {
252
256
        }
253
257
 
254
258
        if ("$force" eq "force") {
255
 
                if (fetchfile("$Conf::version/lists/server-list.db", "$Conf::mainserver")) {
256
 
                        move("$Conf::cachedir/server-list.db", "$Conf::dbdir/lists/server-list.db");
257
 
                } elsif (! -e "$Conf::dbdir/lists/server-list.db" ) {
258
 
                        # if we end up with no server-list at all, return failure
259
 
                        return 0;
260
 
                }
 
259
                fetchfile("$Conf::version/lists/server-list.db", "$Conf::mainserver");
 
260
                move("$Conf::cachedir/server-list.db", "$Conf::dbdir/lists/server-list.db");
261
261
        }
262
 
        return 1;
263
262
}
264
263
 
265
264
sub getcoredb {
280
279
        }
281
280
 
282
281
        if ("$force" eq "force") {
283
 
                if (fetchfile("lists/core-list.db", "")) {
284
 
                        move("$Conf::cachedir/core-list.db", "$Conf::dbdir/lists/core-list.db");
285
 
                }
 
282
                fetchfile("lists/core-list.db", "");
 
283
                move("$Conf::cachedir/core-list.db", "$Conf::dbdir/lists/core-list.db");
286
284
        }
287
285
}
288
286
 
320
318
 
321
319
        ### Check if there is a current server list and read it.
322
320
        #   If there is no list try to get one.
323
 
        unless (open(FILE, "<$Conf::dbdir/lists/server-list.db")) {
324
 
                unless (getmirrors("noforce")) {
325
 
                        message("MIRROR ERROR: Could not find or download a server list");
326
 
                        exit 1;
327
 
                }
328
 
        }
329
 
 
 
321
        my $count = 0;
 
322
        while (!(open(FILE, "<$Conf::dbdir/lists/server-list.db")) && ($count lt 5)) {
 
323
                $count++;
 
324
                getmirrors("noforce");
 
325
        }
 
326
        if ($count == 5) {
 
327
                message("MIRROR ERROR: Could not find or download a server list");
 
328
                exit 1;
 
329
        }
330
330
        my @lines = <FILE>;
331
331
        close(FILE);
332
332
 
390
390
        }
391
391
 
392
392
        if ("$force" eq "force") {
393
 
                if (fetchfile("lists/packages_list.db", "")) {
394
 
                        move("$Conf::cachedir/packages_list.db", "$Conf::dbdir/lists/packages_list.db");
395
 
                } elsif ( -e "$Conf::dbdir/lists/packages_list.db" ) {
396
 
                        # If we end up with no db file after download error there
397
 
                        # is nothing more we can do here.
398
 
                        return 0;
399
 
                }
 
393
                fetchfile("lists/packages_list.db", "");
 
394
                move("$Conf::cachedir/packages_list.db", "$Conf::dbdir/lists/packages_list.db");
400
395
        }
401
396
 
402
397
        # Update the meta database if new packages was in the package list
406
401
        my %metadata;
407
402
        my @templine;
408
403
 
409
 
    my %paklist = &Pakfire::dblist("all");
 
404
        open(FILE, "<$Conf::dbdir/lists/packages_list.db");
 
405
        my @db = <FILE>;
 
406
        close(FILE);
410
407
 
411
408
        opendir(DIR,"$Conf::dbdir/meta");
412
409
        my @files = readdir(DIR);
418
415
                next if ( $file =~ /^old/ );
419
416
                %metadata = parsemetafile("$Conf::dbdir/meta/$file");
420
417
 
421
 
                if ((defined $paklist{"$metadata{'Name'}"}) && (
422
 
                        ("$paklist{\"$metadata{'Name'}\"}{'Release'}" ne "$metadata{'Release'}") ||
423
 
                        (defined $paklist{"$metadata{'Name'}"}{'AvailableRelease'}))
424
 
                   ) {
425
 
                        move("$Conf::dbdir/meta/meta-$metadata{'Name'}","$Conf::dbdir/meta/old_meta-$metadata{'Name'}");
426
 
                        getmetafile($metadata{'Name'});
 
418
                foreach $prog (@db) {
 
419
                        @templine = split(/\;/,$prog);
 
420
                        if (("$metadata{'Name'}" eq "$templine[0]") && ("$metadata{'Release'}" ne "$templine[2]")) {
 
421
                                move("$Conf::dbdir/meta/meta-$metadata{'Name'}","$Conf::dbdir/meta/old_meta-$metadata{'Name'}");
 
422
                                fetchfile("meta/meta-$metadata{'Name'}", "");
 
423
                                move("$Conf::cachedir/meta-$metadata{'Name'}", "$Conf::dbdir/meta/meta-$metadata{'Name'}");
 
424
                        }
427
425
                }
428
426
        }
429
427
}
430
428
 
431
 
sub coredbinfo {
432
 
        ### This subroutine returns core db version information in a hash.
433
 
        # Usage is without arguments
434
 
 
435
 
        eval(`grep "core_" $Conf::dbdir/lists/core-list.db`);
436
 
 
437
 
        my %coredb = (
438
 
                CoreVersion => $Conf::version,
439
 
                Release => $Conf::core_mine,
440
 
        );
441
 
 
442
 
        $coredb{'AvailableRelease'} = $core_release if ("$Conf::core_mine" < "$core_release");
443
 
 
444
 
        return %coredb;
445
 
}
446
 
 
447
429
sub dblist {
448
 
        ### This subroutine returns the packages from the packages_list db in a hash.
449
 
        #   It uses the currently cached version of packages_list. To ensure latest 
450
 
        #   data, run Pakfire::dbgetlist first.
451
 
        #   You may also pass a filter: &Pakfire::dblist(filter) 
452
 
        #   Usage is always with one argument.
453
 
        #   filter may be: 
454
 
        #               - "all": list all known paks,
455
 
        #               - "notinstalled": list only not installed paks,
456
 
        #               - "installed": list only installed paks
457
 
        #               - "upgrade": list only upgradable paks
458
 
        #
459
 
        #   Returned hash format:
460
 
    #   ( "<pak name>" => (
461
 
        #       "Installed" => "Yes" or "No" wether the pak is installed,
462
 
        #       "ProgVersion" => Installed program version when "Installed" => "Yes" or
463
 
    #                        Available version when "Installed" => No,
464
 
        #       "Release" => Installed pak release number when "Installed" => "Yes" or
465
 
    #                    Available pak release number when "Installed" => No,
466
 
        #       "AvailableProgVersion" => Available program version. 
467
 
        #                                 Only defined if an upgrade to a higher version is available,
468
 
        #       "AvailableRelease" => Available pak release version. 
469
 
        #                             Only defined if an upgrade to a higher version is available
470
 
        #         ),
471
 
        #         ...   
472
 
        #   )
473
 
        
 
430
        ### This subroutine lists the packages.
 
431
        #   You may also pass a filter: &Pakfire::dblist(filter)
 
432
        #   Usage is always with two arguments.
 
433
        #   filter may be: all, notinstalled, installed
474
434
        my $filter = shift;
475
 
        my %paklist = ();
 
435
        my $forweb = shift;
 
436
        my @updatepaks;
476
437
        my $file;
477
438
        my $line;
 
439
        my $prog;
478
440
        my %metadata;
479
441
        my @templine;
480
 
        
 
442
 
 
443
        ### Make sure that the list is not outdated.
 
444
        #dbgetlist("noforce");
 
445
 
481
446
        open(FILE, "<$Conf::dbdir/lists/packages_list.db");
482
447
        my @db = <FILE>;
483
448
        close(FILE);
484
449
 
485
 
        if ("$filter" ne "notinstalled") {
 
450
        if ("$filter" eq "upgrade") {
 
451
                if ("$forweb" ne "forweb" && "$forweb" ne "notice" ) {getcoredb("noforce");}
 
452
                eval(`grep "core_" $Conf::dbdir/lists/core-list.db`);
 
453
                if ("$core_release" > "$Conf::core_mine") {
 
454
                        if ("$forweb" eq "forweb") {
 
455
                                print "<option value=\"core\">Core-Update -- $Conf::version -- Release: $Conf::core_mine -> $core_release</option>\n";
 
456
                        }
 
457
                        elsif ("$forweb" eq "notice") {
 
458
                                print "<br /><br /><br /><a href='pakfire.cgi'>$Lang::tr{'core notice 1'} $Conf::core_mine $Lang::tr{'core notice 2'} $core_release $Lang::tr{'core notice 3'}</a>";
 
459
                        } else {
 
460
                                my $command = "Core-Update $Conf::version\nRelease: $Conf::core_mine -> $core_release\n";
 
461
                                if ("$Pakfire::enable_colors" eq "1") {
 
462
                                        print "$color{'lila'}$command$color{'normal'}\n";
 
463
                                } else {
 
464
                                        print "$command\n";
 
465
                                }
 
466
                        }
 
467
                }
 
468
 
486
469
                opendir(DIR,"$Conf::dbdir/installed");
487
470
                my @files = readdir(DIR);
488
471
                closedir(DIR);
489
 
 
490
472
                foreach $file (@files) {
491
473
                        next if ( $file eq "." );
492
474
                        next if ( $file eq ".." );
493
475
                        next if ( $file =~ /^old/ );
494
476
                        %metadata = parsemetafile("$Conf::dbdir/installed/$file");
495
477
 
496
 
                        foreach $line (@db) {
497
 
                                next unless ($line =~ /.*;.*;.*;/ );
498
 
                                @templine = split(/\;/,$line);
499
 
                                if (("$metadata{'Name'}" eq "$templine[0]") && ("$metadata{'Release'}" < "$templine[2]")) {
500
 
                                        # Add all upgradable paks to list
501
 
                                        $paklist{"$metadata{'Name'}"} = {
502
 
                                                ProgVersion => $metadata{'ProgVersion'},
503
 
                                                Release => $metadata{'Release'},
504
 
                                                AvailableProgVersion => $templine[1],
505
 
                                                AvailableRelease => $templine[2],
506
 
                                                Installed => "yes"
507
 
                                        };
508
 
                                        last;
509
 
                                } elsif (("$metadata{'Name'}" eq "$templine[0]") && ("$filter" ne "upgrade")) {
510
 
                                        # Add installed paks without an upgrade available to list
511
 
                                        $paklist{"$metadata{'Name'}"} = {
512
 
                                                ProgVersion => $metadata{'ProgVersion'},
513
 
                                                Release => $metadata{'Release'},
514
 
                                                Installed => "yes"
515
 
                                        };
516
 
                                        last;
 
478
                        foreach $prog (@db) {
 
479
                                @templine = split(/\;/,$prog);
 
480
                                if (("$metadata{'Name'}" eq "$templine[0]") && ("$metadata{'Release'}" < "$templine[2]" && "$forweb" ne "notice")) {
 
481
                                        push(@updatepaks,$metadata{'Name'});
 
482
                                        if ("$forweb" eq "forweb") {
 
483
                                                print "<option value=\"$metadata{'Name'}\">Update: $metadata{'Name'} -- Version: $metadata{'ProgVersion'} -> $templine[1] -- Release: $metadata{'Release'} -> $templine[2]</option>\n";
 
484
                                        } else {
 
485
                                                my $command = "Update: $metadata{'Name'}\nVersion: $metadata{'ProgVersion'} -> $templine[1]\nRelease: $metadata{'Release'} -> $templine[2]\n";
 
486
                                                if ("$Pakfire::enable_colors" eq "1") {
 
487
                                                        print "$color{'lila'}$command$color{'normal'}\n";
 
488
                                                } else {
 
489
                                                        print "$command\n";
 
490
                                                }
 
491
                                        }
517
492
                                }
518
493
                        }
519
494
                }
520
 
        }
521
 
 
522
 
        # Add all not installed paks to list
523
 
        if (("$filter" ne "upgrade") && ("$filter" ne "installed")) {
524
 
                foreach $line (@db) {
 
495
                return @updatepaks;
 
496
        } else {
 
497
                my $line;
 
498
                my $use_color;
 
499
                my @templine;
 
500
                my $count;
 
501
                foreach $line (sort @db) {
525
502
                        next unless ($line =~ /.*;.*;.*;/ );
 
503
                        $use_color = "";
526
504
                        @templine = split(/\;/,$line);
527
 
                        next if ((defined $paklist{"$templine[0]"}) || (&isinstalled($templine[0]) == 0));
528
 
 
529
 
                        $paklist{"$templine[0]"} = {
530
 
                                ProgVersion => "$templine[1]",
531
 
                                Release => "$templine[2]",
532
 
                                Installed => "no"
533
 
                        };
 
505
                        if ("$filter" eq "notinstalled") {
 
506
                                next if ( -e "$Conf::dbdir/installed/meta-$templine[0]" );
 
507
                        } elsif ("$filter" eq "installed") {
 
508
                                next unless ( -e "$Conf::dbdir/installed/meta-$templine[0]" );
 
509
                        }
 
510
                        $count++;
 
511
                        if ("$forweb" eq "forweb")
 
512
                         {
 
513
                                if ("$filter" eq "notinstalled") {
 
514
                                        print "<option value=\"$templine[0]\">$templine[0]-$templine[1]-$templine[2]</option>\n";
 
515
                                } else {
 
516
                                        print "<option value=\"$templine[0]\">$templine[0]</option>\n";
 
517
                                }
 
518
                        } else {
 
519
                                if ("$Pakfire::enable_colors" eq "1") {
 
520
                                        if (&isinstalled("$templine[0]")) {
 
521
                                                $use_color = "$color{'red'}"
 
522
                                        } else {
 
523
                                                $use_color = "$color{'green'}"
 
524
                                        }
 
525
                                }
 
526
                                print "${use_color}Name: $templine[0]\nProgVersion: $templine[1]\nRelease: $templine[2]$color{'normal'}\n\n";
 
527
                        }
534
528
                }
 
529
                print "$count packages total.\n" unless ("$forweb" eq "forweb");
535
530
        }
536
 
 
537
 
        return %paklist;
538
531
}
539
532
 
540
533
sub resolvedeps_one {
541
534
        my $pak = shift;
542
 
        
 
535
 
 
536
        getmetafile("$pak");
 
537
 
543
538
        message("PAKFIRE RESV: $pak: Resolving dependencies...");
544
539
 
545
 
        unless (getmetafile("$pak")) {
546
 
                message("PAKFIRE ERROR: Error retrieving dependency information on $pak. Unable to resolve dependencies.");
547
 
                exit 1;
548
 
        };
549
 
        
550
540
        my %metadata = parsemetafile("$Conf::dbdir/meta/meta-$pak");
551
541
        my @all;
552
542
        my @deps = split(/ /, $metadata{'Dependencies'});
639
629
 
640
630
sub getmetafile {
641
631
        my $pak = shift;
642
 
        
643
 
        # Try to download meta-file if we don't have one yet, or it is empty for some reason
644
 
        if ((! -e "$Conf::dbdir/meta/meta-$pak" ) || ( -z "$Conf::dbdir/meta/meta-$pak" )) {
645
 
                return 0 unless (fetchfile("meta/meta-$pak", ""));
 
632
 
 
633
        unless ( -e "$Conf::dbdir/meta/meta-$pak" ) {
 
634
                fetchfile("meta/meta-$pak", "");
 
635
                move("$Conf::cachedir/meta-$pak", "$Conf::dbdir/meta/meta-$pak");
 
636
        }
 
637
 
 
638
        if ( -z "$Conf::dbdir/meta/meta-$pak" ) {
 
639
                fetchfile("meta/meta-$pak", "");
646
640
                move("$Conf::cachedir/meta-$pak", "$Conf::dbdir/meta/meta-$pak");
647
641
        }
648
642
 
657
651
                print FILE $string;
658
652
        }
659
653
        close(FILE);
660
 
 
661
654
        return 1;
662
655
}
663
656
 
702
695
        return %metadata;
703
696
}
704
697
 
705
 
sub getmetadata {
706
 
        ### This subroutine returns a hash of available info for a package
707
 
        #   Pass package name and type of info as argument: Pakfire::getmetadata(package, type_of_info) 
708
 
        #       Type_of_info can be "latest" or "installed"
709
 
        #   Usage is always with two argument.
710
 
        my ($pak, $type) = @_;
711
 
 
712
 
        my %metadata = (
713
 
                Name => $pak, 
714
 
                Installed => "no",
715
 
                Available => "no");
716
 
        my %installed_metadata = ();
717
 
 
718
 
        my @templine;
719
 
        my @file;
720
 
 
721
 
        ### Get available version information
722
 
        if ("$type" eq "latest") {
723
 
                ### Check if package is in packages_list and get latest available version
724
 
                my %db = Pakfire::dblist("all");
725
 
                
726
 
                if (defined $db{$pak}) {
727
 
                        ### Get and parse latest available metadata
728
 
                        if (getmetafile("$pak")) {
729
 
                                %metadata = parsemetafile("$Conf::dbdir/meta/meta-$pak");
730
 
 
731
 
                                $metadata{'Available'} = "yes";
732
 
                                ### Rename version info fields
733
 
                                $metadata{'AvailableProgVersion'} = delete $metadata{'ProgVersion'};
734
 
                                $metadata{'AvailableRelease'} = delete $metadata{'Release'};
735
 
                        }
736
 
                }
737
 
        }
738
 
        
739
 
        ### Parse installed pak metadata
740
 
        if (&isinstalled($pak) == 0) {
741
 
            %installed_metadata = parsemetafile("$Conf::dbdir/installed/meta-$pak");
742
 
 
743
 
                if ("$type" eq "latest" && exists($metadata{'AvailableProgVersion'})) {
744
 
                        ### Add installed version info to latest metadata
745
 
                        $metadata{'ProgVersion'} = $installed_metadata{'ProgVersion'};
746
 
                        $metadata{'Release'} = $installed_metadata{'Release'};
747
 
                } else {
748
 
                        ### Use metadata of installed pak
749
 
                        %metadata = %installed_metadata;
750
 
                }
751
 
                $metadata{'Installed'} = 'yes';
752
 
        } else {
753
 
                $metadata{'Installed'} = 'no';
754
 
        }
755
 
 
756
 
        return %metadata;
757
 
}
758
 
 
759
698
sub decryptpak {
760
699
        my $pak = shift;
761
700
 
774
713
        my $pak = shift;
775
714
        my $force = shift;
776
715
 
777
 
        unless (getmetafile("$pak")) {
778
 
                message("PAKFIRE ERROR: Unable to retrieve $pak metadata.");
779
 
                exit 1;
780
 
        }
781
 
        
 
716
        getmetafile("$pak");
 
717
 
782
718
        my %metadata = parsemetafile("$Conf::dbdir/meta/meta-$pak");
783
719
        my $file = $metadata{'File'};
784
720
 
792
728
                        return $file;
793
729
                }
794
730
        }
795
 
        
796
 
        unless (fetchfile("paks/$file", "")) {
797
 
                message("PAKFIRE ERROR: Unable to download $pak.");
798
 
                exit 1;
799
 
        }
 
731
 
 
732
        fetchfile("paks/$file", "");
800
733
        return $file;
801
734
}
802
735
 
823
756
}
824
757
 
825
758
sub upgradecore {
826
 
        # Safety check for lazy testers:
827
 
        # Before we upgrade to the latest release, we re-install the previous release
828
 
        # to make sure that the tester has always been on the latest version.
829
 
        my $tree = &get_tree();
830
 
        $Conf::core_mine-- if ($tree eq "testing" || $tree eq "unstable");
831
 
 
832
 
        message("CORE UPGR: Upgrading from release $Conf::core_mine to $core_release");
833
 
        
834
 
        my @seq = ($Conf::core_mine .. $core_release);
835
 
        shift @seq;
836
 
        my $release;
837
 
        foreach $release (@seq) {
838
 
                chomp($release);
839
 
                getpak("core-upgrade-$release");
840
 
        }
841
 
        
842
 
        foreach $release (@seq) {
843
 
                chomp($release);
844
 
                upgradepak("core-upgrade-$release");
845
 
        }
846
 
        
847
 
        system("echo $core_release > $Conf::coredir/mine");
 
759
        getcoredb("noforce");
 
760
        eval(`grep "core_" $Conf::dbdir/lists/core-list.db`);
 
761
        if ("$core_release" > "$Conf::core_mine") {
 
762
                # Safety check for lazy testers:
 
763
                # Before we upgrade to the latest release, we re-install the previous release
 
764
                # to make sure that the tester has always been on the latest version.
 
765
                my $tree = &get_tree();
 
766
                $Conf::core_mine-- if ($tree eq "testing" || $tree eq "unstable");
 
767
 
 
768
                message("CORE UPGR: Upgrading from release $Conf::core_mine to $core_release");
 
769
 
 
770
                my @seq = `seq $Conf::core_mine $core_release`;
 
771
                shift @seq;
 
772
                my $release;
 
773
                foreach $release (@seq) {
 
774
                        chomp($release);
 
775
                        getpak("core-upgrade-$release");
 
776
                }
 
777
 
 
778
                foreach $release (@seq) {
 
779
                        chomp($release);
 
780
                        upgradepak("core-upgrade-$release");
 
781
                }
 
782
 
 
783
                system("echo $core_release > $Conf::coredir/mine");
 
784
 
 
785
        } else {
 
786
                message("CORE ERROR: No new upgrades available. You are on release $Conf::core_mine.");
 
787
        }
848
788
}
849
789
 
850
790
sub isinstalled {
956
896
 
957
897
sub updates_available {
958
898
        # Get packets with updates available
959
 
        my %upgradepaks = &Pakfire::dblist("upgrade");
 
899
        my @upgradepaks = &Pakfire::dblist("upgrade", "noweb");
960
900
 
961
 
        # Get the length of the returned hash
962
 
        my $updatecount = keys %upgradepaks;
 
901
        # Get the length of the returned array
 
902
        my $updatecount = scalar @upgradepaks;
963
903
 
964
904
        return "$updatecount";
965
905
}
966
906
 
 
907
sub coreupdate_available {
 
908
        eval(`grep "core_" $Conf::dbdir/lists/core-list.db`);
 
909
        if ("$core_release" > "$Conf::core_mine") {
 
910
                return "yes ($core_release)";
 
911
        }
 
912
        else {
 
913
                return "no";
 
914
        }
 
915
}
 
916
 
967
917
sub reboot_required {
968
918
        if ( -e "/var/run/need_reboot" ) {
969
919
                return "yes";
974
924
}
975
925
 
976
926
sub status {
977
 
        ### This subroutine returns pakfire status information in a hash.
978
 
        # Usage is without arguments
979
 
 
980
 
        # Add core version info
981
 
        my %status = &Pakfire::coredbinfo();
982
 
 
983
 
        # Add last update info
984
 
        $status{'LastUpdate'} = &General::age("/opt/pakfire/db/core/mine");
985
 
        $status{'LastCoreListUpdate'} = &General::age("/opt/pakfire/db/lists/core-list.db");
986
 
        $status{'LastServerListUpdate'} = &General::age("/opt/pakfire/db/lists/server-list.db");
987
 
        $status{'LastPakListUpdate'} = &General::age("/opt/pakfire/db/lists/packages_list.db");
988
 
 
989
 
        # Add number of available package updates
990
 
        $status{'CoreUpdateAvailable'} = (defined $status{'AvailableRelease'}) ? "yes" : "no";
991
 
        $status{'PakUpdatesAvailable'} = &Pakfire::updates_available();
992
 
 
993
 
        # Add if reboot is required
994
 
        $status{'RebootRequired'} = &Pakfire::reboot_required();
995
 
 
996
 
        return %status;
 
927
        # General info
 
928
        my $return = "Core-Version: $Conf::version\n";
 
929
        $return .= "Core-Update-Level: $Conf::core_mine\n";
 
930
        $return .= "Last update: " . &General::age("/opt/pakfire/db/core/mine") . " ago\n";
 
931
        $return .= "Last core-list update: " . &General::age("/opt/pakfire/db/lists/core-list.db") . " ago\n";
 
932
        $return .= "Last server-list update: " . &General::age("/opt/pakfire/db/lists/server-list.db") . " ago\n";
 
933
        $return .= "Last packages-list update: " . &General::age("/opt/pakfire/db/lists/packages_list.db") . " ago\n";
 
934
 
 
935
        # Get availability of core updates
 
936
        $return .= "Core-Update available: " . &Pakfire::coreupdate_available() . "\n";
 
937
 
 
938
        # Get availability of package updates
 
939
        $return .= "Package-Updates available: " . &Pakfire::updates_available() . "\n";
 
940
 
 
941
        # Test if reboot is required
 
942
        $return .= "Reboot required: " . &Pakfire::reboot_required() . "\n";
 
943
 
 
944
        # Return status text
 
945
        print "$return";
 
946
        exit 1;
997
947
}
998
948
 
999
949
sub get_arch() {
1000
950
        # Append architecture
1001
951
        my ($sysname, $nodename, $release, $version, $machine) = POSIX::uname();
1002
952
 
 
953
        # We only support armv6l for 32 bit arm
 
954
        if ($machine =~ m/armv[67]/) {
 
955
                return "armv6l";
 
956
        }
 
957
 
1003
958
        return $machine;
1004
959
}
1005
960