vagrant-salt 0.3.2 → 0.4.0

data/scripts/tests/bootstrap/test_lint.py

@@ -0,0 +1,27 @@
+# -*- coding: utf-8 -*-
+'''
+    bootstrap.test_lint
+    ~~~~~~~~~~~~~~~~~~~
+
+    :codeauthor: :email:`Pedro Algarvio (pedro@algarvio.me)`
+    :copyright: © 2013 by the UfSoft.org Team, see AUTHORS for more details.
+    :license: BSD, see LICENSE for more details.
+'''
+from bootstrap.unittesting import *
+
+
+class LintTestCase(BootstrapTestCase):
+    def test_bashisms(self):
+        '''
+        Lint check the bootstrap script for any possible bash'isms.
+        '''
+        if not os.path.exists('/usr/bin/perl'):
+            self.skipTest('\'/usr/bin/perl\' was not found on this system')
+        self.assert_script_result(
+            'Some bashisms were found',
+            0,
+            self.run_script(
+                script=os.path.join(EXT_DIR, 'checkbashisms'),
+                args=('-pxfn', BOOTSTRAP_SCRIPT_PATH)
+            )
+        )

data/scripts/tests/bootstrap/test_usage.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+"""
+    bootstrap.test_usage
+    ~~~~~~~~~~~~~~~~~~~~
+
+    :codeauthor: :email:`Pedro Algarvio (pedro@algarvio.me)`
+    :copyright: © 2013 by the UfSoft.org Team, see AUTHORS for more details.
+    :license: BSD, see LICENSE for more details.
+"""
+from bootstrap.unittesting import *
+
+
+class UsageTestCase(BootstrapTestCase):
+    def test_no_daemon_install_shows_warning(self):
+        '''
+        Passing '-N'(no minion) without passing '-M'(install master) or
+        '-S'(install syndic) shows a warning.
+        '''
+        rc, out, err = self.run_script(
+            args=('-N', '-n'),
+        )
+
+        self.assert_script_result(
+            'Not installing any daemons nor configuring did not throw any '
+            'warning',
+            0, (rc, out, err)
+        )
+        self.assertIn(' *  WARN: Nothing to install or configure', out)

data/scripts/tests/bootstrap/unittesting.py

