Exemplo n.º 1
0
    def testOptionLengthError(self):
        testopts = [
            CmdBuilderConfig(bind="0.0.0.0" +
                             ("A" * impexpd.SOCAT_OPTION_MAXLEN),
                             port=1234,
                             ca="/tmp/ca"),
            CmdBuilderConfig(host="localhost",
                             port=1234,
                             ca="/tmp/ca" +
                             ("B" * impexpd.SOCAT_OPTION_MAXLEN)),
            CmdBuilderConfig(host="localhost",
                             port=1234,
                             key="/tmp/key" +
                             ("B" * impexpd.SOCAT_OPTION_MAXLEN)),
        ]

        for opts in testopts:
            for mode in [constants.IEM_IMPORT, constants.IEM_EXPORT]:
                builder = impexpd.CommandBuilder(mode, opts, 1, 2, 3)
                self.assertRaises(errors.GenericError, builder.GetCommand)

            opts.host = "localhost" + ("A" * impexpd.SOCAT_OPTION_MAXLEN)
            builder = impexpd.CommandBuilder(constants.IEM_EXPORT, opts, 1, 2,
                                             3)
            self.assertRaises(errors.GenericError, builder.GetCommand)
Exemplo n.º 2
0
    def testIPv6(self):
        for mode in [constants.IEM_IMPORT, constants.IEM_EXPORT]:
            opts = CmdBuilderConfig(host="localhost",
                                    port=6789,
                                    ipv4=False,
                                    ipv6=False)
            builder = impexpd.CommandBuilder(mode, opts, 1, 2, 3)
            cmd = builder._GetSocatCommand()
            self.assert_(compat.all("pf=" not in i for i in cmd))

            # IPv4
            opts = CmdBuilderConfig(host="localhost",
                                    port=6789,
                                    ipv4=True,
                                    ipv6=False)
            builder = impexpd.CommandBuilder(mode, opts, 1, 2, 3)
            cmd = builder._GetSocatCommand()
            self.assert_(compat.any(",pf=ipv4" in i for i in cmd))

            # IPv6
            opts = CmdBuilderConfig(host="localhost",
                                    port=6789,
                                    ipv4=False,
                                    ipv6=True)
            builder = impexpd.CommandBuilder(mode, opts, 1, 2, 3)
            cmd = builder._GetSocatCommand()
            self.assert_(compat.any(",pf=ipv6" in i for i in cmd))

            # IPv4 and IPv6
            opts = CmdBuilderConfig(host="localhost",
                                    port=6789,
                                    ipv4=True,
                                    ipv6=True)
            builder = impexpd.CommandBuilder(mode, opts, 1, 2, 3)
            self.assertRaises(AssertionError, builder._GetSocatCommand)
Exemplo n.º 3
0
    def testModeError(self):
        mode = "foobarbaz"

        assert mode not in [constants.IEM_IMPORT, constants.IEM_EXPORT]

        opts = CmdBuilderConfig(host="localhost", port=1234)
        builder = impexpd.CommandBuilder(mode, opts, 1, 2, 3)
        self.assertRaises(errors.GenericError, builder.GetCommand)
Exemplo n.º 4
0
    def testCommaError(self):
        opts = CmdBuilderConfig(host="localhost",
                                port=1234,
                                ca="/some/path/with,a/,comma")

        for mode in [constants.IEM_IMPORT, constants.IEM_EXPORT]:
            builder = impexpd.CommandBuilder(mode, opts, 1, 2, 3)
            self.assertRaises(errors.GenericError, builder.GetCommand)
