Adding upstream version 1.65.2.upstream/1.65.2upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

5 files changed, 2177 insertions, 0 deletions

diff --git a/script/deb-systemd-helper b/script/deb-systemd-helper
new file mode 100755
index 0000000..5e7e167
--- /dev/null
+++ b/script/deb-systemd-helper
@@ -0,0 +1,691 @@
+#!/usr/bin/perl
+# vim:ts=4:sw=4:expandtab
+# © 2013-2014 Michael Stapelberg <stapelberg@debian.org>
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#
+#     * Neither the name of Michael Stapelberg nor the
+#       names of contributors may be used to endorse or promote products
+#       derived from this software without specific prior written permission.
+# .
+# THIS SOFTWARE IS PROVIDED BY Michael Stapelberg ''AS IS'' AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL Michael Stapelberg BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=head1 NAME
+
+deb-systemd-helper - subset of systemctl for machines not running systemd
+
+=head1 SYNOPSIS
+
+B<deb-systemd-helper> enable | disable | purge | mask | unmask | is-enabled | was-enabled | debian-installed | update-state | reenable S<I<unit file> ...>
+
+=head1 DESCRIPTION
+
+B<deb-systemd-helper> is a Debian-specific helper script which re-implements
+the enable, disable, is-enabled and reenable commands from systemctl.
+
+The "enable" action will only be performed once (when first installing the
+package). On the first "enable", a state file is created which will be deleted
+upon "purge".
+
+The "mask" action will keep state on whether the service was enabled/disabled
+before and will properly return to that state on "unmask".
+
+The "was-enabled" action is not present in systemctl, but is required in Debian
+so that we can figure out whether a service was enabled before we installed an
+updated service file. See http://bugs.debian.org/717603 for details.
+
+The "debian-installed" action is also not present in systemctl. It returns 0 if
+the state file of at least one of the given units is present.
+
+The "update-state" action is also not present in systemctl. It updates
+B<deb-systemd-helper>'s state file, removing obsolete entries (e.g. service
+files that are no longer shipped by the package) and adding new entries (e.g.
+new service files shipped by the package) without enabling them.
+
+B<deb-systemd-helper> is intended to be used from maintscripts to enable
+systemd unit files. It is specifically NOT intended to be used interactively by
+users. Instead, users should run systemd and use systemctl, or not bother about
+the systemd enabled state in case they are not running systemd.
+
+=head1 ENVIRONMENT
+
+=over 4
+
+=item B<_DEB_SYSTEMD_HELPER_DEBUG>
+
+If you export _DEB_SYSTEMD_HELPER_DEBUG=1, deb-systemd-helper will print debug
+messages to stderr (thus visible in dpkg runs). Please include these when
+filing a bugreport.
+
+=item B<DPKG_ROOT>
+
+Instead of working on the filesystem root /, perform all operations on a chroot
+system in the directory given by DPKG_ROOT.
+
+=back
+
+=cut
+
+use strict;
+use warnings;
+use File::Path qw(make_path); # in core since Perl 5.001
+use File::Basename; # in core since Perl 5
+use File::Temp qw(tempfile); # in core since Perl 5.6.1
+use Getopt::Long; # in core since Perl 5
+# Make Data::Dumper::Dumper available if present (not present on systems that
+# only have perl-base, not perl).
+eval { require Data::Dumper; } or *Data::Dumper::Dumper = sub { "no Data::Dumper" };
+
+my $dpkg_root = $ENV{DPKG_ROOT} // '';
+
+use constant {
+     SYSTEM_INSTANCE_ENABLED_STATE_DIR => '/var/lib/systemd/deb-systemd-helper-enabled',
+     USER_INSTANCE_ENABLED_STATE_DIR   => '/var/lib/systemd/deb-systemd-user-helper-enabled',
+     SYSTEM_INSTANCE_MASKED_STATE_DIR  => '/var/lib/systemd/deb-systemd-helper-masked',
+     USER_INSTANCE_MASKED_STATE_DIR    => '/var/lib/systemd/deb-systemd-user-helper-masked',
+};
+
+my $quiet = 0;
+my $instance = 'system';
+my $enabled_state_dir = $dpkg_root . SYSTEM_INSTANCE_ENABLED_STATE_DIR;
+my $masked_state_dir = $dpkg_root . SYSTEM_INSTANCE_MASKED_STATE_DIR;
+
+# Globals are bad, but in this specific case, it really makes things much
+# easier to write and understand.
+my $changed_sth;
+my $has_systemctl = -x "$dpkg_root/bin/systemctl" || -x "$dpkg_root/usr/bin/systemctl";
+
+sub assertdpkgroot {
+    my ($path, $msg) = @_;
+    if (length $ENV{DPKG_ROOT}) {
+        if ($path !~ /^\Q$dpkg_root\E/) {
+            error("doesn't start with dpkg_root: $path $msg");
+        }
+        if ($path =~ /^\Q$dpkg_root$dpkg_root\E/) {
+            error("double dpkg_root: $path $msg");
+        }
+    }
+}
+
+sub assertnotdpkgroot {
+    my ($path, $msg) = @_;
+    if (length $ENV{DPKG_ROOT}) {
+        if ($path =~ /^\Q$dpkg_root\E/) {
+            error("starts with dpkg_root: $path $msg");
+        }
+    }
+}
+
+sub error {
+    print STDERR "$0: error: @_\n";
+    exit (1);
+}
+
+sub debug {
+    my ($msg) = @_;
+    return if !defined($ENV{_DEB_SYSTEMD_HELPER_DEBUG}) || $ENV{_DEB_SYSTEMD_HELPER_DEBUG} != 1;
+    print STDERR "(deb-systemd-helper DEBUG) $msg\n";
+}
+
+sub is_purge {
+    return (defined($ENV{_DEB_SYSTEMD_HELPER_PURGE}) && $ENV{_DEB_SYSTEMD_HELPER_PURGE} == 1)
+}
+
+sub find_unit {
+    my ($scriptname) = @_;
+
+    my $service_path = $scriptname;
+
+    if (-f "$dpkg_root/etc/systemd/$instance/$scriptname") {
+        $service_path = "/etc/systemd/$instance/$scriptname";
+    } elsif (-f "$dpkg_root/lib/systemd/$instance/$scriptname") {
+        $service_path = "/lib/systemd/$instance/$scriptname";
+    } elsif (-f "$dpkg_root/usr/lib/systemd/$instance/$scriptname") {
+        $service_path = "/usr/lib/systemd/$instance/$scriptname";
+    }
+
+    return $service_path;
+}
+
+sub dsh_state_path {
+    my ($scriptname) = @_;
+    return $enabled_state_dir . '/' . basename($scriptname) . '.dsh-also';
+}
+
+sub state_file_entries {
+    my ($dsh_state) = @_;
+    debug "Reading state file $dsh_state";
+    my @entries;
+    if (open(my $fh, '<', $dsh_state)) {
+        @entries = map { chomp; "$dpkg_root$_" } <$fh>;
+        close($fh);
+    }
+    return @entries;
+}
+
+# Writes $service_link into $dsh_state unless it’s already in there.
+sub record_in_statefile {
+    my ($dsh_state, $service_link) = @_;
+
+    assertdpkgroot($dsh_state, "record_in_statefile");
+    assertnotdpkgroot($service_link, "record_in_statefile");
+
+    # Appending a newline makes the following code simpler; we can skip
+    # chomp()ing and appending newlines in every print.
+    $service_link .= "\n";
+
+    make_path(dirname($dsh_state));
+    my $line_exists;
+    my ($outfh, $tmpname) = tempfile('.stateXXXXX',
+        DIR => dirname($dsh_state),
+        SUFFIX => '.tmp',
+        UNLINK => 0);
+    chmod(0644, $tmpname);
+    if (-e $dsh_state) {
+        open(my $infh, '<', $dsh_state) or error("unable to read from $dsh_state");
+        while (<$infh>) {
+            $line_exists = 1 if $_ eq $service_link;
+            print $outfh $_;
+        }
+        close($infh);
+    }
+    print $outfh $service_link unless $line_exists;
+    close($outfh) or error("unable to close $tmpname");
+
+    debug "Renaming temp file $tmpname to state file $dsh_state";
+    rename($tmpname, $dsh_state) or
+        error("Unable to move $tmpname to $dsh_state");
+}
+
+# Gets the transitive closure of links, i.e. all links that need to be created
+# when enabling this service file. Not straight-forward because service files
+# can refer to other service files using Also=.
+sub get_link_closure {
+    my ($scriptname, $service_path, @visited) = @_;
+    assertnotdpkgroot($service_path, "get_link_closure");
+
+    my @links;
+    my @wants_dirs;
+
+    my $unit_name = basename($service_path);
+    my $wanted_target = $unit_name;
+
+    # The keys parsed from the unit file below can only have unit names
+    # as values. Since unit names can't have whitespace in systemd,
+    # simply use split and strip any leading/trailing quotes. See
+    # systemd-escape(1) for examples of valid unit names.
+    open my $fh, '<', "$dpkg_root$service_path" or error("unable to read $dpkg_root$service_path");
+    while (my $line = <$fh>) {
+        chomp($line);
+        my $service_link;
+
+        if ($line =~ /^\s*(WantedBy|RequiredBy)=(.+)$/i) {
+            for my $value (split(/\s+/, $2)) {
+                $value =~ s/^(["'])(.*)\g1$/$2/;
+                my $wants_dir = "/etc/systemd/$instance/$value";
+                $wants_dir .= '.wants' if $1 eq 'WantedBy';
+                $wants_dir .= '.requires' if $1 eq 'RequiredBy';
+                push @wants_dirs, "$wants_dir/";
+            }
+        }
+
+        if ($line =~ /^\s*Also=(.+)$/i) {
+            for my $value (split(/\s+/, $1)) {
+                $value =~ s/^(["'])(.*)\g1$/$2/;
+                if ($value ne $unit_name and not grep $_ eq $value, @visited) {
+                    # We can end up in an infinite recursion, so remember what units we
+                    # already processed to break it
+                    push @visited, $value;
+                    push @links, get_link_closure($value, find_unit($value), @visited);
+                }
+            }
+        }
+
+        if ($line =~ /^\s*Alias=(.+)$/i) {
+            for my $value (split(/\s+/, $1)) {
+                $value =~ s/^(["'])(.*)\g1$/$2/;
+                if ($value ne $unit_name) {
+                    push @links, { dest => $service_path, src => "/etc/systemd/$instance/$1" };
+                }
+            }
+        }
+
+        if ($line =~ /^\s*DefaultInstance=\s*(["']?+)(.+)\g1\s*$/i) {
+            $wanted_target = $2;
+            $wanted_target = $unit_name =~ s/^(.*\@)(\.\w+)$/$1$wanted_target$2/r;
+        }
+    }
+    close($fh);
+
+    for my $wants_dir (@wants_dirs) {
+        push @links, { dest => $service_path, src => $wants_dir . $wanted_target };
+    }
+
+    return @links;
+}
+
+sub all_links_installed {
+    my ($scriptname, $service_path) = @_;
+
+    my @links = get_link_closure($scriptname, $service_path);
+    foreach my $link (@links) {
+        assertnotdpkgroot($link->{src}, "all_links_installed");
+    }
+    my @missing_links = grep { ! -l "$dpkg_root$_->{src}" } @links;
+
+    return (@missing_links == 0);
+}
+
+sub no_link_installed {
+    my ($scriptname, $service_path) = @_;
+
+    my @links = get_link_closure($scriptname, $service_path);
+    foreach my $link (@links) {
+        assertnotdpkgroot($link->{src}, "all_links_installed");
+    }
+    my @existing_links = grep { -l "$dpkg_root$_->{src}" } @links;
+
+    return (@existing_links == 0);
+}
+
+sub enable {
+    my ($scriptname, $service_path) = @_;
+    if ($has_systemctl) {
+        # We use 'systemctl preset' on the initial installation only.
+        # On upgrade, we manually add the missing symlinks only if the
+        # service already has some links installed. Using 'systemctl
+        # preset' allows administrators and downstreams to alter the
+        # enable policy using systemd-native tools.
+        my $create_links = 0;
+        if (debian_installed($scriptname)) {
+            $create_links = 1 unless no_link_installed($scriptname, $service_path);
+        } else {
+            debug "Using systemctl preset to enable $scriptname";
+            my $systemd_root = '/';
+            if ($dpkg_root ne '') {
+                $systemd_root = $dpkg_root;
+            }
+            system("systemctl",
+                   "--root=$systemd_root",
+                   $instance eq "user" ? "--global" : "--system",
+                   "--preset-mode=enable-only",
+                   "preset", $scriptname) == 0
+                or error("systemctl preset failed on $scriptname: $!");
+        }
+        make_systemd_links($scriptname, $service_path, create_links => $create_links);
+    } else {
+        # We create all the symlinks ourselves
+        make_systemd_links($scriptname, $service_path);
+    }
+}
+
+sub make_systemd_links {
+    my ($scriptname, $service_path, %opts) = @_;
+    $opts{'create_links'} //= 1;
+
+    my $dsh_state = dsh_state_path($scriptname);
+
+    my @links = get_link_closure($scriptname, $service_path);
+    for my $link (@links) {
+        my $service_path = $link->{dest};
+        my $service_link = $link->{src};
+
+        record_in_statefile($dsh_state, $service_link);
+
+        my $statefile = $service_link;
+        $statefile =~ s,^/etc/systemd/$instance/,$enabled_state_dir/,;
+        $service_link = "$dpkg_root$service_link";
+        assertdpkgroot($statefile, "make_systemd_links");
+        assertdpkgroot($service_link, "make_systemd_links");
+        assertnotdpkgroot($service_path, "make_systemd_links");
+        next if -e $statefile;
+
+        if ($opts{'create_links'} && ! -l $service_link) {
+            make_path(dirname($service_link));
+            symlink($service_path, $service_link) or
+                error("unable to link $service_link to $service_path: $!");
+            $changed_sth = 1;
+        }
+
+        # Store the fact that we ran enable for this service_path,
+        # so that we can skip enable the next time.
+        # This allows us to call deb-systemd-helper unconditionally
+        # and still only enable unit files on the initial installation
+        # of a package.
+        make_path(dirname($statefile));
+        open(my $fh, '>>', $statefile) or error("Failed to create/touch $statefile");
+        close($fh) or error("Failed to create/touch $statefile");
+    }
+
+}
+
+# In contrary to make_systemd_links(), which only modifies the state file in an
+# append-only fashion, update_state() can also remove entries from the state
+# file.
+#
+# The distinction is important because update_state() should only be called
+# when the unit file(s) are guaranteed to be on-disk, e.g. on package updates,
+# but not on package removals.
+sub update_state {
+    my ($scriptname, $service_path) = @_;
+
+    my $dsh_state = dsh_state_path($scriptname);
+    my @links = get_link_closure($scriptname, $service_path);
+    assertdpkgroot($dsh_state, "update_state");
+
+    debug "Old state file contents: " .
+        Data::Dumper::Dumper([ state_file_entries($dsh_state) ]);
+
+    make_path(dirname($dsh_state));
+    my ($outfh, $tmpname) = tempfile('.stateXXXXX',
+        DIR => dirname($dsh_state),
+        SUFFIX => '.tmp',
+        UNLINK => 0);
+    chmod(0644, $tmpname);
+    for my $link (@links) {
+        assertnotdpkgroot($link->{src}, "update_state");
+        print $outfh $link->{src} . "\n";
+    }
+    close($outfh) or error("Failed to close $tmpname");
+
+    debug "Renaming temp file $tmpname to state file $dsh_state";
+    rename($tmpname, $dsh_state) or
+        error("Unable to move $tmpname to $dsh_state");
+
+    debug "New state file contents: " .
+        Data::Dumper::Dumper([ state_file_entries($dsh_state) ]);
+}
+
+sub was_enabled {
+    my ($scriptname) = @_;
+
+    my @entries = state_file_entries(dsh_state_path($scriptname));
+    debug "Contents: " . Data::Dumper::Dumper(\@entries);
+
+    for my $link (@entries) {
+        assertdpkgroot($link, "was_enabled");
+        if (! -l $link) {
+            debug "Link $link is missing, considering $scriptname was-disabled.";
+            return 0;
+        }
+    }
+
+    debug "All links present, considering $scriptname was-enabled.";
+    return 1;
+}
+
+sub debian_installed {
+    my ($scriptname) = @_;
+    return -f dsh_state_path($scriptname);
+}
+
+sub remove_links {
+    my ($service_path) = @_;
+
+    my $dsh_state = dsh_state_path($service_path);
+    my @entries = state_file_entries($dsh_state);
+    debug "Contents: " . Data::Dumper::Dumper(\@entries);
+    assertdpkgroot($dsh_state, "remove_links");
+    assertnotdpkgroot($service_path, "remove_links");
+
+    if (is_purge()) {
+        unlink($dsh_state) if -e $dsh_state;
+    }
+
+    # Also disable all the units which were enabled when this one was enabled.
+    for my $link (@entries) {
+        # Delete the corresponding state file:
+        # • Always when purging
+        # • If the user did not disable (= link still exists) the service.
+        #   If we don’t do this, the link will be deleted a few lines down,
+        #   but not re-created when re-installing the package.
+        assertdpkgroot($link, "remove_links");
+        if (is_purge() || -l $link) {
+            my $link_state = $link;
+            $link_state =~ s,^\Q$dpkg_root\E/etc/systemd/$instance/,$enabled_state_dir/,;
+            unlink($link_state);
+        }
+
+        next unless -l $link;
+        unlink($link) or
+            print STDERR "$0: unable to remove '$link': $!\n";
+
+        $changed_sth = 1;
+    }
+
+    # Read $service_path, recurse for all Also= units.
+    # This might not work when $service_path was already deleted,
+    # i.e. after apt-get remove. In this case we just return
+    # silently in order to not confuse the user about whether
+    # disabling actually worked or not — the case is handled by
+    # dh_installsystemd generating an appropriate disable
+    # command by parsing the service file at debhelper-time.
+    open(my $fh, '<', "$dpkg_root$service_path") or return;
+    while (my $line = <$fh>) {
+        chomp($line);
+        my $service_link;
+
+        if ($line =~ /^\s*Also=(.+)$/i) {
+            remove_links(find_unit($1));
+        }
+    }
+    close($fh);
+}
+
+# Recursively deletes a directory structure, if all (!) components are empty,
+# e.g. to clean up after purging.
+sub rmdir_if_empty {
+    my ($dir) = @_;
+
+    debug "rmdir_if_empty $dir";
+
+    rmdir_if_empty($_) for (grep { -d } <$dir/*>);
+
+    if (!rmdir($dir)) {
+        debug "rmdir($dir) failed ($!)";
+    }
+}
+
+sub mask_service {
+    my ($scriptname, $service_path) = @_;
+
+    my $mask_link = "$dpkg_root/etc/systemd/$instance/" . basename($service_path);
+
+    if (-e $mask_link) {
+        # If the link already exists, don’t do anything.
+        return if -l $mask_link && readlink($mask_link) eq '/dev/null';
+
+        # If the file already exists, the user most likely copied the .service
+        # file to /etc/ to change it in some way. In this case we don’t need to
+        # mask the .service in the first place, since it will not be removed by
+        # dpkg.
+        debug "$mask_link already exists, not masking.";
+        return;
+    }
+
+    make_path(dirname($mask_link));
+    # clean up after possible leftovers from Alias= to self (LP#1439793)
+    unlink($mask_link);
+    symlink('/dev/null', $mask_link) or
+        error("unable to link $mask_link to /dev/null: $!");
+    $changed_sth = 1;
+
+    my $statefile = $mask_link;
+    $statefile =~ s,^\Q$dpkg_root\E/etc/systemd/$instance/,$masked_state_dir/,;
+
+    # Store the fact that we masked this service, so that we can unmask it on
+    # installation time. We cannot unconditionally unmask because that would
+    # interfere with the user’s decision to mask a service.
+    make_path(dirname($statefile));
+    open(my $fh, '>>', $statefile) or error("Failed to create/touch $statefile");
+    close($fh) or error("Failed to create/touch $statefile");
+}
+
+sub unmask_service {
+    my ($scriptname, $service_path) = @_;
+
+    my $mask_link = "$dpkg_root/etc/systemd/$instance/" . basename($service_path);
+
+    # Not masked? Nothing to do.
+    return unless -e $mask_link;
+
+    if (! -l $mask_link || readlink($mask_link) ne '/dev/null') {
+        debug "Not unmasking $mask_link because it is not a link to /dev/null";
+        return;
+    }
+
+    my $statefile = $mask_link;
+    $statefile =~ s,^\Q$dpkg_root\E/etc/systemd/$instance/,$masked_state_dir/,;
+
+    if (! -e $statefile) {
+        debug "Not unmasking $mask_link because the state file $statefile does not exist";
+        return;
+    }
+
+    unlink($mask_link) or
+        error("unable to remove $mask_link: $!");
+    $changed_sth = 1;
+    unlink($statefile);
+}
+
+my $result = GetOptions(
+    "quiet" => \$quiet,
+    "user" => sub { $instance = 'user'; },
+    "system" => sub { $instance = 'system'; }, # default
+);
+
+if ($instance eq 'user') {
+    debug "is user unit = yes";
+    $enabled_state_dir = $dpkg_root . USER_INSTANCE_ENABLED_STATE_DIR;
+    $masked_state_dir = $dpkg_root . USER_INSTANCE_MASKED_STATE_DIR;
+}
+
+my $action = shift;
+if (!defined($action)) {
+    # Called without arguments. Explain that this script should not be run interactively.
+    print "$0 is a program which should be called by dpkg maintscripts only.\n";
+    print "Please do not run it interactively, ever. Also see the manpage deb-systemd-helper(1).\n";
+    exit 0;
+}
+
+if (!$ENV{DPKG_MAINTSCRIPT_PACKAGE}) {
+    print STDERR "$0 was not called from dpkg. Exiting.\n";
+    exit 1;
+}
+
+if ($action eq 'purge') {
+    $ENV{_DEB_SYSTEMD_HELPER_PURGE} = 1;
+    $action = 'disable';
+}
+
+debug "is purge = " . (is_purge() ? "yes" : "no");
+
+my $rc = 0;
+if ($action eq 'is-enabled' ||
+    $action eq 'was-enabled' ||
+    $action eq 'debian-installed') {
+    $rc = 1;
+}
+for my $scriptname (@ARGV) {
+    my $service_path = find_unit($scriptname);
+
+    debug "action = $action, scriptname = $scriptname, service_path = $service_path";
+
+    if ($action eq 'is-enabled') {
+        my $enabled = all_links_installed($scriptname, $service_path);
+        print STDERR ($enabled ? "enabled\n" : "disabled\n") unless $quiet;
+        $rc = 0 if $enabled;
+    }
+
+    # was-enabled is the same as is-enabled, but only considers links recorded
+    # in the state file. This is useful after package upgrades, to determine
+    # whether the unit file was enabled before upgrading, even if the unit file
+    # has changed and is not entirely enabled currently (due to a new Alias=
+    # line for example).
+    #
+    # If all machines were running systemd, this issue would not be present
+    # because is-enabled would query systemd, which would not have picked up
+    # the new unit file yet.
+    if ($action eq 'was-enabled') {
+        my $enabled = was_enabled($scriptname);
+        print STDERR ($enabled ? "enabled\n" : "disabled\n") unless $quiet;
+        $rc = 0 if $enabled;
+    }
+
+    if ($action eq 'update-state') {
+        update_state($scriptname, $service_path);
+    }
+
+    if ($action eq 'debian-installed') {
+        $rc = 0 if debian_installed($scriptname);
+    }
+
+    if ($action eq 'reenable') {
+        remove_links($service_path);
+        make_systemd_links($scriptname, $service_path);
+    }
+
+    if ($action eq 'disable') {
+        remove_links($service_path);
+        # Clean up the state dir if it’s empty, or at least clean up all empty
+        # subdirectories. Necessary to cleanly pass a piuparts run.
+        rmdir_if_empty($dpkg_root . SYSTEM_INSTANCE_ENABLED_STATE_DIR);
+        rmdir_if_empty($dpkg_root . USER_INSTANCE_ENABLED_STATE_DIR);
+
+        # Same with directories below /etc/systemd, where we create symlinks.
+        # If systemd is not installed (and no other package shipping service
+        # files), this would make piuparts fail, too.
+        rmdir_if_empty($_) for (grep { -d } <$dpkg_root/etc/systemd/system/*>);
+        rmdir_if_empty($_) for (grep { -d } <$dpkg_root/etc/systemd/user/*>);
+    }
+
+    if ($action eq 'enable') {
+        enable($scriptname, $service_path);
+    }
+
+    if ($action eq 'mask') {
+        mask_service($scriptname, $service_path);
+    }
+
+    if ($action eq 'unmask') {
+        unmask_service($scriptname, $service_path);
+        # Clean up the state dir if it’s empty, or at least clean up all empty
+        # subdirectories. Necessary to cleanly pass a piuparts run.
+        rmdir_if_empty($dpkg_root . SYSTEM_INSTANCE_MASKED_STATE_DIR);
+        rmdir_if_empty($dpkg_root . USER_INSTANCE_MASKED_STATE_DIR);
+    }
+}
+
+# If we changed anything and this machine is running systemd, tell
+# systemd to reload so that it will immediately pick up our
+# changes.
+if (!length $ENV{DPKG_ROOT} && $changed_sth && $instance eq 'system' && -d "/run/systemd/system") {
+    system("systemctl", "daemon-reload");
+}
+
+exit $rc;
+
+=head1 AUTHOR
+
+Michael Stapelberg <stapelberg@debian.org>
+
+=cut
diff --git a/script/deb-systemd-invoke b/script/deb-systemd-invoke
new file mode 100755
index 0000000..c2e07f7
--- /dev/null
+++ b/script/deb-systemd-invoke
@@ -0,0 +1,159 @@
+#!/usr/bin/perl
+# vim:ts=4:sw=4:expandtab
+# © 2013 Michael Stapelberg <stapelberg@debian.org>
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     * Redistributions of source code must retain the above copyright
+#       notice, this list of conditions and the following disclaimer.
+#
+#     * Redistributions in binary form must reproduce the above copyright
+#       notice, this list of conditions and the following disclaimer in the
+#       documentation and/or other materials provided with the distribution.
+#
+#     * Neither the name of Michael Stapelberg nor the
+#       names of contributors may be used to endorse or promote products
+#       derived from this software without specific prior written permission.
+# .
+# THIS SOFTWARE IS PROVIDED BY Michael Stapelberg ''AS IS'' AND ANY
+# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL Michael Stapelberg BE LIABLE FOR ANY
+# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+=head1 NAME
+
+deb-systemd-invoke - wrapper around systemctl, respecting policy-rc.d
+
+=head1 SYNOPSIS
+
+B<deb-systemd-invoke> [B<--user>] start|stop|restart S<I<unit file> ...>
+
+=head1 DESCRIPTION
+
+B<deb-systemd-invoke> is a Debian-specific helper script which asks
+/usr/sbin/policy-rc.d before performing a systemctl call.
+
+B<deb-systemd-invoke> is intended to be used from maintscripts to start
+systemd unit files. It is specifically NOT intended to be used interactively by
+users. Instead, users should run systemd and use systemctl, or not bother about
+the systemd enabled state in case they are not running systemd.
+
+=cut
+
+use strict;
+use warnings;
+use Getopt::Long; # in core since Perl 5
+
+if (@ARGV < 2) {
+    print STDERR "Syntax: $0 <action> <unit file> [<unit file> ...]\n";
+    exit 1;
+}
+
+my $is_system = 1;
+my @instances = ();
+my $result = GetOptions(
+    "user" => sub { $is_system = 0; },
+    "system" => sub { $is_system = 1; }, # default
+);
+
+my $policyhelper = '/usr/sbin/policy-rc.d';
+if (length $ENV{DPKG_ROOT}) {
+    $policyhelper = $ENV{DPKG_ROOT} . $policyhelper;
+}
+my @units = @ARGV;
+my $action = shift @units;
+if (-x $policyhelper) {
+    for my $unit (@units) {
+        system(qq|$policyhelper $unit "$action"|);
+
+        # 0 or 104 means run
+        # 101 means do not run
+        my $exitcode = ($? >> 8);
+        if ($exitcode == 101) {
+            print STDERR "$policyhelper returned 101, not running '" . join(' ', @ARGV) . "'\n";
+            exit 0;
+        } elsif ($exitcode != 104 && $exitcode != 0) {
+            print STDERR "deb-systemd-invoke only supports $policyhelper return codes 0, 101, and 104!\n";
+            print STDERR "Got return code $exitcode, ignoring.\n";
+        }
+    }
+}
+
+if (!$is_system) {
+    # '--machine <ID>@' was added in v250 and v249.10, before that we can't talk to arbitrary user instances
+    my $systemctl_version = `systemctl --version --quiet | sed -n -r "s/systemd ([0-9]+) \\(.*/\\1/p"`;
+    chomp ($systemctl_version);
+    if (system('dpkg', '--compare-versions', $systemctl_version, 'ge', '249') != 0) {
+            print STDERR "systemctl version $systemctl_version does not support acting on user instance, skipping\n";
+            exit 0;
+    }
+
+    # Each user instance of the manager has a corresponding user@<id<.service unit.
+    # Get the full list of IDs, so that we can talk to each user instance to start/stop
+    # user units.
+    @instances = `systemctl --no-legend --quiet list-units 'user@*' | sed -n -r 's/.*user@([0-9]+).service.*/\\1/p'`;
+} else {
+    push @instances, 'system';
+}
+
+# If the job is disabled and is not currently running, the job is not started or restarted.
+# However, if the job is disabled but has been forced into the running state, we *do* stop
+# and restart it since this is expected behaviour for the admin who forced the start.
+# We don't autostart static units either.
+if ($action eq "start" || $action eq "restart") {
+    my $global_exit_code = 0;
+    my @start_units = ();
+
+    for my $instance (@instances) {
+        my @instance_args = ();
+
+        if ($instance eq 'system') {
+            push @instance_args, '--system';
+        } else {
+            chomp ($instance);
+            push @instance_args, '--user', '--machine', "$instance@";
+        }
+
+        for my $unit (@units) {
+            my $unit_installed = 0;
+            my $enabled_output = `systemctl @instance_args is-enabled -- '$unit'`;
+            # matching enabled and enabled-runtime as an installed non static unit
+            if ($enabled_output =~ /enabled/) {
+                $unit_installed = 1;
+            }
+            system('systemctl', @instance_args, '--quiet', 'is-active', '--', $unit);
+            my $unit_active = $?>>8 == 0 ? 1 : 0;
+            if (!$unit_installed && $action eq "start") {
+                print STDERR "$unit is a disabled or a static unit, not starting it.\n";
+            } elsif (!$unit_installed && !$unit_active && $action eq "restart") {
+                print STDERR "$unit is a disabled or a static unit not running, not starting it.\n";
+            }
+            else {
+                push @start_units, $unit;
+            }
+        }
+        if (@start_units) {
+            system('systemctl', '--quiet', @instance_args, $action, @start_units) == 0 or die("Could not execute systemctl: $!");
+        }
+    }
+    exit(0);
+} elsif ($action eq "stop" && !$is_system) {
+    my $global_exit_code = 0;
+
+    for my $instance (@instances) {
+        chomp ($instance);
+        system('systemctl', '--quiet', '--user', '--machine', "$instance@", $action, @units);
+    }
+    exit(0);
+} else {
+    exec('systemctl', @ARGV);
+}
diff --git a/script/invoke-rc.d b/script/invoke-rc.d
new file mode 100755
index 0000000..ca1bdbe
--- /dev/null
+++ b/script/invoke-rc.d
@@ -0,0 +1,574 @@
+#!/bin/sh  
+# vim: ft=sh
+#
+# invoke-rc.d.sysvinit - Executes initscript actions
+#
+# SysVinit /etc/rc?.d version for Debian's sysvinit package
+#
+# Copyright (C) 2000,2001 Henrique de Moraes Holschuh <hmh@debian.org>
+#
+# This program is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by the Free
+# Software Foundation; either version 2 of the License, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+# or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
+
+# Constants
+RUNLEVELHELPER=/sbin/runlevel
+POLICYHELPER=$DPKG_ROOT/usr/sbin/policy-rc.d
+INITDPREFIX=/etc/init.d/
+RCDPREFIX=/etc/rc
+
+# Options
+BEQUIET=
+MODE=
+ACTION=
+FALLBACK=
+NOFALLBACK=
+FORCE=
+RETRY=
+RETURNFAILURE=
+RC=
+is_systemd=
+is_openrc=
+SKIP_SYSTEMD_NATIVE=
+
+# Shell options
+set +e
+
+dohelp () {
+ # 
+ # outputs help and usage
+ #
+cat <<EOF
+
+invoke-rc.d, Debian/SysVinit (/etc/rc?.d) initscript subsystem.
+Copyright (c) 2000,2001 Henrique de Moraes Holschuh <hmh@debian.org>
+
+Usage:
+  invoke-rc.d [options] <basename> <action> [extra parameters]
+
+  basename - Initscript ID, as per update-rc.d(8)
+  action   - Initscript action. Known actions are:
+                start, [force-]stop, [try-]restart,
+                [force-]reload, status
+  WARNING: not all initscripts implement all of the above actions.
+
+  extra parameters are passed as is to the initscript, following 
+  the action (first initscript parameter).
+
+Options:
+  --quiet
+     Quiet mode, no error messages are generated.
+  --force
+     Try to run the initscript regardless of policy and subsystem
+     non-fatal errors.
+  --try-anyway
+     Try to run init script even if a non-fatal error is found.
+  --disclose-deny
+     Return status code 101 instead of status code 0 if
+     initscript action is denied by local policy rules or
+     runlevel constrains.
+  --query
+     Returns one of status codes 100-106, does not run
+     the initscript. Implies --disclose-deny and --no-fallback.
+  --no-fallback
+     Ignores any fallback action requests by the policy layer.
+     Warning: this is usually a very *bad* idea for any actions
+     other than "start".
+  --skip-systemd-native
+    Exits before doing anything if a systemd environment is detected
+    and the requested service is a native systemd unit.
+    This is useful for maintainer scripts that want to defer systemd
+    actions to deb-systemd-invoke
+  --help
+     Outputs help message to stdout
+
+EOF
+}
+
+printerror () {
+ #
+ # prints an error message
+ #  $* - error message
+ #
+if test x${BEQUIET} = x ; then
+    echo `basename $0`: "$*" >&2
+fi
+}
+
+formataction () {
+ #
+ # formats a list in $* into $printaction
+ # for human-friendly printing to stderr
+ # and sets $naction to action or actions
+ #
+printaction=`echo $* | sed 's/ /, /g'`
+if test $# -eq 1 ; then
+    naction=action
+else
+    naction=actions
+fi
+}
+
+querypolicy () {
+ #
+ # queries policy database
+ # returns: $RC = 104 - ok, run
+ #          $RC = 101 - ok, do not run
+ #        other - exit with status $RC, maybe run if $RETRY
+ #          initial status of $RC is taken into account.
+ #
+
+policyaction="${ACTION}"
+if test x${RC} = "x101" ; then
+    if test "${ACTION}" = "start" || test "${ACTION}" = "restart" || test "${ACTION}" = "try-restart"; then
+	policyaction="(${ACTION})"
+    fi
+fi
+
+if test "x${POLICYHELPER}" != x && test -x "${POLICYHELPER}" ; then
+    FALLBACK=`${POLICYHELPER} ${BEQUIET} ${INITSCRIPTID} "${policyaction}" ${RL}`
+    RC=$?
+    formataction ${ACTION}
+    case ${RC} in
+	0)   RC=104
+	     ;;
+	1)   RC=105
+	     ;;
+	101) if test x${FORCE} != x ; then
+		printerror Overriding policy-rc.d denied execution of ${printaction}.
+		RC=104
+	     else
+		printerror policy-rc.d denied execution of ${printaction}.
+	     fi
+	     ;;
+    esac
+    if test x${MODE} != xquery ; then
+      case ${RC} in
+	105) printerror policy-rc.d query returned \"behaviour undefined\",
+	     printerror assuming \"${printaction}\" is allowed.
+	     RC=104
+	     ;;
+	106) formataction ${FALLBACK}
+	     if test x${FORCE} = x ; then
+		 if test x${NOFALLBACK} = x ; then
+		     ACTION="${FALLBACK}"
+		     printerror executing ${naction} \"${printaction}\" instead due to policy-rc.d request.
+		     RC=104
+		 else
+		     printerror ignoring policy-rc.d fallback request: ${printaction}.
+		     RC=101
+		 fi
+	     else
+		 printerror ignoring policy-rc.d fallback request: ${printaction}.
+		 RC=104
+	     fi
+	     ;;
+      esac
+    fi
+    case ${RC} in
+      100|101|102|103|104|105|106) ;;
+      *) printerror WARNING: policy-rc.d returned unexpected error status ${RC}, 102 used instead.
+         RC=102
+	 ;;
+    esac
+else
+    if test ! -e "/sbin/init" ; then
+        if test x${FORCE} != x ; then
+            printerror "WARNING: No init system and policy-rc.d missing, but force specified so proceeding."
+        else
+            printerror "WARNING: No init system and policy-rc.d missing! Defaulting to block."
+            RC=101
+        fi
+    fi
+
+    if test x${RC} = x ; then 
+	RC=104
+    fi
+fi
+return
+}
+
+verifyparameter () {
+ #
+ # Verifies if $1 is not null, and $# = 1
+ #
+if test $# -eq 0 ; then
+    printerror syntax error: invalid empty parameter
+    exit 103
+elif test $# -ne 1 ; then
+    printerror syntax error: embedded blanks are not allowed in \"$*\"
+    exit 103
+fi
+return
+}
+
+##
+##  main
+##
+
+## Verifies command line arguments
+
+if test $# -eq 0 ; then
+  printerror syntax error: missing required parameter, --help assumed
+  dohelp
+  exit 103
+fi
+
+state=I
+while test $# -gt 0 && test ${state} != III ; do
+    case "$1" in
+      --help)   dohelp 
+		exit 0
+		;;
+      --quiet)  BEQUIET=--quiet
+		;;
+      --force)  FORCE=yes
+		RETRY=yes
+		;;
+      --try-anyway)
+	        RETRY=yes
+		;;
+      --disclose-deny)
+		RETURNFAILURE=yes
+		;;
+      --query)  MODE=query
+		RETURNFAILURE=yes
+		;;
+      --no-fallback)
+		NOFALLBACK=yes
+        ;;
+      --skip-systemd-native) SKIP_SYSTEMD_NATIVE=yes
+		;;
+      --*)	printerror syntax error: unknown option \"$1\"
+		exit 103
+		;;
+	*)      case ${state} in
+		I)  verifyparameter $1
+		    INITSCRIPTID=$1
+		    ;;
+		II) verifyparameter $1
+		    ACTION=$1
+		    ;;
+		esac
+		state=${state}I
+		;;
+    esac
+    shift
+done
+
+if test ${state} != III ; then
+    printerror syntax error: missing required parameter
+    exit 103
+fi
+
+#NOTE: It may not be obvious, but "$@" from this point on must expand
+#to the extra initscript parameters, except inside functions.
+
+if test -d /run/systemd/system ; then
+    is_systemd=1
+    UNIT="${INITSCRIPTID%.sh}.service"
+elif test -f /run/openrc/softlevel ; then
+    is_openrc=1
+elif test ! -f "${INITDPREFIX}${INITSCRIPTID}" ; then
+    ## Verifies if the given initscript ID is known
+    ## For sysvinit, this error is critical
+    printerror unknown initscript, ${INITDPREFIX}${INITSCRIPTID} not found.
+fi
+
+## Queries sysvinit for the current runlevel
+if [ ! -x ${RUNLEVELHELPER} ] || ! RL=`${RUNLEVELHELPER}`; then
+    if [ -n "$is_systemd" ] && systemctl is-active --quiet sysinit.target; then
+        # under systemd, the [2345] runlevels are only set upon reaching them;
+        # if we are past sysinit.target (roughly equivalent to rcS), consider
+        # this as runlevel 5 (this is only being used for validating rcN.d
+        # symlinks, so the precise value does not matter much)
+        RL=5
+    else
+        printerror "could not determine current runlevel"
+        # this usually fails in schroots etc., ignore failure (#823611)
+        RL=
+    fi
+fi
+# strip off previous runlevel
+RL=${RL#* }
+
+## Running ${RUNLEVELHELPER} to get current runlevel do not work in
+## the boot runlevel (scripts in /etc/rcS.d/), as /var/run/utmp
+## contains runlevel 0 or 6 (written at shutdown) at that point.
+if test x${RL} = x0 || test x${RL} = x6 ; then
+    if ps -fp 1 | grep -q 'init boot' ; then
+       RL=S
+    fi
+fi
+
+## Handles shutdown sequences VERY safely
+## i.e.: forget about policy, and do all we can to run the script.
+## BTW, why the heck are we being run in a shutdown runlevel?!
+if test x${RL} = x0 || test x${RL} = x6 ; then
+    FORCE=yes
+    RETRY=yes
+    POLICYHELPER=
+    BEQUIET=
+    printerror "-----------------------------------------------------"
+    printerror "WARNING: 'invoke-rc.d ${INITSCRIPTID} ${ACTION}' called"
+    printerror "during shutdown sequence."
+    printerror "enabling safe mode: initscript policy layer disabled"
+    printerror "-----------------------------------------------------"
+fi
+
+## Verifies the existance of proper S??initscriptID and K??initscriptID 
+## *links* in the proper /etc/rc?.d/ directory
+verifyrclink () {
+  #
+  # verifies if parameters are non-dangling symlinks
+  # all parameters are verified
+  #
+  doexit=
+  while test $# -gt 0 ; do
+    if test ! -L "$1" ; then
+        printerror not a symlink: $1
+        doexit=102
+    fi
+    if test ! -f "$1" ; then
+        printerror dangling symlink: $1
+        doexit=102
+    fi
+    shift
+  done
+  if test x${doexit} != x && test x${RETRY} = x; then
+     exit ${doexit}
+  fi
+  return 0
+}
+
+testexec () {
+  #
+  # returns true if any of the parameters is
+  # executable (after following links)
+  #
+  while test $# -gt 0 ; do
+    if test -x "$1" ; then
+       return 0
+    fi
+    shift
+  done
+  return 1
+}
+
+RC=
+
+###
+### LOCAL POLICY: Enforce that the script/unit is enabled. For SysV init
+### scripts, this needs a start entry in either runlevel S or current runlevel
+### to allow start or restart.
+if [ -n "$is_systemd" ]; then
+    case ${ACTION} in
+        start|restart|try-restart)
+            # If a package ships both init script and systemd service file, the
+            # systemd unit will not be enabled by the time invoke-rc.d is called
+            # (with current debhelper sequence). This would make systemctl is-enabled
+            # report the wrong status, and then the service would not be started.
+            # This check cannot be removed as long as we support not passing --skip-systemd-native
+
+            if systemctl --quiet is-enabled "${UNIT}" 2>/dev/null || \
+               ls ${RCDPREFIX}[S2345].d/S[0-9][0-9]${INITSCRIPTID} >/dev/null 2>&1; then
+                RC=104
+            elif systemctl --quiet is-active "${UNIT}" 2>/dev/null; then
+                RC=104
+            else
+                RC=101
+            fi
+            ;;
+    esac
+else
+    # we do handle multiple links per runlevel
+    # but we don't handle embedded blanks in link names :-(
+    if test x${RL} != x ; then
+	SLINK=`ls -d -Q ${RCDPREFIX}${RL}.d/S[0-9][0-9]${INITSCRIPTID} 2>/dev/null | xargs`
+	KLINK=`ls -d -Q ${RCDPREFIX}${RL}.d/K[0-9][0-9]${INITSCRIPTID} 2>/dev/null | xargs`
+	SSLINK=`ls -d -Q ${RCDPREFIX}S.d/S[0-9][0-9]${INITSCRIPTID} 2>/dev/null | xargs`
+
+	verifyrclink ${SLINK} ${KLINK} ${SSLINK}
+    fi
+
+    case ${ACTION} in
+      start|restart|try-restart)
+	if testexec ${SLINK} ; then
+	    RC=104
+	elif testexec ${KLINK} ; then
+	    RC=101
+	elif testexec ${SSLINK} ; then
+	    RC=104
+	else
+	    RC=101
+	fi
+      ;;
+    esac
+fi
+
+# test if /etc/init.d/initscript is actually executable
+_executable=
+if [ -n "$is_systemd" ]; then
+    _executable=1
+elif testexec "${INITDPREFIX}${INITSCRIPTID}"; then
+    _executable=1
+fi
+if [ "$_executable" = "1" ]; then
+    if test x${RC} = x && test x${MODE} = xquery ; then
+        RC=105
+    fi
+
+    # call policy layer
+    querypolicy
+    case ${RC} in
+        101|104)
+           ;;
+        *) if test x${MODE} != xquery ; then
+	       printerror policy-rc.d returned error status ${RC}
+	       if test x${RETRY} = x ; then
+	           exit ${RC}
+               else
+    	           RC=102
+    	       fi
+           fi
+           ;;
+    esac
+else
+    ###
+    ### LOCAL INITSCRIPT POLICY: non-executable initscript; deny exec.
+    ### (this is common sense, actually :^P )
+    ###
+    RC=101
+fi
+
+## Handles --query
+if test x${MODE} = xquery ; then
+    exit ${RC}
+fi
+
+
+setechoactions () {
+    if test $# -gt 1 ; then
+	echoaction=true
+    else
+	echoaction=
+    fi
+}
+getnextaction () {
+    saction=$1
+    shift
+    ACTION="$@"
+}
+
+## Executes initscript
+## note that $ACTION is a space-separated list of actions
+## to be attempted in order until one suceeds.
+if test x${FORCE} != x || test ${RC} -eq 104 ; then
+    if [ -n "$is_systemd" ] || testexec "${INITDPREFIX}${INITSCRIPTID}" ; then
+	RC=102
+	setechoactions ${ACTION}
+	while test ! -z "${ACTION}" ; do
+	    getnextaction ${ACTION}
+	    if test ! -z ${echoaction} ; then
+		printerror executing initscript action \"${saction}\"...
+	    fi
+
+            if [ -n "$is_systemd" ]; then
+                if [ "$SKIP_SYSTEMD_NATIVE" = yes ] ; then
+                    case $(systemctl show --value --property SourcePath "${UNIT}") in
+                    /etc/init.d/*)
+                        ;;
+                    *)
+                        # We were asked to skip native systemd units, and this one was not generated by the sysv generator
+                        # exit cleanly
+                        exit 0
+                        ;;
+                    esac
+
+                fi
+                _state=$(systemctl -p LoadState show "${UNIT}" 2>/dev/null)
+
+                case $saction in
+                    start|restart|try-restart)
+                        [ "$_state" != "LoadState=masked" ] || exit 0
+                        systemctl $sctl_args "${saction}" "${UNIT}" && exit 0
+                        ;;
+                    stop|status)
+                        systemctl $sctl_args "${saction}" "${UNIT}" && exit 0
+                        ;;
+                    reload)
+                        [ "$_state" != "LoadState=masked" ] || exit 0
+                        _canreload="$(systemctl -p CanReload show ${UNIT} 2>/dev/null)"
+                        # Don't block on reload requests during bootup and shutdown
+                        # from units/hooks and simply schedule the task.
+                        if ! systemctl --quiet is-system-running; then
+                            sctl_args="--no-block"
+                        fi
+                        if [ "$_canreload" = "CanReload=no" ]; then
+                            "${INITDPREFIX}${INITSCRIPTID}" "${saction}" "$@" && exit 0
+                        else
+                            systemctl $sctl_args reload "${UNIT}" && exit 0
+                        fi
+                        ;;
+                    force-stop)
+                        systemctl --signal=KILL kill "${UNIT}" && exit 0
+                        ;;
+                    force-reload)
+                        [ "$_state" != "LoadState=masked" ] || exit 0
+                        _canreload="$(systemctl -p CanReload show ${UNIT} 2>/dev/null)"
+                        if [ "$_canreload" = "CanReload=no" ]; then
+                           systemctl $sctl_args restart "${UNIT}" && exit 0
+                        else
+                           systemctl $sctl_args reload "${UNIT}" && exit 0
+                        fi
+                        ;;
+                    *)
+                        # We try to run non-standard actions by running
+                        # the init script directly.
+                        "${INITDPREFIX}${INITSCRIPTID}" "${saction}" "$@" && exit 0
+                        ;;
+                esac
+	    elif [ -n "$is_openrc" ]; then
+		rc-service "${INITSCRIPTID}" "${saction}" && exit 0
+	    else
+		"${INITDPREFIX}${INITSCRIPTID}" "${saction}" "$@" && exit 0
+	    fi
+	    RC=$?
+
+	    if test ! -z "${ACTION}" ; then
+		printerror action \"${saction}\" failed, trying next action...
+	    fi
+	done
+	printerror initscript ${INITSCRIPTID}, action \"${saction}\" failed.
+	if [ -n "$is_systemd" ] && [ "$saction" = start -o "$saction" = restart -o "$saction" = "try-restart" ]; then
+	    systemctl status --full --no-pager "${UNIT}" || true
+	fi
+	exit ${RC}
+    fi
+    exit 102
+fi
+
+## Handles --disclose-deny and denied "status" action (bug #381497)
+if test ${RC} -eq 101 && test x${RETURNFAILURE} = x ; then
+    if test "x${ACTION%% *}" = "xstatus"; then
+	printerror emulating initscript action \"status\", returning \"unknown\"
+	RC=4
+    else
+        RC=0
+    fi
+else
+    formataction ${ACTION}
+    printerror initscript ${naction} \"${printaction}\" not executed.
+fi
+
+exit ${RC}
diff --git a/script/service b/script/service
new file mode 100755
index 0000000..08f69bb
--- /dev/null
+++ b/script/service
@@ -0,0 +1,217 @@
+#!/bin/sh
+
+###########################################################################
+# /usr/bin/service
+#
+# A convenient wrapper for the /etc/init.d init scripts.
+#
+# This script is a modified version of the /sbin/service utility found on
+# Red Hat/Fedora systems (licensed GPLv2+).
+#
+# Copyright (C) 2006 Red Hat, Inc. All rights reserved.
+# Copyright (C) 2008 Canonical Ltd.
+#   * August 2008 - Dustin Kirkland <kirkland@canonical.com>
+# Copyright (C) 2013 Michael Stapelberg <stapelberg@debian.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+# On Debian GNU/Linux systems, the complete text of the GNU General
+# Public License can be found in `/usr/share/common-licenses/GPL-2'.
+###########################################################################
+
+
+is_ignored_file() {
+	case "$1" in
+		skeleton | README | *.dpkg-dist | *.dpkg-old | rc | rcS | single | reboot | bootclean.sh)
+			return 0
+		;;
+	esac
+	return 1
+}
+
+VERSION="`basename $0` ver. __VERSION__"
+USAGE="Usage: `basename $0` < option > | --status-all | \
+[ service_name [ command | --full-restart ] ]"
+SERVICE=
+ACTION=
+SERVICEDIR="/etc/init.d"
+OPTIONS=
+is_systemd=
+
+
+if [ $# -eq 0 ]; then
+   echo "${USAGE}" >&2
+   exit 1
+fi
+
+if [ -d /run/systemd/system ]; then
+   is_systemd=1
+fi
+
+cd /
+while [ $# -gt 0 ]; do
+  case "${1}" in
+    --help | -h | --h* )
+       echo "${USAGE}" >&2
+       exit 0
+       ;;
+    --version | -V )
+       echo "${VERSION}" >&2
+       exit 0
+       ;;
+    *)
+       if [ -z "${SERVICE}" -a $# -eq 1 -a "${1}" = "--status-all" ]; then
+          cd ${SERVICEDIR}
+          for SERVICE in * ; do
+            case "${SERVICE}" in
+              functions | halt | killall | single| linuxconf| kudzu)
+                  ;;
+              *)
+                if ! is_ignored_file "${SERVICE}" \
+		    && [ -x "${SERVICEDIR}/${SERVICE}" ]; then
+                        out=$(env -i LANG="$LANG" LANGUAGE="$LANGUAGE" LC_CTYPE="$LC_CTYPE" LC_NUMERIC="$LC_NUMERIC" LC_TIME="$LC_TIME" LC_COLLATE="$LC_COLLATE" LC_MONETARY="$LC_MONETARY" LC_MESSAGES="$LC_MESSAGES" LC_PAPER="$LC_PAPER" LC_NAME="$LC_NAME" LC_ADDRESS="$LC_ADDRESS" LC_TELEPHONE="$LC_TELEPHONE" LC_MEASUREMENT="$LC_MEASUREMENT" LC_IDENTIFICATION="$LC_IDENTIFICATION" LC_ALL="$LC_ALL" PATH="$PATH" TERM="$TERM" "$SERVICEDIR/$SERVICE" status 2>&1)
+                        retval=$?
+                        if echo "$out" | grep -Fiq "usage:"; then
+                          #printf " %s %-60s %s\n" "[?]" "$SERVICE:" "unknown" 1>&2
+                          echo " [ ? ]  $SERVICE" 1>&2
+                          continue
+                        else
+                          if [ "$retval" = "0" -a -n "$out" ]; then
+                            #printf " %s %-60s %s\n" "[+]" "$SERVICE:" "running"
+                            echo " [ + ]  $SERVICE"
+                            continue
+                          else
+                            #printf " %s %-60s %s\n" "[-]" "$SERVICE:" "NOT running"
+                            echo " [ - ]  $SERVICE"
+                            continue
+                          fi
+                        fi
+                  #env -i LANG="$LANG" LANGUAGE="$LANGUAGE" LC_CTYPE="$LC_CTYPE" LC_NUMERIC="$LC_NUMERIC" LC_TIME="$LC_TIME" LC_COLLATE="$LC_COLLATE" LC_MONETARY="$LC_MONETARY" LC_MESSAGES="$LC_MESSAGES" LC_PAPER="$LC_PAPER" LC_NAME="$LC_NAME" LC_ADDRESS="$LC_ADDRESS" LC_TELEPHONE="$LC_TELEPHONE" LC_MEASUREMENT="$LC_MEASUREMENT" LC_IDENTIFICATION="$LC_IDENTIFICATION" LC_ALL="$LC_ALL" PATH="$PATH" TERM="$TERM" "$SERVICEDIR/$SERVICE" status
+                fi
+                ;;
+            esac
+          done
+          exit 0
+       elif [ $# -eq 2 -a "${2}" = "--full-restart" ]; then
+          SERVICE="${1}"
+          # On systems using systemd, we just perform a normal restart:
+          # A restart with systemd is already a full restart.
+          if [ -n "$is_systemd" ]; then
+             ACTION="restart"
+          else
+             if [ -x "${SERVICEDIR}/${SERVICE}" ]; then
+               env -i LANG="$LANG" LANGUAGE="$LANGUAGE" LC_CTYPE="$LC_CTYPE" LC_NUMERIC="$LC_NUMERIC" LC_TIME="$LC_TIME" LC_COLLATE="$LC_COLLATE" LC_MONETARY="$LC_MONETARY" LC_MESSAGES="$LC_MESSAGES" LC_PAPER="$LC_PAPER" LC_NAME="$LC_NAME" LC_ADDRESS="$LC_ADDRESS" LC_TELEPHONE="$LC_TELEPHONE" LC_MEASUREMENT="$LC_MEASUREMENT" LC_IDENTIFICATION="$LC_IDENTIFICATION" LC_ALL="$LC_ALL" PATH="$PATH" TERM="$TERM" "$SERVICEDIR/$SERVICE" stop
+               env -i LANG="$LANG" LANGUAGE="$LANGUAGE" LC_CTYPE="$LC_CTYPE" LC_NUMERIC="$LC_NUMERIC" LC_TIME="$LC_TIME" LC_COLLATE="$LC_COLLATE" LC_MONETARY="$LC_MONETARY" LC_MESSAGES="$LC_MESSAGES" LC_PAPER="$LC_PAPER" LC_NAME="$LC_NAME" LC_ADDRESS="$LC_ADDRESS" LC_TELEPHONE="$LC_TELEPHONE" LC_MEASUREMENT="$LC_MEASUREMENT" LC_IDENTIFICATION="$LC_IDENTIFICATION" LC_ALL="$LC_ALL" PATH="$PATH" TERM="$TERM" "$SERVICEDIR/$SERVICE" start
+               exit $?
+             fi
+          fi
+       elif [ -z "${SERVICE}" ]; then
+         SERVICE="${1}"
+       elif [ -z "${ACTION}" ]; then
+         ACTION="${1}"
+       else
+         OPTIONS="${OPTIONS} ${1}"
+       fi
+       shift
+       ;;
+   esac
+done
+
+run_via_sysvinit() {
+   # Otherwise, use the traditional sysvinit
+   if [ -x "${SERVICEDIR}/${SERVICE}" ]; then
+      exec env -i LANG="$LANG" LANGUAGE="$LANGUAGE" LC_CTYPE="$LC_CTYPE" LC_NUMERIC="$LC_NUMERIC" LC_TIME="$LC_TIME" LC_COLLATE="$LC_COLLATE" LC_MONETARY="$LC_MONETARY" LC_MESSAGES="$LC_MESSAGES" LC_PAPER="$LC_PAPER" LC_NAME="$LC_NAME" LC_ADDRESS="$LC_ADDRESS" LC_TELEPHONE="$LC_TELEPHONE" LC_MEASUREMENT="$LC_MEASUREMENT" LC_IDENTIFICATION="$LC_IDENTIFICATION" LC_ALL="$LC_ALL" PATH="$PATH" TERM="$TERM" "$SERVICEDIR/$SERVICE" ${ACTION} ${OPTIONS}
+   else
+      echo "${SERVICE}: unrecognized service" >&2
+      exit 1
+   fi
+}
+
+update_openrc_started_symlinks() {
+   # maintain the symlinks of /run/openrc/started so that
+   # rc-status works with the service command as well
+   if [ -d /run/openrc/started ] ; then
+      case "${ACTION}" in
+      start)
+         if [ ! -h /run/openrc/started/$SERVICE ] ; then
+            ln -s $SERVICEDIR/$SERVICE /run/openrc/started/$SERVICE || true
+         fi
+      ;;
+      stop)
+         rm /run/openrc/started/$SERVICE || true
+      ;;
+      esac
+   fi
+}
+
+# When this machine is running systemd, standard service calls are turned into
+# systemctl calls.
+if [ -n "$is_systemd" ]
+then
+   UNIT="${SERVICE%.sh}.service"
+
+   case "${ACTION}" in
+      restart|status|try-restart)
+         exec systemctl $sctl_args ${ACTION} ${UNIT}
+      ;;
+      start|stop)
+         # Follow the principle of least surprise for SysV people:
+         # When running "service foo stop" and foo happens to be a service that
+         # has one or more .socket files, we also stop the .socket units.
+         # Users who need more control will use systemctl directly.
+         for unit in $(systemctl list-unit-files --full --type=socket 2>/dev/null | sed -ne 's/\.socket\s*[a-z]*\s*$/.socket/p'); do
+             if [ "$(systemctl -p Triggers show $unit)" = "Triggers=${UNIT}" ]; then
+                systemctl $sctl_args ${ACTION} $unit
+             fi
+         done
+         exec systemctl $sctl_args ${ACTION} ${UNIT}
+      ;;
+      reload)
+         _canreload="$(systemctl -p CanReload show ${UNIT} 2>/dev/null)"
+         # Don't block on reload requests during bootup and shutdown
+         # from units/hooks and simply schedule the task.
+         if ! systemctl --quiet is-system-running; then
+              sctl_args="--no-block"
+         fi
+         if [ "$_canreload" = "CanReload=no" ]; then
+            # The reload action falls back to the sysv init script just in case
+            # the systemd service file does not (yet) support reload for a
+            # specific service.
+            run_via_sysvinit
+         else
+            exec systemctl $sctl_args reload "${UNIT}"
+         fi
+         ;;
+      force-stop)
+         exec systemctl --signal=KILL kill "${UNIT}"
+         ;;
+      force-reload)
+         _canreload="$(systemctl -p CanReload show ${UNIT} 2>/dev/null)"
+         if [ "$_canreload" = "CanReload=no" ]; then
+            exec systemctl $sctl_args restart "${UNIT}"
+         else
+            exec systemctl $sctl_args reload "${UNIT}"
+         fi
+         ;;
+      *)
+         # We try to run non-standard actions by running
+         # the init script directly.
+         run_via_sysvinit
+         ;;
+   esac
+fi
+
+update_openrc_started_symlinks
+run_via_sysvinit
diff --git a/script/update-rc.d b/script/update-rc.d
new file mode 100755
index 0000000..1ad3e4a
--- /dev/null
+++ b/script/update-rc.d
@@ -0,0 +1,536 @@
+#! /usr/bin/perl
+# vim: ft=perl
+#
+# update-rc.d	Update the links in /etc/rc[0-9S].d/
+#
+
+use strict;
+use warnings;
+# NB: All Perl modules used here must be in perl-base. Specifically, depending
+# on modules in perl-modules is not okay! See bug #716923
+
+my $initd = "/etc/init.d";
+my $etcd  = "/etc/rc";
+my $dpkg_root = $ENV{DPKG_ROOT} // '';
+
+# Print usage message and die.
+
+sub usage {
+	print STDERR "update-rc.d: error: @_\n" if ($#_ >= 0);
+	print STDERR <<EOF;
+usage: update-rc.d [-f] <basename> remove
+       update-rc.d [-f] <basename> defaults
+       update-rc.d [-f] <basename> defaults-disabled
+       update-rc.d <basename> disable|enable [S|2|3|4|5]
+		-f: force
+
+The disable|enable API is not stable and might change in the future.
+EOF
+	exit (1);
+}
+
+exit main(@ARGV);
+
+sub info {
+    print STDOUT "update-rc.d: @_\n";
+}
+
+sub warning {
+    print STDERR "update-rc.d: warning: @_\n";
+}
+
+sub error {
+    print STDERR "update-rc.d: error: @_\n";
+    exit (1);
+}
+
+sub error_code {
+    my $rc = shift;
+    print STDERR "update-rc.d: error: @_\n";
+    exit ($rc);
+}
+
+sub make_path {
+    my ($path) = @_;
+    my @dirs = ();
+    my @path = split /\//, $path;
+    map { push @dirs, $_; mkdir join('/', @dirs), 0755; } @path;
+}
+
+# Given a script name, return any runlevels except 0 or 6 in which the
+# script is enabled.  If that gives nothing and the script is not
+# explicitly disabled, return 6 if the script is disabled in runlevel
+# 0 or 6.
+sub script_runlevels {
+    my ($scriptname) = @_;
+    my @links=<"$dpkg_root/etc/rc[S12345].d/S[0-9][0-9]$scriptname">;
+    if (@links) {
+        return map(substr($_, 7, 1), @links);
+    } elsif (! <"$dpkg_root/etc/rc[S12345].d/K[0-9][0-9]$scriptname">) {
+        @links=<"$dpkg_root/etc/rc[06].d/K[0-9][0-9]$scriptname">;
+        return ("6") if (@links);
+    } else {
+	return ;
+    }
+}
+
+# Map the sysvinit runlevel to that of openrc.
+sub openrc_rlconv {
+    my %rl_table = (
+        "S" => "sysinit",
+        "1" => "recovery",
+        "2" => "default",
+        "3" => "default",
+        "4" => "default",
+        "5" => "default",
+        "6" => "off" );
+
+    my %seen; # return unique runlevels
+    return grep !$seen{$_}++, map($rl_table{$_}, @_);
+}
+
+sub systemd_reload {
+    if (length $ENV{DPKG_ROOT}) {
+	# if we operate on a chroot from the outside, do not attempt to reload
+	return;
+    }
+    if (-d "/run/systemd/system") {
+        system("systemctl", "daemon-reload");
+    }
+}
+
+# Creates the necessary links to enable/disable a SysV init script (fallback if
+# no insserv/rc-update exists)
+sub make_sysv_links {
+    my ($scriptname, $action) = @_;
+
+    # for "remove" we cannot rely on the init script still being present, as
+    # this gets called in postrm for purging. Just remove all symlinks.
+    if ("remove" eq $action) { unlink($_) for
+        glob("$dpkg_root/etc/rc?.d/[SK][0-9][0-9]$scriptname"); return; }
+
+    # if the service already has any links, do not touch them
+    # numbers we don't care about, but enabled/disabled state we do
+    return if glob("$dpkg_root/etc/rc?.d/[SK][0-9][0-9]$scriptname");
+
+    # for "defaults", parse Default-{Start,Stop} and create these links
+    my ($lsb_start_ref, $lsb_stop_ref) = parse_def_start_stop("$dpkg_root/etc/init.d/$scriptname");
+    my $start = $action eq "defaults-disabled" ? "K" : "S";
+    foreach my $lvl (@$lsb_start_ref) {
+        make_path("$dpkg_root/etc/rc$lvl.d");
+        my $l = "$dpkg_root/etc/rc$lvl.d/${start}01$scriptname";
+        symlink("../init.d/$scriptname", $l);
+    }
+
+    foreach my $lvl (@$lsb_stop_ref) {
+        make_path("$dpkg_root/etc/rc$lvl.d");
+        my $l = "$dpkg_root/etc/rc$lvl.d/K01$scriptname";
+        symlink("../init.d/$scriptname", $l);
+    }
+}
+
+# Creates the necessary links to enable/disable the service (equivalent of an
+# initscript) in systemd.
+sub make_systemd_links {
+    my ($scriptname, $action) = @_;
+
+    # If called by systemctl (via systemd-sysv-install), do nothing to avoid
+    # an endless loop.
+    if (defined($ENV{_SKIP_SYSTEMD_NATIVE}) && $ENV{_SKIP_SYSTEMD_NATIVE} == 1) {
+        return;
+    }
+
+    # If systemctl is available, let's use that to create the symlinks.
+    if (-x "/bin/systemctl" || -x "/usr/bin/systemctl") {
+        my $systemd_root = '/';
+        if ($dpkg_root ne '') {
+            $systemd_root = $dpkg_root;
+        }
+        # Set this env var to avoid loop in systemd-sysv-install.
+        local $ENV{SYSTEMCTL_SKIP_SYSV} = 1;
+        # Use --quiet to mimic the old update-rc.d behaviour.
+        system("systemctl", "--root=$systemd_root", "--quiet", "$action", "$scriptname");
+        return;
+    }
+
+    # In addition to the insserv call we also enable/disable the service
+    # for systemd by creating the appropriate symlink in case there is a
+    # native systemd service. In case systemd is not installed we do this
+    # on our own instead of using systemctl.
+    my $service_path;
+    if (-f "/etc/systemd/system/$scriptname.service") {
+        $service_path = "/etc/systemd/system/$scriptname.service";
+    } elsif (-f "/lib/systemd/system/$scriptname.service") {
+        $service_path = "/lib/systemd/system/$scriptname.service";
+    } elsif (-f "/usr/lib/systemd/system/$scriptname.service") {
+        $service_path = "/usr/lib/systemd/system/$scriptname.service";
+    }
+    if (defined($service_path)) {
+        my $changed_sth;
+        open my $fh, '<', $service_path or error("unable to read $service_path");
+        while (<$fh>) {
+            chomp;
+            if (/^\s*WantedBy=(.+)$/i) {
+                my $wants_dir = "/etc/systemd/system/$1.wants";
+                my $service_link = "$wants_dir/$scriptname.service";
+                if ("enable" eq $action) {
+                    make_path($wants_dir);
+                    symlink($service_path, $service_link);
+                } else {
+                    unlink($service_link) if -e $service_link;
+                }
+            }
+        }
+        close($fh);
+    }
+}
+
+sub create_sequence {
+    my $force = (@_);
+    my $insserv = "/usr/lib/insserv/insserv";
+    # Fallback for older insserv package versions [2014-04-16]
+    $insserv = "/sbin/insserv" if ( -x "/sbin/insserv");
+    # If insserv is not configured it is not fully installed
+    my $insserv_installed = -x $insserv && -e "/etc/insserv.conf";
+    my @opts;
+    push(@opts, '-f') if $force;
+    # Add force flag if initscripts is not installed
+    # This enables inistcripts-less systems to not fail when a facility is missing
+    unshift(@opts, '-f') unless is_initscripts_installed();
+
+    my $openrc_installed = -x "/sbin/openrc";
+
+    my $sysv_insserv ={};
+    $sysv_insserv->{remove} = sub {
+        my ($scriptname) = @_;
+        if ( -f "/etc/init.d/$scriptname" ) {
+            return system($insserv, @opts, "-r", $scriptname) >> 8;
+        } else {
+            # insserv removes all dangling symlinks, no need to tell it
+            # what to look for.
+            my $rc = system($insserv, @opts) >> 8;
+            error_code($rc, "insserv rejected the script header") if $rc;
+        }
+    };
+    $sysv_insserv->{defaults} = sub {
+        my ($scriptname) = @_;
+        if ( -f "/etc/init.d/$scriptname" ) {
+            my $rc = system($insserv, @opts, $scriptname) >> 8;
+            error_code($rc, "insserv rejected the script header") if $rc;
+        } else {
+            error("initscript does not exist: /etc/init.d/$scriptname");
+        }
+    };
+    $sysv_insserv->{defaults_disabled} = sub {
+        my ($scriptname) = @_;
+        return if glob("/etc/rc?.d/[SK][0-9][0-9]$scriptname");
+        if ( -f "/etc/init.d/$scriptname" ) {
+            my $rc = system($insserv, @opts, $scriptname) >> 8;
+            error_code($rc, "insserv rejected the script header") if $rc;
+        } else {
+            error("initscript does not exist: /etc/init.d/$scriptname");
+        }
+        sysv_toggle("disable", $scriptname);
+    };
+    $sysv_insserv->{toggle} = sub {
+        my ($action, $scriptname) = (shift, shift);
+        sysv_toggle($action, $scriptname, @_);
+
+        # Call insserv to resequence modified links
+        my $rc = system($insserv, @opts, $scriptname) >> 8;
+        error_code($rc, "insserv rejected the script header") if $rc;
+    };
+
+    my $sysv_plain = {};
+    $sysv_plain->{remove} = sub {
+        my ($scriptname) = @_;
+        make_sysv_links($scriptname, "remove");
+    };
+    $sysv_plain->{defaults} = sub {
+        my ($scriptname) = @_;
+        make_sysv_links($scriptname, "defaults");
+    };
+    $sysv_plain->{defaults_disabled} = sub {
+        my ($scriptname) = @_;
+        make_sysv_links($scriptname, "defaults-disabled");
+    };
+    $sysv_plain->{toggle} = sub {
+        my ($action, $scriptname) = (shift, shift);
+        sysv_toggle($action, $scriptname, @_);
+    };
+
+    my $systemd = {};
+    $systemd->{remove} = sub {
+        systemd_reload;
+    };
+    $systemd->{defaults} = sub {
+        systemd_reload;
+    };
+    $systemd->{defaults_disabled} = sub {
+        systemd_reload;
+    };
+    $systemd->{toggle} = sub {
+        my ($action, $scriptname) = (shift, shift);
+        make_systemd_links($scriptname, $action);
+        systemd_reload;
+    };
+
+    # Should we check exit codeS?
+    my $openrc = {};
+    $openrc->{remove} = sub {
+        my ($scriptname) = @_;
+        system("rc-update", "-qqa", "delete", $scriptname);
+
+    };
+    $openrc->{defaults} = sub {
+        my ($scriptname) = @_;
+        # OpenRC does not distinguish halt and reboot.  They are handled
+        # by /etc/init.d/transit instead.
+        return if ("halt" eq $scriptname || "reboot" eq $scriptname);
+        # no need to consider default disabled runlevels
+        # because everything is disabled by openrc by default
+        my @rls=script_runlevels($scriptname);
+        if ( @rls ) {
+            system("rc-update", "add", $scriptname, openrc_rlconv(@rls));
+        }
+    };
+    $openrc->{defaults_disabled} = sub {
+        # In openrc everything is disabled by default
+    };
+    $openrc->{toggle} = sub {
+        my ($action, $scriptname) = (shift, shift);
+        my (@toggle_lvls, $start_lvls, $stop_lvls, @symlinks);
+        my $lsb_header = lsb_header_for_script($scriptname);
+
+        # Extra arguments to disable|enable action are runlevels. If none
+        # given parse LSB info for Default-Start value.
+        if ($#_ >= 0) {
+            @toggle_lvls = @_;
+        } else {
+            ($start_lvls, $stop_lvls) = parse_def_start_stop($lsb_header);
+            @toggle_lvls = @$start_lvls;
+            if ($#toggle_lvls < 0) {
+                error("$scriptname Default-Start contains no runlevels, aborting.");
+            }
+        }
+        my %openrc_act = ( "disable" => "del", "enable" => "add" );
+        system("rc-update", $openrc_act{$action}, $scriptname,
+               openrc_rlconv(@toggle_lvls))
+    };
+
+    my @sequence;
+    if ($insserv_installed) {
+        push @sequence, $sysv_insserv;
+    }
+    else {
+        push @sequence, $sysv_plain;
+    }
+    # OpenRC has to be after sysv_{insserv,plain} because it depends on them to synchronize
+    # states.
+    if ($openrc_installed) {
+        push @sequence, $openrc;
+    }
+    push @sequence, $systemd;
+
+    return @sequence;
+}
+
+## Dependency based
+sub main {
+    my @args = @_;
+    my $scriptname;
+    my $action;
+    my $force = 0;
+
+    while($#args >= 0 && ($_ = $args[0]) =~ /^-/) {
+        shift @args;
+        if (/^-f$/) { $force = 1; next }
+        if (/^-h|--help$/) { usage(); }
+        usage("unknown option");
+    }
+
+    usage("not enough arguments") if ($#args < 1);
+
+    my @sequence = create_sequence($force);
+
+    $scriptname = shift @args;
+    $action = shift @args;
+    if ("remove" eq $action) {
+        foreach my $init (@sequence) {
+            $init->{remove}->($scriptname);
+        }
+    } elsif ("defaults" eq $action || "start" eq $action ||
+             "stop" eq $action) {
+        # All start/stop/defaults arguments are discarded so emit a
+        # message if arguments have been given and are in conflict
+        # with Default-Start/Default-Stop values of LSB comment.
+        if ("start" eq $action || "stop" eq $action) {
+            cmp_args_with_defaults($scriptname, $action, @args);
+        }
+        foreach my $init (@sequence) {
+            $init->{defaults}->($scriptname);
+        }
+    } elsif ("defaults-disabled" eq $action) {
+        foreach my $init (@sequence) {
+            $init->{defaults_disabled}->($scriptname);
+        }
+    } elsif ("disable" eq $action || "enable" eq $action) {
+        foreach my $init (@sequence) {
+            $init->{toggle}->($action, $scriptname, @args);
+        }
+    } else {
+        usage();
+    }
+}
+
+sub parse_def_start_stop {
+    my $script = shift;
+    my (%lsb, @def_start_lvls, @def_stop_lvls);
+
+    open my $fh, '<', $script or error("unable to read $script");
+    while (<$fh>) {
+        chomp;
+        if (m/^### BEGIN INIT INFO\s*$/) {
+            $lsb{'begin'}++;
+        }
+        elsif (m/^### END INIT INFO\s*$/) {
+            $lsb{'end'}++;
+            last;
+        }
+        elsif ($lsb{'begin'} and not $lsb{'end'}) {
+            if (m/^# Default-Start:\s*(\S?.*)$/) {
+                @def_start_lvls = split(' ', $1);
+            }
+            if (m/^# Default-Stop:\s*(\S?.*)$/) {
+                @def_stop_lvls = split(' ', $1);
+            }
+        }
+    }
+    close($fh);
+
+    return (\@def_start_lvls, \@def_stop_lvls);
+}
+
+sub lsb_header_for_script {
+    my $name = shift;
+
+    foreach my $file ("/etc/insserv/overrides/$name", "/etc/init.d/$name",
+                      "/usr/share/insserv/overrides/$name") {
+        return $file if -s $file;
+    }
+
+    error("cannot find a LSB script for $name");
+}
+
+sub cmp_args_with_defaults {
+    my ($name, $act) = (shift, shift);
+    my ($lsb_start_ref, $lsb_stop_ref, $arg_str, $lsb_str);
+    my (@arg_start_lvls, @arg_stop_lvls, @lsb_start_lvls, @lsb_stop_lvls);
+
+    ($lsb_start_ref, $lsb_stop_ref) = parse_def_start_stop("/etc/init.d/$name");
+    @lsb_start_lvls = @$lsb_start_ref;
+    @lsb_stop_lvls  = @$lsb_stop_ref;
+    return if (!@lsb_start_lvls and !@lsb_stop_lvls);
+
+    warning "start and stop actions are no longer supported; falling back to defaults";
+    my $start = $act eq 'start' ? 1 : 0;
+    my $stop = $act eq 'stop' ? 1 : 0;
+
+    # The legacy part of this program passes arguments starting with
+    # "start|stop NN x y z ." but the insserv part gives argument list
+    # starting with sequence number (ie. strips off leading "start|stop")
+    # Start processing arguments immediately after the first seq number.
+    my $argi = $_[0] eq $act ? 2 : 1;
+
+    while (defined $_[$argi]) {
+        my $arg = $_[$argi];
+
+        # Runlevels 0 and 6 are always stop runlevels
+        if ($arg eq 0 or $arg eq 6) {
+            $start = 0; $stop = 1;
+        } elsif ($arg eq 'start') {
+            $start = 1; $stop = 0; $argi++; next;
+        } elsif ($arg eq 'stop') {
+            $start = 0; $stop = 1; $argi++; next;
+        } elsif ($arg eq '.') {
+            next;
+        }
+        push(@arg_start_lvls, $arg) if $start;
+        push(@arg_stop_lvls, $arg) if $stop;
+    } continue {
+        $argi++;
+    }
+
+    if ($#arg_start_lvls != $#lsb_start_lvls or
+        join("\0", sort @arg_start_lvls) ne join("\0", sort @lsb_start_lvls)) {
+        $arg_str = @arg_start_lvls ? "@arg_start_lvls" : "none";
+        $lsb_str = @lsb_start_lvls ? "@lsb_start_lvls" : "none";
+        warning "start runlevel arguments ($arg_str) do not match",
+                "$name Default-Start values ($lsb_str)";
+    }
+    if ($#arg_stop_lvls != $#lsb_stop_lvls or
+        join("\0", sort @arg_stop_lvls) ne join("\0", sort @lsb_stop_lvls)) {
+        $arg_str = @arg_stop_lvls ? "@arg_stop_lvls" : "none";
+        $lsb_str = @lsb_stop_lvls ? "@lsb_stop_lvls" : "none";
+        warning "stop runlevel arguments ($arg_str) do not match",
+                "$name Default-Stop values ($lsb_str)";
+    }
+}
+
+sub sysv_toggle {
+    my ($act, $name) = (shift, shift);
+    my (@toggle_lvls, $start_lvls, $stop_lvls, @symlinks);
+    my $lsb_header = lsb_header_for_script($name);
+
+    # Extra arguments to disable|enable action are runlevels. If none
+    # given parse LSB info for Default-Start value.
+    if ($#_ >= 0) {
+        @toggle_lvls = @_;
+    } else {
+        ($start_lvls, $stop_lvls) = parse_def_start_stop($lsb_header);
+        @toggle_lvls = @$start_lvls;
+        if ($#toggle_lvls < 0) {
+            error("$name Default-Start contains no runlevels, aborting.");
+        }
+    }
+
+    # Find symlinks in rc.d directories. Refuse to modify links in runlevels
+    # not used for normal system start sequence.
+    for my $lvl (@toggle_lvls) {
+        if ($lvl !~ /^[S2345]$/) {
+            warning("$act action will have no effect on runlevel $lvl");
+            next;
+        }
+        push(@symlinks, $_) for glob("$dpkg_root/etc/rc$lvl.d/[SK][0-9][0-9]$name");
+    }
+
+    if (!@symlinks) {
+        error("no runlevel symlinks to modify, aborting!");
+    }
+
+    # Toggle S/K bit of script symlink.
+    for my $cur_lnk (@symlinks) {
+        my $sk;
+        my @new_lnk = split(//, $cur_lnk);
+
+        if ("disable" eq $act) {
+            $sk = rindex($cur_lnk, '/S') + 1;
+            next if $sk < 1;
+            $new_lnk[$sk] = 'K';
+        } else {
+            $sk = rindex($cur_lnk, '/K') + 1;
+            next if $sk < 1;
+            $new_lnk[$sk] = 'S';
+        }
+
+        rename($cur_lnk, join('', @new_lnk)) or error($!);
+    }
+}
+
+# Try to determine if initscripts is installed
+sub is_initscripts_installed {
+    # Check if mountkernfs is available. We cannot make inferences
+    # using the running init system because we may be running in a
+    # chroot
+    return  glob("$dpkg_root/etc/rcS.d/S??mountkernfs.sh");
+}