@@ -0,0 +1,216 @@
+# -*- coding: utf-8 -*-
+'''
+    bootstrap.unittesting
+    ~~~~~~~~~~~~~~~~~~~~~
+
+    Unit testing related classes, helpers.
+
+    :codeauthor: :email:`Pedro Algarvio (pedro@algarvio.me)`
+    :copyright: © 2013 by the SaltStack Team, see AUTHORS for more details.
+    :license: Apache 2.0, see LICENSE for more details.
+'''
+
+# Import python libs
+import os
+import sys
+import fcntl
+import signal
+import tempfile
+import subprocess
+from datetime import datetime, timedelta
+
+# Import salt bootstrap libs
+from bootstrap.ext.os_data import GRAINS
+
+
+# support python < 2.7 via unittest2
+if sys.version_info < (2, 7):
+    try:
+        from unittest2 import (
+            TestLoader,
+            TextTestRunner,
+            TestCase,
+            expectedFailure,
+            TestSuite,
+            skipIf,
+        )
+    except ImportError:
+        raise SystemExit('You need to install unittest2 to run the salt tests')
+else:
+    from unittest import (
+        TestLoader,
+        TextTestRunner,
+        TestCase,
+        expectedFailure,
+        TestSuite,
+        skipIf,
+    )
+
+
+TEST_DIR = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
+EXT_DIR = os.path.join(TEST_DIR, 'ext')
+PARENT_DIR = os.path.dirname(TEST_DIR)
+BOOTSTRAP_SCRIPT_PATH = os.path.join(PARENT_DIR, 'bootstrap-salt.sh')
+
+
+class NonBlockingPopen(subprocess.Popen):
+
+    def __init__(self, *args, **kwargs):
+        self.stream_stds = kwargs.pop('stream_stds', False)
+        super(NonBlockingPopen, self).__init__(*args, **kwargs)
+        if self.stdout is not None and self.stream_stds:
+            fod = self.stdout.fileno()
+            fol = fcntl.fcntl(fod, fcntl.F_GETFL)
+            fcntl.fcntl(fod, fcntl.F_SETFL, fol | os.O_NONBLOCK)
+            self.obuff = ''
+
+        if self.stderr is not None and self.stream_stds:
+            fed = self.stderr.fileno()
+            fel = fcntl.fcntl(fed, fcntl.F_GETFL)
+            fcntl.fcntl(fed, fcntl.F_SETFL, fel | os.O_NONBLOCK)
+            self.ebuff = ''
+
+    def poll(self):
+        poll = super(NonBlockingPopen, self).poll()
+
+        if self.stdout is not None and self.stream_stds:
+            try:
+                obuff = self.stdout.read()
+                self.obuff += obuff
+                sys.stdout.write(obuff)
+            except IOError, err:
+                if err.errno not in (11, 35):
+                    # We only handle Resource not ready properly, any other
+                    # raise the exception
+                    raise
+        if self.stderr is not None and self.stream_stds:
+            try:
+                ebuff = self.stderr.read()
+                self.ebuff += ebuff
+                sys.stderr.write(ebuff)
+            except IOError, err:
+                if err.errno not in (11, 35):
+                    # We only handle Resource not ready properly, any other
+                    # raise the exception
+                    raise
+
+        if poll is None:
+            # Not done yet
+            return poll
+
+        if not self.stream_stds:
+            # Allow the same attribute access even though not streaming to stds
+            try:
+                self.obuff = self.stdout.read()
+            except IOError, err:
+                if err.errno not in (11, 35):
+                    # We only handle Resource not ready properly, any other
+                    # raise the exception
+                    raise
+            try:
+                self.ebuff = self.stderr.read()
+            except IOError, err:
+                if err.errno not in (11, 35):
+                    # We only handle Resource not ready properly, any other
+                    # raise the exception
+                    raise
+        return poll
+
+
+class BootstrapTestCase(TestCase):
+    def run_script(self,
+                   script=BOOTSTRAP_SCRIPT_PATH,
+                   args=(),
+                   cwd=PARENT_DIR,
+                   timeout=None,
+                   executable='/bin/sh',
+                   stream_stds=False):
+
+        cmd = [script] + list(args)
+
+        outbuff = errbuff = ''
+
+        popen_kwargs = {
+            'cwd': cwd,
+            'shell': True,
+            'stderr': subprocess.PIPE,
+            'stdout': subprocess.PIPE,
+            'close_fds': True,
+            'executable': executable,
+
+            'stream_stds': stream_stds,
+
+            # detach from parent group (no more inherited signals!)
+            #'preexec_fn': os.setpgrp
+        }
+
+        cmd = ' '.join(filter(None, [script] + list(args)))
+
+        process = NonBlockingPopen(cmd, **popen_kwargs)
+
+        if timeout is not None:
+            stop_at = datetime.now() + timedelta(seconds=timeout)
+            term_sent = False
+
+        while process.poll() is None:
+
+            if timeout is not None:
+                now = datetime.now()
+
+                if now > stop_at:
+                    if term_sent is False:
+                        # Kill the process group since sending the term signal
+                        # would only terminate the shell, not the command
+                        # executed in the shell
+                        os.killpg(os.getpgid(process.pid), signal.SIGINT)
+                        term_sent = True
+                        continue
+
+                    # As a last resort, kill the process group
+                    os.killpg(os.getpgid(process.pid), signal.SIGKILL)
+
+                    return 1, [
+                        'Process took more than {0} seconds to complete. '
+                        'Process Killed! Current STDOUT: \n{1}'.format(
+                            timeout, process.obuff
+                        )
+                    ], [
+                        'Process took more than {0} seconds to complete. '
+                        'Process Killed! Current STDERR: \n{1}'.format(
+                            timeout, process.ebuff
+                        )
+                    ]
+
+        process.communicate()
+
+        try:
+            return (
+                process.returncode,
+                process.obuff.splitlines(),
+                process.ebuff.splitlines()
+            )
+        finally:
+            try:
+                process.terminate()
+            except OSError:
+                # process already terminated
+                pass
+
+    def assert_script_result(self, fail_msg, expected_rcs, process_details):
+        if not isinstance(expected_rcs, (tuple, list)):
+            expected_rcs = (expected_rcs,)
+
+        rc, out, err = process_details
+        if rc not in expected_rcs:
+            err_msg = '{0}:\n'.format(fail_msg)
+            if out:
+                err_msg = '{0}STDOUT:\n{1}\n'.format(err_msg, '\n'.join(out))
+            if err:
+                err_msg = '{0}STDERR:\n{1}\n'.format(err_msg, '\n'.join(err))
+            if not err and not out:
+                err_msg = (
+                    '{0} No stdout nor stderr captured. Exit code: {1}'.format(
+                        err_msg, rc
+                    )
+                )
+            raise AssertionError(err_msg.rstrip())

data/scripts/tests/ext/checkbashisms