Exemplo n.º 5
0
    def test(self):

        # The commands various compressions should use
        compress_import = {
            constants.IEC_GZIP: "gzip -d",
            constants.IEC_GZIP_FAST: "gzip -d",
            constants.IEC_GZIP_SLOW: "gzip -d",
            constants.IEC_LZOP: "lzop -d",
        }
        compress_export = {
            constants.IEC_GZIP: "gzip -1",
            constants.IEC_GZIP_FAST: "gzip -1",
            constants.IEC_GZIP_SLOW: "gzip",
            constants.IEC_LZOP: "lzop",
        }

        for mode in [constants.IEM_IMPORT, constants.IEM_EXPORT]:
            if mode == constants.IEM_IMPORT:
                compress_dict = compress_import
            elif mode == constants.IEM_EXPORT:
                compress_dict = compress_export

            for compress in constants.IEC_ALL:
                for magic in [
                        None, 10 * "-", "HelloWorld", "J9plh4nFo2",
                        "24A02A81-2264-4B51-A882-A2AB9D85B420"
                ]:
                    opts = CmdBuilderConfig(magic=magic, compress=compress)
                    builder = impexpd.CommandBuilder(mode, opts, 1, 2, 3)

                    magic_cmd = builder._GetMagicCommand()
                    dd_cmd = builder._GetDdCommand()

                    if magic:
                        self.assert_(("M=%s" % magic) in magic_cmd)
                        self.assert_(("M=%s" % magic) in dd_cmd)
                    else:
                        self.assertFalse(magic_cmd)

                for host in ["localhost", "198.51.100.4", "192.0.2.99"]:
                    for port in [0, 1, 1234, 7856, 45452]:
                        for cmd_prefix in [
                                None, "PrefixCommandGoesHere|",
                                "dd if=/dev/hda bs=1048576 |"
                        ]:
                            for cmd_suffix in [
                                    None, "< /some/file/name",
                                    "| dd of=/dev/null"
                            ]:
                                opts = CmdBuilderConfig(host=host,
                                                        port=port,
                                                        compress=compress,
                                                        cmd_prefix=cmd_prefix,
                                                        cmd_suffix=cmd_suffix)

                                builder = impexpd.CommandBuilder(
                                    mode, opts, 1, 2, 3)

                                # Check complete command
                                cmd = builder.GetCommand()
                                self.assert_(isinstance(cmd, list))

                                if compress != constants.IEC_NONE:
                                    self.assert_(
                                        CheckCmdWord(cmd,
                                                     compress_dict[compress]))

                                if cmd_prefix is not None:
                                    self.assert_(
                                        compat.any(cmd_prefix in i
                                                   for i in cmd))

                                if cmd_suffix is not None:
                                    self.assert_(
                                        compat.any(cmd_suffix in i
                                                   for i in cmd))

                                # Check socat command
                                socat_cmd = builder._GetSocatCommand()

                                if mode == constants.IEM_IMPORT:
                                    ssl_addr = socat_cmd[-2].split(",")
                                    self.assert_(("OPENSSL-LISTEN:%s" %
                                                  port) in ssl_addr)
                                elif mode == constants.IEM_EXPORT:
                                    ssl_addr = socat_cmd[-1].split(",")
                                    self.assert_(("OPENSSL:%s:%s" %
                                                  (host, port)) in ssl_addr)
                                    if impexpd.CommandBuilder._GetSocatVersion(
                                    ) >= (1, 7, 3):
                                        self.assert_(
                                            "openssl-commonname=%s" %
                                            constants.X509_CERT_CN in ssl_addr)
                                    else:
                                        self.assert_("openssl-commonname=%s" %
                                                     constants.X509_CERT_CN
                                                     not in ssl_addr)

                                self.assert_("verify=1" in ssl_addr)
Exemplo n.º 6
0
    def test(self):
        for mode in [constants.IEM_IMPORT, constants.IEM_EXPORT]:
            if mode == constants.IEM_IMPORT:
                comprcmd = "gunzip"
            elif mode == constants.IEM_EXPORT:
                comprcmd = "gzip"

            for compress in [constants.IEC_NONE, constants.IEC_GZIP]:
                for magic in [
                        None, 10 * "-", "HelloWorld", "J9plh4nFo2",
                        "24A02A81-2264-4B51-A882-A2AB9D85B420"
                ]:
                    opts = CmdBuilderConfig(magic=magic, compress=compress)
                    builder = impexpd.CommandBuilder(mode, opts, 1, 2, 3)

                    magic_cmd = builder._GetMagicCommand()
                    dd_cmd = builder._GetDdCommand()

                    if magic:
                        self.assert_(("M=%s" % magic) in magic_cmd)
                        self.assert_(("M=%s" % magic) in dd_cmd)
                    else:
                        self.assertFalse(magic_cmd)

                for host in ["localhost", "198.51.100.4", "192.0.2.99"]:
                    for port in [0, 1, 1234, 7856, 45452]:
                        for cmd_prefix in [
                                None, "PrefixCommandGoesHere|",
                                "dd if=/dev/hda bs=1048576 |"
                        ]:
                            for cmd_suffix in [
                                    None, "< /some/file/name",
                                    "| dd of=/dev/null"
                            ]:
                                opts = CmdBuilderConfig(host=host,
                                                        port=port,
                                                        compress=compress,
                                                        cmd_prefix=cmd_prefix,
                                                        cmd_suffix=cmd_suffix)

                                builder = impexpd.CommandBuilder(
                                    mode, opts, 1, 2, 3)

                                # Check complete command
                                cmd = builder.GetCommand()
                                self.assert_(isinstance(cmd, list))

                                if compress == constants.IEC_GZIP:
                                    self.assert_(CheckCmdWord(cmd, comprcmd))

                                if cmd_prefix is not None:
                                    self.assert_(
                                        compat.any(cmd_prefix in i
                                                   for i in cmd))

                                if cmd_suffix is not None:
                                    self.assert_(
                                        compat.any(cmd_suffix in i
                                                   for i in cmd))

                                # Check socat command
                                socat_cmd = builder._GetSocatCommand()

                                if mode == constants.IEM_IMPORT:
                                    ssl_addr = socat_cmd[-2].split(",")
                                    self.assert_(("OPENSSL-LISTEN:%s" %
                                                  port) in ssl_addr)
                                elif mode == constants.IEM_EXPORT:
                                    ssl_addr = socat_cmd[-1].split(",")
                                    self.assert_(("OPENSSL:%s:%s" %
                                                  (host, port)) in ssl_addr)

                                self.assert_("verify=1" in ssl_addr)