@@ -0,0 +1,640 @@
+#! /usr/bin/perl -w
+
+# This script is essentially copied from /usr/share/lintian/checks/scripts,
+# which is:
+#   Copyright (C) 1998 Richard Braakman
+#   Copyright (C) 2002 Josip Rodin
+# This version is
+#   Copyright (C) 2003 Julian Gilbey
+#
+# 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, see <http://www.gnu.org/licenses/>.
+
+use strict;
+use Getopt::Long qw(:config gnu_getopt);
+use File::Temp qw/tempfile/;
+
+sub init_hashes;
+
+(my $progname = $0) =~ s|.*/||;
+
+my $usage = <<"EOF";
+Usage: $progname [-n] [-f] [-x] script ...
+   or: $progname --help
+   or: $progname --version
+This script performs basic checks for the presence of bashisms
+in /bin/sh scripts.
+EOF
+
+my $version = <<"EOF";
+This is $progname, from the Debian devscripts package, version 2.11.6ubuntu1.4
+This code is copyright 2003 by Julian Gilbey <jdg\@debian.org>,
+based on original code which is copyright 1998 by Richard Braakman
+and copyright 2002 by Josip Rodin.
+This program comes with ABSOLUTELY NO WARRANTY.
+You are free to redistribute this code under the terms of the
+GNU General Public License, version 2, or (at your option) any later version.
+EOF
+
+my ($opt_echo, $opt_force, $opt_extra, $opt_posix);
+my ($opt_help, $opt_version);
+my @filenames;
+
+# Detect if STDIN is a pipe
+if (-p STDIN or -f STDIN) {
+    my ($tmp_fh, $tmp_filename) = tempfile("chkbashisms_tmp.XXXX", TMPDIR => 1, UNLINK => 1);
+    while (my $line = <STDIN>) {
+        print $tmp_fh $line;
+    }
+    close($tmp_fh);
+    push(@ARGV, $tmp_filename);
+}
+
+##
+## handle command-line options
+##
+$opt_help = 1 if int(@ARGV) == 0;
+
+GetOptions("help|h" => \$opt_help,
+	   "version|v" => \$opt_version,
+	   "newline|n" => \$opt_echo,
+	   "force|f" => \$opt_force,
+	   "extra|x" => \$opt_extra,
+	   "posix|p" => \$opt_posix,
+           )
+    or die "Usage: $progname [options] filelist\nRun $progname --help for more details\n";
+
+if ($opt_help) { print $usage; exit 0; }
+if ($opt_version) { print $version; exit 0; }
+
+$opt_echo = 1 if $opt_posix;
+
+my $status = 0;
+my $makefile = 0;
+my (%bashisms, %string_bashisms, %singlequote_bashisms);
+
+my $LEADIN = qr'(?:(?:^|[`&;(|{])\s*|(?:if|then|do|while|shell)\s+)';
+init_hashes;
+
+foreach my $filename (@ARGV) {
+    my $check_lines_count = -1;
+
+    my $display_filename = $filename;
+    if ($filename =~ /chkbashisms_tmp\.....$/) {
+        $display_filename = "(stdin)";
+    }
+
+    if (!$opt_force) {
+	$check_lines_count = script_is_evil_and_wrong($filename);
+    }
+
+    if ($check_lines_count == 0 or $check_lines_count == 1) {
+	warn "script $display_filename does not appear to be a /bin/sh script; skipping\n";
+	next;
+    }
+
+    if ($check_lines_count != -1) {
+	warn "script $display_filename appears to be a shell wrapper; only checking the first "
+	     . "$check_lines_count lines\n";
+    }
+
+    unless (open C, '<', $filename) {
+	warn "cannot open script $display_filename for reading: $!\n";
+	$status |= 2;
+	next;
+    }
+
+    my $cat_string = "";
+    my $cat_indented = 0;
+    my $quote_string = "";
+    my $last_continued = 0;
+    my $continued = 0;
+    my $found_rules = 0;
+    my $buffered_orig_line = "";
+    my $buffered_line = "";
+
+    while (<C>) {
+	next unless ($check_lines_count == -1 or $. <= $check_lines_count);
+
+	if ($. == 1) { # This should be an interpreter line
+	    if (m,^\#!\s*(\S+),) {
+		my $interpreter = $1;
+
+		if ($interpreter =~ m,/make$,) {
+		    init_hashes if !$makefile++;
+		    $makefile = 1;
+		} else {
+		    init_hashes if $makefile--;
+		    $makefile = 0;
+		}
+		next if $opt_force;
+
+		if ($interpreter =~ m,/bash$,) {
+		    warn "script $display_filename is already a bash script; skipping\n";
+		    $status |= 2;
+		    last;  # end this file
+		}
+		elsif ($interpreter !~ m,/(sh|posh)$,) {
+### ksh/zsh?
+		    warn "script $display_filename does not appear to be a /bin/sh script; skipping\n";
+		    $status |= 2;
+		    last;
+		}
+	    } else {
+		warn "script $display_filename does not appear to have a \#! interpreter line;\nyou may get strange results\n";
+	    }
+	}
+
+	chomp;
+	my $orig_line = $_;
+
+	# We want to remove end-of-line comments, so need to skip
+	# comments that appear inside balanced pairs
+	# of single or double quotes
+
+	# Remove comments in the "quoted" part of a line that starts
+	# in a quoted block? The problem is that we have no idea
+	# whether the program interpreting the block treats the
+	# quote character as part of the comment or as a quote
+	# terminator. We err on the side of caution and assume it
+	# will be treated as part of the comment.
+	# s/^(?:.*?[^\\])?$quote_string(.*)$/$1/ if $quote_string ne "";
+
+	# skip comment lines
+	if (m,^\s*\#, && $quote_string eq '' && $buffered_line eq '' && $cat_string eq '') {
+	    next;
+	}
+
+	# Remove quoted strings so we can more easily ignore comments
+	# inside them
+	s/(^|[^\\](?:\\\\)*)\'(?:\\.|[^\\\'])+\'/$1''/g;
+	s/(^|[^\\](?:\\\\)*)\"(?:\\.|[^\\\"])+\"/$1""/g;
+
+	# If the remaining string contains what looks like a comment,
+	# eat it. In either case, swap the unmodified script line
+	# back in for processing.
+	if (m/(?:^|[^[\\])[\s\&;\(\)](\#.*$)/) {
+	    $_ = $orig_line;
+	    s/\Q$1\E//;  # eat comments
+	} else {
+	    $_ = $orig_line;
+	}
+
+	# Handle line continuation
+	if (!$makefile && $cat_string eq '' && m/\\$/) {
+	    chop;
+	    $buffered_line .= $_;
+	    $buffered_orig_line .= $orig_line . "\n";
+	    next;
+	}
+
+	if ($buffered_line ne '') {
+	    $_ = $buffered_line . $_;
+	    $orig_line = $buffered_orig_line . $orig_line;
+	    $buffered_line ='';
+	    $buffered_orig_line ='';
+	}
+
+	if ($makefile) {
+	    $last_continued = $continued;
+	    if (/[^\\]\\$/) {
+		$continued = 1;
+	    } else {
+		$continued = 0;
+	    }
+
+	    # Don't match lines that look like a rule if we're in a
+	    # continuation line before the start of the rules
+	    if (/^[\w%-]+:+\s.*?;?(.*)$/ and !($last_continued and !$found_rules)) {
+		$found_rules = 1;
+		$_ = $1 if $1;
+	    }
+
+	    last if m%^\s*(override\s|export\s)?\s*SHELL\s*:?=\s*(/bin/)?bash\s*%;
+
+	    # Remove "simple" target names
+	    s/^[\w%.-]+(?:\s+[\w%.-]+)*::?//;
+	    s/^\t//;
+	    s/(?<!\$)\$\((\w+)\)/\${$1}/g;
+	    s/(\$){2}/$1/g;
+	    s/^[\s\t]*[@-]{1,2}//;
+	}
+
+	if ($cat_string ne "" && (m/^\Q$cat_string\E$/ || ($cat_indented && m/^\t*\Q$cat_string\E$/))) {
+	    $cat_string = "";
+	    next;
+	}
+	my $within_another_shell = 0;
+	if (m,(^|\s+)((/usr)?/bin/)?((b|d)?a|k|z|t?c)sh\s+-c\s*.+,) {
+	    $within_another_shell = 1;
+	}
+	# if cat_string is set, we are in a HERE document and need not
+	# check for things
+	if ($cat_string eq "" and !$within_another_shell) {
+	    my $found = 0;
+	    my $match = '';
+	    my $explanation = '';
+	    my $line = $_;
+
+	    # Remove "" / '' as they clearly aren't quoted strings
+	    # and not considering them makes the matching easier
+	    $line =~ s/(^|[^\\])(\'\')+/$1/g;
+	    $line =~ s/(^|[^\\])(\"\")+/$1/g;
+
+	    if ($quote_string ne "") {
+		my $otherquote = ($quote_string eq "\"" ? "\'" : "\"");
+		# Inside a quoted block
+		if ($line =~ /(?:^|^.*?[^\\])$quote_string(.*)$/) {
+		    my $rest = $1;
+		    my $templine = $line;
+
+		    # Remove quoted strings delimited with $otherquote
+		    $templine =~ s/(^|[^\\])$otherquote[^$quote_string]*?[^\\]$otherquote/$1/g;
+		    # Remove quotes that are themselves quoted
+		    # "a'b"
+		    $templine =~ s/(^|[^\\])$otherquote.*?$quote_string.*?[^\\]$otherquote/$1/g;
+		    # "\""
+		    $templine =~ s/(^|[^\\])$quote_string\\$quote_string$quote_string/$1/g;
+
+		    # After all that, were there still any quotes left?
+		    my $count = () = $templine =~ /(^|[^\\])$quote_string/g;
+		    next if $count == 0;
+
+		    $count = () = $rest =~ /(^|[^\\])$quote_string/g;
+		    if ($count % 2 == 0) {
+			# Quoted block ends on this line
+			# Ignore everything before the closing quote
+			$line = $rest || '';
+			$quote_string = "";
+		    } else {
+			next;
+		    }
+		} else {
+		    # Still inside the quoted block, skip this line
+		    next;
+		}
+	    }
+
+	    # Check even if we removed the end of a quoted block
+	    # in the previous check, as a single line can end one
+	    # block and begin another
+	    if ($quote_string eq "") {
+		# Possible start of a quoted block
+		for my $quote ("\"", "\'") {
+		    my $templine = $line;
+		    my $otherquote = ($quote eq "\"" ? "\'" : "\"");
+
+		    # Remove balanced quotes and their content
+		    $templine =~ s/(^|[^\\\"](?:\\\\)*)\'[^\']*\'/$1/g;
+		    $templine =~ s/(^|[^\\\'](?:\\\\)*)\"(?:\\.|[^\\\"])+\"/$1/g;
+
+		    # Don't flag quotes that are themselves quoted
+		    # "a'b"
+		    $templine =~ s/$otherquote.*?$quote.*?$otherquote//g;
+		    # "\""
+		    $templine =~ s/(^|[^\\])$quote\\$quote$quote/$1/g;
+		    # \' or \"
+		    $templine =~ s/\\[\'\"]//g;
+		    my $count = () = $templine =~ /(^|(?!\\))$quote/g;
+
+		    # If there's an odd number of non-escaped
+		    # quotes in the line it's almost certainly the
+		    # start of a quoted block.
+		    if ($count % 2 == 1) {
+			$quote_string = $quote;
+			$line =~ s/^(.*)$quote.*$/$1/;
+			last;
+		    }
+		}
+	    }
+
+	    # since this test is ugly, I have to do it by itself
+	    # detect source (.) trying to pass args to the command it runs
+	    # The first expression weeds out '. "foo bar"'
+	    if (not $found and
+		not m/$LEADIN\.\s+(\"[^\"]+\"|\'[^\']+\'|\$\([^)]+\)+(?:\/[^\s;]+)?)\s*(\&|\||\d?>|<|;|\Z)/
+		and m/$LEADIN(\.\s+[^\s;\`:]+\s+([^\s;]+))/) {
+		if ($2 =~ /^(\&|\||\d?>|<)/) {
+		    # everything is ok
+		    ;
+		} else {
+		    $found = 1;
+		    $match = $1;
+		    $explanation = "sourced script with arguments";
+		    output_explanation($display_filename, $orig_line, $explanation);
+		}
+	    }
+
+	    # Remove "quoted quotes". They're likely to be inside
+	    # another pair of quotes; we're not interested in
+	    # them for their own sake and removing them makes finding
+	    # the limits of the outer pair far easier.
+	    $line =~ s/(^|[^\\\'\"])\"\'\"/$1/g;
+	    $line =~ s/(^|[^\\\'\"])\'\"\'/$1/g;
+
+	    while (my ($re,$expl) = each %singlequote_bashisms) {
+		if ($line =~ m/($re)/) {
+		    $found = 1;
+		    $match = $1;
+		    $explanation = $expl;
+		    output_explanation($display_filename, $orig_line, $explanation);
+		}
+	    }
+
+	    my $re='(?<![\$\\\])\$\'[^\']+\'';
+	    if ($line =~ m/(.*)($re)/){
+		my $count = () = $1 =~ /(^|[^\\])\'/g;
+		if( $count % 2 == 0 ) {
+		    output_explanation($display_filename, $orig_line, q<$'...' should be "$(printf '...')">);
+		}
+	    }
+
+	    # $cat_line contains the version of the line we'll check
+	    # for heredoc delimiters later. Initially, remove any
+	    # spaces between << and the delimiter to make the following
+	    # updates to $cat_line easier.
+	    my $cat_line = $line;
+	    $cat_line =~ s/(<\<-?)\s+/$1/g;
+
+	    # Ignore anything inside single quotes; it could be an
+	    # argument to grep or the like.
+	    $line =~ s/(^|[^\\\"](?:\\\\)*)\'(?:\\.|[^\\\'])+\'/$1''/g;
+
+	    # As above, with the exception that we don't remove the string
+	    # if the quote is immediately preceeded by a < or a -, so we
+	    # can match "foo <<-?'xyz'" as a heredoc later
+	    # The check is a little more greedy than we'd like, but the
+	    # heredoc test itself will weed out any false positives
+	    $cat_line =~ s/(^|[^<\\\"-](?:\\\\)*)\'(?:\\.|[^\\\'])+\'/$1''/g;
+
+	    $re='(?<![\$\\\])\$\"[^\"]+\"';
+	    if ($line =~ m/(.*)($re)/){
+		my $count = () = $1 =~ /(^|[^\\])\"/g;
+		if( $count % 2 == 0 ) {
+		    output_explanation($display_filename, $orig_line, q<$"foo" should be eval_gettext "foo">);
+		}
+	    }
+
+	    while (my ($re,$expl) = each %string_bashisms) {
+		if ($line =~ m/($re)/) {
+		    $found = 1;
+		    $match = $1;
+		    $explanation = $expl;
+		    output_explanation($display_filename, $orig_line, $explanation);
+		}
+	    }
+
+	    # We've checked for all the things we still want to notice in
+	    # double-quoted strings, so now remove those strings as well.
+	    $line =~ s/(^|[^\\\'](?:\\\\)*)\"(?:\\.|[^\\\"])+\"/$1""/g;
+	    $cat_line =~ s/(^|[^<\\\'-](?:\\\\)*)\"(?:\\.|[^\\\"])+\"/$1""/g;
+	    while (my ($re,$expl) = each %bashisms) {
+	        if ($line =~ m/($re)/) {
+		    $found = 1;
+		    $match = $1;
+		    $explanation = $expl;
+		    output_explanation($display_filename, $orig_line, $explanation);
+		}
+	    }
+
+	    # Only look for the beginning of a heredoc here, after we've
+	    # stripped out quoted material, to avoid false positives.
+	    if ($cat_line =~ m/(?:^|[^<])\<\<(\-?)\s*(?:[\\]?(\w+)|[\'\"](.*?)[\'\"])/) {
+		$cat_indented = ($1 && $1 eq '-')? 1 : 0;
+		$cat_string = $2;
+		$cat_string = $3 if not defined $cat_string;
+            }
+	}
+    }
+
+    warn "error: $filename:  Unterminated heredoc found, EOF reached. Wanted: <$cat_string>\n"
+	if ($cat_string ne '');
+    warn "error: $filename: Unterminated quoted string found, EOF reached. Wanted: <$quote_string>\n"
+	if ($quote_string ne '');
+    warn "error: $filename: EOF reached while on line continuation.\n"
+	if ($buffered_line ne '');
+
+    close C;
+}
+
+exit $status;
+
+sub output_explanation {
+    my ($filename, $line, $explanation) = @_;
+
+    warn "possible bashism in $filename line $. ($explanation):\n$line\n";
+    $status |= 1;
+}
+
+# Returns non-zero if the given file is not actually a shell script,
+# just looks like one.
+sub script_is_evil_and_wrong {
+    my ($filename) = @_;
+    my $ret = -1;
+    # lintian's version of this function aborts if the file
+    # can't be opened, but we simply return as the next
+    # test in the calling code handles reporting the error
+    # itself
+    open (IN, '<', $filename) or return $ret;
+    my $i = 0;
+    my $var = "0";
+    my $backgrounded = 0;
+    local $_;
+    while (<IN>) {
+        chomp;
+        next if /^#/o;
+        next if /^$/o;
+        last if (++$i > 55);
+        if (m~
+	    # the exec should either be "eval"ed or a new statement
+	    (^\s*|\beval\s*[\'\"]|(;|&&|\b(then|else))\s*)
+
+	    # eat anything between the exec and $0
+	    exec\s*.+\s*
+
+	    # optionally quoted executable name (via $0)
+	    .?\$$var.?\s*
+
+	    # optional "end of options" indicator
+	    (--\s*)?
+
+	    # Match expressions of the form '${1+$@}', '${1:+"$@"',
+	    # '"${1+$@', "$@", etc where the quotes (before the dollar
+	    # sign(s)) are optional and the second (or only if the $1
+	    # clause is omitted) parameter may be $@ or $*.
+	    #
+	    # Finally the whole subexpression may be omitted for scripts
+	    # which do not pass on their parameters (i.e. after re-execing
+	    # they take their parameters (and potentially data) from stdin
+	    .?(\${1:?\+.?)?(\$(\@|\*))?~x) {
+            $ret = $. - 1;
+            last;
+        } elsif (/^\s*(\w+)=\$0;/) {
+	    $var = $1;
+	} elsif (m~
+	    # Match scripts which use "foo $0 $@ &\nexec true\n"
+	    # Program name
+	    \S+\s+
+
+	    # As above
+	    .?\$$var.?\s*
+	    (--\s*)?
+	    .?(\${1:?\+.?)?(\$(\@|\*))?.?\s*\&~x) {
+
+	    $backgrounded = 1;
+	} elsif ($backgrounded and m~
+	    # the exec should either be "eval"ed or a new statement
+	    (^\s*|\beval\s*[\'\"]|(;|&&|\b(then|else))\s*)
+	    exec\s+true(\s|\Z)~x) {
+
+	    $ret = $. - 1;
+	    last;
+	} elsif (m~\@DPATCH\@~) {
+	    $ret = $. - 1;
+	    last;
+	}
+
+    }
+    close IN;
+    return $ret;
+}
+
+sub init_hashes {
+
+    %bashisms = (
+	qr'(?:^|\s+)function \w+(\s|\(|\Z)' => q<'function' is useless>,
+	$LEADIN . qr'select\s+\w+' =>     q<'select' is not POSIX>,
+	qr'(test|-o|-a)\s*[^\s]+\s+==\s' => q<should be 'b = a'>,
+	qr'\[\s+[^\]]+\s+==\s' =>        q<should be 'b = a'>,
+	qr'\s\|\&' =>                    q<pipelining is not POSIX>,
+	qr'[^\\\$]\{([^\s\\\}]*?,)+[^\\\}\s]*\}' => q<brace expansion>,
+	qr'\{\d+\.\.\d+\}' =>          q<brace expansion, should be $(seq a b)>,
+	qr'(?:^|\s+)\w+\[\d+\]=' =>      q<bash arrays, H[0]>,
+	$LEADIN . qr'read\s+(?:-[a-qs-zA-Z\d-]+)' => q<read with option other than -r>,
+	$LEADIN . qr'read\s*(?:-\w+\s*)*(?:\".*?\"|[\'].*?[\'])?\s*(?:;|$)'
+	    => q<read without variable>,
+	$LEADIN . qr'echo\s+(-n\s+)?-n?en?\s' =>      q<echo -e>,
+	$LEADIN . qr'exec\s+-[acl]' =>    q<exec -c/-l/-a name>,
+	$LEADIN . qr'let\s' =>            q<let ...>,
+	qr'(?<![\$\(])\(\(.*\)\)' =>     q<'((' should be '$(('>,
+	qr'(?:^|\s+)(\[|test)\s+-a' =>            q<test with unary -a (should be -e)>,
+	qr'\&>' =>	               q<should be \>word 2\>&1>,
+	qr'(<\&|>\&)\s*((-|\d+)[^\s;|)}`&\\\\]|[^-\d\s]+(?<!\$)(?!\d))' =>
+				       q<should be \>word 2\>&1>,
+	qr'\[\[(?!:)' => q<alternative test command ([[ foo ]] should be [ foo ])>,
+	qr'/dev/(tcp|udp)'	    => q</dev/(tcp|udp)>,
+	$LEADIN . qr'builtin\s' =>        q<builtin>,
+	$LEADIN . qr'caller\s' =>         q<caller>,
+	$LEADIN . qr'compgen\s' =>        q<compgen>,
+	$LEADIN . qr'complete\s' =>       q<complete>,
+	$LEADIN . qr'declare\s' =>        q<declare>,
+	$LEADIN . qr'dirs(\s|\Z)' =>      q<dirs>,
+	$LEADIN . qr'disown\s' =>         q<disown>,
+	$LEADIN . qr'enable\s' =>         q<enable>,
+	$LEADIN . qr'mapfile\s' =>        q<mapfile>,
+	$LEADIN . qr'readarray\s' =>      q<readarray>,
+	$LEADIN . qr'shopt(\s|\Z)' =>     q<shopt>,
+	$LEADIN . qr'suspend\s' =>        q<suspend>,
+	$LEADIN . qr'time\s' =>           q<time>,
+	$LEADIN . qr'type\s' =>           q<type>,
+	$LEADIN . qr'typeset\s' =>        q<typeset>,
+	$LEADIN . qr'ulimit(\s|\Z)' =>    q<ulimit>,
+	$LEADIN . qr'set\s+-[BHT]+' =>    q<set -[BHT]>,
+	$LEADIN . qr'alias\s+-p' =>       q<alias -p>,
+	$LEADIN . qr'unalias\s+-a' =>     q<unalias -a>,
+	$LEADIN . qr'local\s+-[a-zA-Z]+' => q<local -opt>,
+	qr'(?:^|\s+)\s*\(?\w*[^\(\w\s]+\S*?\s*\(\)\s*([\{|\(]|\Z)'
+		=> q<function names should only contain [a-z0-9_]>,
+	$LEADIN . qr'(push|pop)d(\s|\Z)' =>    q<(push|pop)d>,
+	$LEADIN . qr'export\s+-[^p]' =>  q<export only takes -p as an option>,
+	qr'(?:^|\s+)[<>]\(.*?\)'	    => q<\<() process substituion>,
+	$LEADIN . qr'readonly\s+-[af]' => q<readonly -[af]>,
+	$LEADIN . qr'(sh|\$\{?SHELL\}?) -[rD]' => q<sh -[rD]>,
+	$LEADIN . qr'(sh|\$\{?SHELL\}?) --\w+' =>  q<sh --long-option>,
+	$LEADIN . qr'(sh|\$\{?SHELL\}?) [-+]O' =>  q<sh [-+]O>,
+	qr'\[\^[^]]+\]' =>  q<[^] should be [!]>,
+	$LEADIN . qr'printf\s+-v' => q<'printf -v var ...' should be var='$(printf ...)'>,
+	$LEADIN . qr'coproc\s' =>        q<coproc>,
+	qr';;?&' =>  q<;;& and ;& special case operators>,
+	$LEADIN . qr'jobs\s' =>  q<jobs>,
+#	$LEADIN . qr'jobs\s+-[^lp]\s' =>  q<'jobs' with option other than -l or -p>,
+	$LEADIN . qr'command\s+-[^p]\s' =>  q<'command' with option other than -p>,
+    );
+
+    %string_bashisms = (
+	qr'\$\[[^][]+\]' =>	         q<'$[' should be '$(('>,
+	qr'\$\{\w+\:\d+(?::\d+)?\}' =>   q<${foo:3[:1]}>,
+	qr'\$\{!\w+[\@*]\}' =>           q<${!prefix[*|@]>,
+	qr'\$\{!\w+\}' =>                q<${!name}>,
+	qr'\$\{\w+(/.+?){1,2}\}' =>      q<${parm/?/pat[/str]}>,
+	qr'\$\{\#?\w+\[[0-9\*\@]+\]\}' => q<bash arrays, ${name[0|*|@]}>,
+	qr'\$\{?RANDOM\}?\b' =>          q<$RANDOM>,
+	qr'\$\{?(OS|MACH)TYPE\}?\b'   => q<$(OS|MACH)TYPE>,
+	qr'\$\{?HOST(TYPE|NAME)\}?\b' => q<$HOST(TYPE|NAME)>,
+	qr'\$\{?DIRSTACK\}?\b'        => q<$DIRSTACK>,
+	qr'\$\{?EUID\}?\b'	      => q<$EUID should be "$(id -u)">,
+	qr'\$\{?UID\}?\b'	       => q<$UID should be "$(id -ru)">,
+	qr'\$\{?SECONDS\}?\b'	    => q<$SECONDS>,
+	qr'\$\{?BASH_[A-Z]+\}?\b'     => q<$BASH_SOMETHING>,
+	qr'\$\{?SHELLOPTS\}?\b'       => q<$SHELLOPTS>,
+	qr'\$\{?PIPESTATUS\}?\b'      => q<$PIPESTATUS>,
+	qr'\$\{?SHLVL\}?\b'           => q<$SHLVL>,
+	qr'<<<'                       => q<\<\<\< here string>,
+	$LEADIN . qr'echo\s+(?:-[^e\s]+\s+)?\"[^\"]*(\\[abcEfnrtv0])+.*?[\"]' => q<unsafe echo with backslash>,
+	qr'\$\(\([\s\w$*/+-]*\w\+\+.*?\)\)'   => q<'$((n++))' should be '$n; $((n=n+1))'>,
+	qr'\$\(\([\s\w$*/+-]*\+\+\w.*?\)\)'   => q<'$((++n))' should be '$((n=n+1))'>,
+	qr'\$\(\([\s\w$*/+-]*\w\-\-.*?\)\)'   => q<'$((n--))' should be '$n; $((n=n-1))'>,
+	qr'\$\(\([\s\w$*/+-]*\-\-\w.*?\)\)'   => q<'$((--n))' should be '$((n=n-1))'>,
+	qr'\$\(\([\s\w$*/+-]*\*\*.*?\)\)'   => q<exponentiation is not POSIX>,
+	$LEADIN . qr'printf\s["\'][^"\']+?%[qb].+?["\']' => q<printf %q|%b>,
+    );
+
+    %singlequote_bashisms = (
+	$LEADIN . qr'echo\s+(?:-[^e\s]+\s+)?\'[^\']*(\\[abcEfnrtv0])+.*?[\']' => q<unsafe echo with backslash>,
+	$LEADIN . qr'source\s+[\"\']?(?:\.\/|\/|\$|[\w~.-])\S*' =>
+	                               q<should be '.', not 'source'>,
+    );
+
+    if ($opt_echo) {
+	$bashisms{$LEADIN . qr'echo\s+-[A-Za-z]*n'} = q<echo -n>;
+    }
+    if ($opt_posix) {
+	$bashisms{$LEADIN . qr'local\s+\w+(\s+\W|\s*[;&|)]|$)'} = q<local foo>;
+	$bashisms{$LEADIN . qr'local\s+\w+='} = q<local foo=bar>;
+	$bashisms{$LEADIN . qr'local\s+\w+\s+\w+'} = q<local x y>;
+	$bashisms{$LEADIN . qr'((?:test|\[)\s+.+\s-[ao])\s'} = q<test -a/-o>;
+	$bashisms{$LEADIN . qr'kill\s+-[^sl]\w*'} = q<kill -[0-9] or -[A-Z]>;
+	$bashisms{$LEADIN . qr'trap\s+["\']?.*["\']?\s+.*[1-9]'} = q<trap with signal numbers>;
+    }
+
+    if ($makefile) {
+	$string_bashisms{qr'(\$\(|\`)\s*\<\s*([^\s\)]{2,}|[^DF])\s*(\)|\`)'} =
+	    q<'$(\< foo)' should be '$(cat foo)'>;
+    } else {
+	$bashisms{$LEADIN . qr'\w+\+='} = q<should be VAR="${VAR}foo">;
+	$string_bashisms{qr'(\$\(|\`)\s*\<\s*\S+\s*(\)|\`)'} = q<'$(\< foo)' should be '$(cat foo)'>;
+    }
+
+    if ($opt_extra) {
+	$string_bashisms{qr'\$\{?BASH\}?\b'} = q<$BASH>;
+	$string_bashisms{qr'(?:^|\s+)RANDOM='} = q<RANDOM=>;
+	$string_bashisms{qr'(?:^|\s+)(OS|MACH)TYPE='} = q<(OS|MACH)TYPE=>;
+	$string_bashisms{qr'(?:^|\s+)HOST(TYPE|NAME)='} = q<HOST(TYPE|NAME)=>;
+	$string_bashisms{qr'(?:^|\s+)DIRSTACK='} = q<DIRSTACK=>;
+	$string_bashisms{qr'(?:^|\s+)EUID='} = q<EUID=>;
+	$string_bashisms{qr'(?:^|\s+)UID='} = q<UID=>;
+	$string_bashisms{qr'(?:^|\s+)BASH(_[A-Z]+)?='} = q<BASH(_SOMETHING)=>;
+	$string_bashisms{qr'(?:^|\s+)SHELLOPTS='} = q<SHELLOPTS=>;
+	$string_bashisms{qr'\$\{?POSIXLY_CORRECT\}?\b'} = q<$POSIXLY_CORRECT>;
+    }
+}