From d9ec85492933aec9257e947757f098d4ee006620 Mon Sep 17 00:00:00 2001 From: sthen Date: Tue, 18 Feb 2025 21:30:55 +0000 Subject: [PATCH] apply 2to3 conversions via patches rather than running during build --- net/nmap/Makefile | 4 +- net/nmap/patches/patch-ndiff_ndiff_py | 1169 +++++++++++++++++++- net/nmap/patches/patch-ndiff_ndifftest_py | 207 ++++ net/nmap/patches/patch-ndiff_scripts_ndiff | 27 + net/nmap/patches/patch-ndiff_setup_py | 67 +- 5 files changed, 1456 insertions(+), 18 deletions(-) create mode 100644 net/nmap/patches/patch-ndiff_ndifftest_py create mode 100644 net/nmap/patches/patch-ndiff_scripts_ndiff diff --git a/net/nmap/Makefile b/net/nmap/Makefile index 86c1fb53795..1f3db88444d 100644 --- a/net/nmap/Makefile +++ b/net/nmap/Makefile @@ -3,7 +3,7 @@ COMMENT-main= scan ports and fingerprint stack of network hosts MODPY_DISTV= 7.92 DISTNAME= nmap-${MODPY_DISTV} PKGNAME-main= ${DISTNAME} -REVISION-main= 0 +REVISION-main= 1 CATEGORIES= net security SITES= ${HOMEPAGE}/dist/ @@ -59,8 +59,6 @@ BUILD_DEPENDS= devel/bison \ post-extract: @cd ${WRKSRC} && rm -rf liblua/ libpcre/ - 2to3 --fix=all --no-diffs --nobackups --verbose --write \ - ${WRKSRC}/ndiff/*py ${WRKSRC}/ndiff/scripts/ndiff pre-configure: @cd ${WRKSRC}/nping ; env PATH=${PORTPATH} \ diff --git a/net/nmap/patches/patch-ndiff_ndiff_py b/net/nmap/patches/patch-ndiff_ndiff_py index 686b311234c..c5a5b74a668 100644 --- a/net/nmap/patches/patch-ndiff_ndiff_py +++ b/net/nmap/patches/patch-ndiff_ndiff_py @@ -1,36 +1,1183 @@ +apply 2to3 and additional fixes + Index: ndiff/ndiff.py --- ndiff/ndiff.py.orig +++ ndiff/ndiff.py -@@ -32,6 +32,8 @@ verbose = False +@@ -26,12 +26,14 @@ xml.__path__ = [x for x in xml.__path__ if "_xmlplus" + import xml.sax + import xml.sax.saxutils + import xml.dom.minidom +-from StringIO import StringIO ++from io import StringIO - NDIFF_XML_VERSION = "1" + verbose = False + +-NDIFF_XML_VERSION = u"1" ++NDIFF_XML_VERSION = "1" +def cmp(x, y): + return (x > y) - (x < y) class OverrideEntityResolver(xml.sax.handler.EntityResolver): """This class overrides the default behavior of xml.sax to download -@@ -160,11 +162,11 @@ class Host(object): +@@ -75,35 +77,35 @@ class Scan(object): + def write_nmaprun_open(self, writer): + attrs = {} + if self.scanner is not None: +- attrs[u"scanner"] = self.scanner ++ attrs["scanner"] = self.scanner + if self.args is not None: +- attrs[u"args"] = self.args ++ attrs["args"] = self.args + if self.start_date is not None: +- attrs[u"start"] = "%d" % time.mktime(self.start_date.timetuple()) +- attrs[u"startstr"] = self.start_date.strftime( ++ attrs["start"] = "%d" % time.mktime(self.start_date.timetuple()) ++ attrs["startstr"] = self.start_date.strftime( + "%a %b %d %H:%M:%S %Y") + if self.version is not None: +- attrs[u"version"] = self.version +- writer.startElement(u"nmaprun", attrs) ++ attrs["version"] = self.version ++ writer.startElement("nmaprun", attrs) + + def write_nmaprun_close(self, writer): +- writer.endElement(u"nmaprun") ++ writer.endElement("nmaprun") + + def nmaprun_to_dom_fragment(self, document): + frag = document.createDocumentFragment() +- elem = document.createElement(u"nmaprun") ++ elem = document.createElement("nmaprun") + if self.scanner is not None: +- elem.setAttribute(u"scanner", self.scanner) ++ elem.setAttribute("scanner", self.scanner) + if self.args is not None: +- elem.setAttribute(u"args", self.args) ++ elem.setAttribute("args", self.args) + if self.start_date is not None: + elem.setAttribute( +- u"start", "%d" % time.mktime(self.start_date.timetuple())) ++ "start", "%d" % time.mktime(self.start_date.timetuple())) + elem.setAttribute( +- u"startstr", ++ "startstr", + self.start_date.strftime("%a %b %d %H:%M:%S %Y")) + if self.version is not None: +- elem.setAttribute(u"version", self.version) ++ elem.setAttribute("version", self.version) + frag.appendChild(elem) + return frag + +@@ -133,17 +135,17 @@ class Host(object): + + def format_name(self): + """Return a human-readable identifier for this host.""" +- address_s = u", ".join(a.s for a in sorted(self.addresses)) +- hostname_s = u", ".join(sorted(self.hostnames)) ++ address_s = ", ".join(a.s for a in sorted(self.addresses)) ++ hostname_s = ", ".join(sorted(self.hostnames)) + if len(hostname_s) > 0: + if len(address_s) > 0: +- return u"%s (%s)" % (hostname_s, address_s) ++ return "%s (%s)" % (hostname_s, address_s) + else: + return hostname_s + elif len(address_s) > 0: + return address_s + else: +- return u"" ++ return "" + + def add_port(self, port): + self.ports[port.spec] = port +@@ -160,46 +162,46 @@ class Host(object): return state is None or state in self.extraports def extraports_string(self): -- list = [(count, state) for (state, count) in list(self.extraports.items())] +- list = [(count, state) for (state, count) in self.extraports.items()] + mylist = [(count, state) for (state, count) in list(self.extraports.items())] # Reverse-sort by count. - list.sort(reverse=True) +- return u", ".join( +- [u"%d %s ports" % (count, state) for (count, state) in list]) + mylist.sort(reverse=True) - return ", ".join( -- ["%d %s ports" % (count, state) for (count, state) in list]) ++ return ", ".join( + ["%d %s ports" % (count, state) for (count, state) in mylist]) def state_to_dom_fragment(self, document): frag = document.createDocumentFragment() -@@ -183,7 +185,7 @@ class Host(object): + if self.state is not None: +- elem = document.createElement(u"status") +- elem.setAttribute(u"state", self.state) ++ elem = document.createElement("status") ++ elem.setAttribute("state", self.state) + frag.appendChild(elem) + return frag + + def hostname_to_dom_fragment(self, document, hostname): + frag = document.createDocumentFragment() +- elem = document.createElement(u"hostname") +- elem.setAttribute(u"name", hostname) ++ elem = document.createElement("hostname") ++ elem.setAttribute("name", hostname) + frag.appendChild(elem) + return frag def extraports_to_dom_fragment(self, document): frag = document.createDocumentFragment() -- for state, count in list(self.extraports.items()): +- for state, count in self.extraports.items(): +- elem = document.createElement(u"extraports") +- elem.setAttribute(u"state", state) +- elem.setAttribute(u"count", unicode(count)) + for state, count in mylist(self.extraports.items()): - elem = document.createElement("extraports") - elem.setAttribute("state", state) - elem.setAttribute("count", str(count)) ++ elem = document.createElement("extraports") ++ elem.setAttribute("state", state) ++ elem.setAttribute("count", str(count)) + frag.appendChild(elem) + return frag + + def os_to_dom_fragment(self, document, os): + frag = document.createDocumentFragment() +- elem = document.createElement(u"osmatch") +- elem.setAttribute(u"name", os) ++ elem = document.createElement("osmatch") ++ elem.setAttribute("name", os) + frag.appendChild(elem) + return frag + + def to_dom_fragment(self, document): + frag = document.createDocumentFragment() +- elem = document.createElement(u"host") ++ elem = document.createElement("host") + + if self.state is not None: + elem.appendChild(self.state_to_dom_fragment(document)) +@@ -208,13 +210,13 @@ class Host(object): + elem.appendChild(addr.to_dom_fragment(document)) + + if len(self.hostnames) > 0: +- hostnames_elem = document.createElement(u"hostnames") ++ hostnames_elem = document.createElement("hostnames") + for hostname in self.hostnames: + hostnames_elem.appendChild( + self.hostname_to_dom_fragment(document, hostname)) + elem.appendChild(hostnames_elem) + +- ports_elem = document.createElement(u"ports") ++ ports_elem = document.createElement("ports") + ports_elem.appendChild(self.extraports_to_dom_fragment(document)) + for port in sorted(self.ports.values()): + if not self.is_extraports(port.state): +@@ -223,13 +225,13 @@ class Host(object): + elem.appendChild(ports_elem) + + if len(self.os) > 0: +- os_elem = document.createElement(u"os") ++ os_elem = document.createElement("os") + for os in self.os: + os_elem.appendChild(self.os_to_dom_fragment(document, os)) + elem.appendChild(os_elem) + + if len(self.script_results) > 0: +- hostscript_elem = document.createElement(u"hostscript") ++ hostscript_elem = document.createElement("hostscript") + for sr in self.script_results: + hostscript_elem.appendChild(sr.to_dom_fragment(document)) + elem.appendChild(hostscript_elem) +@@ -261,21 +263,21 @@ class Address(object): + return self.s + + def new(type, s): +- if type == u"ipv4": ++ if type == "ipv4": + return IPv4Address(s) +- elif type == u"ipv6": ++ elif type == "ipv6": + return IPv6Address(s) +- elif type == u"mac": ++ elif type == "mac": + return MACAddress(s) + else: +- raise ValueError(u"Unknown address type %s." % type) ++ raise ValueError("Unknown address type %s." % type) + new = staticmethod(new) + + def to_dom_fragment(self, document): + frag = document.createDocumentFragment() +- elem = document.createElement(u"address") +- elem.setAttribute(u"addr", self.s) +- elem.setAttribute(u"addrtype", self.type) ++ elem = document.createElement("address") ++ elem.setAttribute("addr", self.s) ++ elem.setAttribute("addrtype", self.type) + frag.appendChild(elem) + return frag + +@@ -284,21 +286,21 @@ class Address(object): + + + class IPv4Address(Address): +- type = property(lambda self: u"ipv4") ++ type = property(lambda self: "ipv4") + + def sort_key(self): + return (0, self.s) + + + class IPv6Address(Address): +- type = property(lambda self: u"ipv6") ++ type = property(lambda self: "ipv6") + + def sort_key(self): + return (1, self.s) + + + class MACAddress(Address): +- type = property(lambda self: u"mac") ++ type = property(lambda self: "mac") + + def sort_key(self): + return (2, self.s) +@@ -317,12 +319,12 @@ class Port(object): + + def state_string(self): + if self.state is None: +- return u"unknown" ++ return "unknown" + else: +- return unicode(self.state) ++ return str(self.state) + + def spec_string(self): +- return u"%d/%s" % self.spec ++ return "%d/%s" % self.spec + + def __hash__(self): + return hash(self.spec) +@@ -336,12 +338,12 @@ class Port(object): + + def to_dom_fragment(self, document): + frag = document.createDocumentFragment() +- elem = document.createElement(u"port") +- elem.setAttribute(u"portid", unicode(self.spec[0])) +- elem.setAttribute(u"protocol", self.spec[1]) ++ elem = document.createElement("port") ++ elem.setAttribute("portid", str(self.spec[0])) ++ elem.setAttribute("protocol", self.spec[1]) + if self.state is not None: +- state_elem = document.createElement(u"state") +- state_elem.setAttribute(u"state", self.state) ++ state_elem = document.createElement("state") ++ state_elem.setAttribute("state", self.state) + elem.appendChild(state_elem) + elem.appendChild(self.service.to_dom_fragment(document)) + for sr in self.script_results: +@@ -385,7 +387,7 @@ class Service(object): + if len(parts) == 0: + return None + else: +- return u"/".join(parts) ++ return "/".join(parts) + + def version_string(self): + """Get a string like in the VERSION column of Nmap output.""" +@@ -395,17 +397,17 @@ class Service(object): + if self.version is not None: + parts.append(self.version) + if self.extrainfo is not None: +- parts.append(u"(%s)" % self.extrainfo) ++ parts.append("(%s)" % self.extrainfo) + + if len(parts) == 0: + return None + else: +- return u" ".join(parts) ++ return " ".join(parts) + + def to_dom_fragment(self, document): + frag = document.createDocumentFragment() +- elem = document.createElement(u"service") +- for attr in (u"name", u"product", u"version", u"extrainfo", u"tunnel"): ++ elem = document.createElement("service") ++ for attr in ("name", "product", "version", "extrainfo", "tunnel"): + v = getattr(self, attr) + if v is None: + continue +@@ -435,53 +437,53 @@ class ScriptResult(object): + result = [] + lines = self.output.splitlines() + if len(lines) > 0: +- lines[0] = self.id + u": " + lines[0] ++ lines[0] = self.id + ": " + lines[0] + for line in lines[:-1]: +- result.append(u"| " + line) ++ result.append("| " + line) + if len(lines) > 0: +- result.append(u"|_ " + lines[-1]) ++ result.append("|_ " + lines[-1]) + return result + + def to_dom_fragment(self, document): + frag = document.createDocumentFragment() +- elem = document.createElement(u"script") +- elem.setAttribute(u"id", self.id) +- elem.setAttribute(u"output", self.output) ++ elem = document.createElement("script") ++ elem.setAttribute("id", self.id) ++ elem.setAttribute("output", self.output) + frag.appendChild(elem) + return frag + + + def format_banner(scan): + """Format a startup banner more or less like Nmap does.""" +- scanner = u"Nmap" +- if scan.scanner is not None and scan.scanner != u"nmap": ++ scanner = "Nmap" ++ if scan.scanner is not None and scan.scanner != "nmap": + scanner = scan.scanner + parts = [scanner] + if scan.version is not None: + parts.append(scan.version) +- parts.append(u"scan") ++ parts.append("scan") + if scan.start_date is not None: +- parts.append(u"initiated %s" % scan.start_date.strftime( ++ parts.append("initiated %s" % scan.start_date.strftime( + "%a %b %d %H:%M:%S %Y")) + if scan.args is not None: +- parts.append(u"as: %s" % scan.args) +- return u" ".join(parts) ++ parts.append("as: %s" % scan.args) ++ return " ".join(parts) + + + def print_script_result_diffs_text(title, script_results_a, script_results_b, + script_result_diffs, f=sys.stdout): +- table = Table(u"*") ++ table = Table("*") + for sr_diff in script_result_diffs: + sr_diff.append_to_port_table(table) + if len(table) > 0: +- print >> f ++ print(file=f) + if len(script_results_b) == 0: +- print >> f, u"-%s:" % title ++ print("-%s:" % title, file=f) + elif len(script_results_a) == 0: +- print >> f, u"+%s:" % title ++ print("+%s:" % title, file=f) + else: +- print >> f, u" %s:" % title +- print >> f, table ++ print(" %s:" % title, file=f) ++ print(table, file=f) + + + def script_result_diffs_to_dom_fragment(elem, script_results_a, +@@ -489,13 +491,13 @@ def script_result_diffs_to_dom_fragment(elem, script_r + if len(script_results_a) == 0 and len(script_results_b) == 0: + return document.createDocumentFragment() + elif len(script_results_b) == 0: +- a_elem = document.createElement(u"a") ++ a_elem = document.createElement("a") + for sr in script_results_a: + elem.appendChild(sr.to_dom_fragment(document)) + a_elem.appendChild(elem) + return a_elem + elif len(script_results_a) == 0: +- b_elem = document.createElement(u"b") ++ b_elem = document.createElement("b") + for sr in script_results_b: + elem.appendChild(sr.to_dom_fragment(document)) + b_elem.appendChild(elem) +@@ -580,10 +582,10 @@ class ScanDiffText(ScanDiff): + banner_a = format_banner(self.scan_a) + banner_b = format_banner(self.scan_b) + if banner_a != banner_b: +- print >> self.f, u"-%s" % banner_a +- print >> self.f, u"+%s" % banner_b ++ print("-%s" % banner_a, file=self.f) ++ print("+%s" % banner_b, file=self.f) + elif verbose: +- print >> self.f, u" %s" % banner_a ++ print(" %s" % banner_a, file=self.f) + + def output_pre_scripts(self, pre_script_result_diffs): + print_script_result_diffs_text("Pre-scan script results", +@@ -596,7 +598,7 @@ class ScanDiffText(ScanDiff): + post_script_result_diffs, self.f) + + def output_host_diff(self, h_diff): +- print >> self.f ++ print(file=self.f) + h_diff.print_text(self.f) + + def output_ending(self): +@@ -621,8 +623,8 @@ class ScanDiffXML(ScanDiff): + + def output_beginning(self): + self.writer.startDocument() +- self.writer.startElement(u"nmapdiff", {u"version": NDIFF_XML_VERSION}) +- self.writer.startElement(u"scandiff", {}) ++ self.writer.startElement("nmapdiff", {"version": NDIFF_XML_VERSION}) ++ self.writer.startElement("scandiff", {}) + + if self.nmaprun_differs(): + self.writer.frag_a( +@@ -635,7 +637,7 @@ class ScanDiffXML(ScanDiff): + + def output_pre_scripts(self, pre_script_result_diffs): + if len(pre_script_result_diffs) > 0 or verbose: +- prescript_elem = self.document.createElement(u"prescript") ++ prescript_elem = self.document.createElement("prescript") + frag = script_result_diffs_to_dom_fragment( + prescript_elem, self.scan_a.pre_script_results, + self.scan_b.pre_script_results, pre_script_result_diffs, +@@ -645,7 +647,7 @@ class ScanDiffXML(ScanDiff): + + def output_post_scripts(self, post_script_result_diffs): + if len(post_script_result_diffs) > 0 or verbose: +- postscript_elem = self.document.createElement(u"postscript") ++ postscript_elem = self.document.createElement("postscript") + frag = script_result_diffs_to_dom_fragment( + postscript_elem, self.scan_a.post_script_results, + self.scan_b.post_script_results, post_script_result_diffs, +@@ -659,8 +661,8 @@ class ScanDiffXML(ScanDiff): + frag.unlink() + + def output_ending(self): +- self.writer.endElement(u"scandiff") +- self.writer.endElement(u"nmapdiff") ++ self.writer.endElement("scandiff") ++ self.writer.endElement("nmapdiff") + self.writer.endDocument() + + +@@ -718,9 +720,9 @@ class HostDiff(object): + self.cost += os_cost + + extraports_a = tuple((count, state) +- for (state, count) in self.host_a.extraports.items()) ++ for (state, count) in list(self.host_a.extraports.items())) + extraports_b = tuple((count, state) +- for (state, count) in self.host_b.extraports.items()) ++ for (state, count) in list(self.host_b.extraports.items())) + if extraports_a != extraports_b: + self.extraports_changed = True + self.cost += 1 +@@ -746,69 +748,69 @@ class HostDiff(object): + # Names and addresses. + if self.id_changed: + if host_a.state is not None: +- print >> f, u"-%s:" % host_a.format_name() ++ print("-%s:" % host_a.format_name(), file=f) + if self.host_b.state is not None: +- print >> f, u"+%s:" % host_b.format_name() ++ print("+%s:" % host_b.format_name(), file=f) + else: +- print >> f, u" %s:" % host_a.format_name() ++ print(" %s:" % host_a.format_name(), file=f) + + # State. + if self.state_changed: + if host_a.state is not None: +- print >> f, u"-Host is %s." % host_a.state ++ print("-Host is %s." % host_a.state, file=f) + if host_b.state is not None: +- print >> f, u"+Host is %s." % host_b.state ++ print("+Host is %s." % host_b.state, file=f) + elif verbose: +- print >> f, u" Host is %s." % host_b.state ++ print(" Host is %s." % host_b.state, file=f) + + # Extraports. + if self.extraports_changed: + if len(host_a.extraports) > 0: +- print >> f, u"-Not shown: %s" % host_a.extraports_string() ++ print("-Not shown: %s" % host_a.extraports_string(), file=f) + if len(host_b.extraports) > 0: +- print >> f, u"+Not shown: %s" % host_b.extraports_string() ++ print("+Not shown: %s" % host_b.extraports_string(), file=f) + elif verbose: + if len(host_a.extraports) > 0: +- print >> f, u" Not shown: %s" % host_a.extraports_string() ++ print(" Not shown: %s" % host_a.extraports_string(), file=f) + + # Port table. +- port_table = Table(u"** * * *") ++ port_table = Table("** * * *") + if host_a.state is None: +- mark = u"+" ++ mark = "+" + elif host_b.state is None: +- mark = u"-" ++ mark = "-" + else: +- mark = u" " +- port_table.append((mark, u"PORT", u"STATE", u"SERVICE", u"VERSION")) ++ mark = " " ++ port_table.append((mark, "PORT", "STATE", "SERVICE", "VERSION")) + + for port in self.ports: + port_diff = self.port_diffs[port] + port_diff.append_to_port_table(port_table, host_a, host_b) + + if len(port_table) > 1: +- print >> f, port_table ++ print(port_table, file=f) + + # OS changes. + if self.os_changed or verbose: + if len(host_a.os) > 0: + if len(host_b.os) > 0: +- print >> f, u" OS details:" ++ print(" OS details:", file=f) + else: +- print >> f, u"-OS details:" ++ print("-OS details:", file=f) + elif len(host_b.os) > 0: +- print >> f, u"+OS details:" ++ print("+OS details:", file=f) + # os_diffs is a list of 5-tuples returned by + # difflib.SequenceMatcher. + for op, i1, i2, j1, j2 in self.os_diffs: + if op == "replace" or op == "delete": + for i in range(i1, i2): +- print >> f, "- %s" % host_a.os[i] ++ print("- %s" % host_a.os[i], file=f) + if op == "replace" or op == "insert": + for i in range(j1, j2): +- print >> f, "+ %s" % host_b.os[i] ++ print("+ %s" % host_b.os[i], file=f) + if op == "equal": + for i in range(i1, i2): +- print >> f, " %s" % host_a.os[i] ++ print(" %s" % host_a.os[i], file=f) + + print_script_result_diffs_text("Host script results", + host_a.script_results, host_b.script_results, +@@ -819,32 +821,32 @@ class HostDiff(object): + host_b = self.host_b + + frag = document.createDocumentFragment() +- hostdiff_elem = document.createElement(u"hostdiff") ++ hostdiff_elem = document.createElement("hostdiff") + frag.appendChild(hostdiff_elem) + + if host_a.state is None or host_b.state is None: + # The host is missing in one scan. Output the whole thing. + if host_a.state is not None: +- a_elem = document.createElement(u"a") ++ a_elem = document.createElement("a") + a_elem.appendChild(host_a.to_dom_fragment(document)) + hostdiff_elem.appendChild(a_elem) + elif host_b.state is not None: +- b_elem = document.createElement(u"b") ++ b_elem = document.createElement("b") + b_elem.appendChild(host_b.to_dom_fragment(document)) + hostdiff_elem.appendChild(b_elem) + return frag + +- host_elem = document.createElement(u"host") ++ host_elem = document.createElement("host") + + # State. + if host_a.state == host_b.state: + if verbose: + host_elem.appendChild(host_a.state_to_dom_fragment(document)) + else: +- a_elem = document.createElement(u"a") ++ a_elem = document.createElement("a") + a_elem.appendChild(host_a.state_to_dom_fragment(document)) + host_elem.appendChild(a_elem) +- b_elem = document.createElement(u"b") ++ b_elem = document.createElement("b") + b_elem.appendChild(host_b.state_to_dom_fragment(document)) + host_elem.appendChild(b_elem) + +@@ -853,31 +855,31 @@ class HostDiff(object): + addrset_b = set(host_b.addresses) + for addr in sorted(addrset_a.intersection(addrset_b)): + host_elem.appendChild(addr.to_dom_fragment(document)) +- a_elem = document.createElement(u"a") ++ a_elem = document.createElement("a") + for addr in sorted(addrset_a - addrset_b): + a_elem.appendChild(addr.to_dom_fragment(document)) + if a_elem.hasChildNodes(): + host_elem.appendChild(a_elem) +- b_elem = document.createElement(u"b") ++ b_elem = document.createElement("b") + for addr in sorted(addrset_b - addrset_a): + b_elem.appendChild(addr.to_dom_fragment(document)) + if b_elem.hasChildNodes(): + host_elem.appendChild(b_elem) + + # Host names. +- hostnames_elem = document.createElement(u"hostnames") ++ hostnames_elem = document.createElement("hostnames") + hostnameset_a = set(host_a.hostnames) + hostnameset_b = set(host_b.hostnames) + for hostname in sorted(hostnameset_a.intersection(hostnameset_b)): + hostnames_elem.appendChild( + host_a.hostname_to_dom_fragment(document, hostname)) +- a_elem = document.createElement(u"a") ++ a_elem = document.createElement("a") + for hostname in sorted(hostnameset_a - hostnameset_b): + a_elem.appendChild( + host_a.hostname_to_dom_fragment(document, hostname)) + if a_elem.hasChildNodes(): + hostnames_elem.appendChild(a_elem) +- b_elem = document.createElement(u"b") ++ b_elem = document.createElement("b") + for hostname in sorted(hostnameset_b - hostnameset_a): + b_elem.appendChild( + host_b.hostname_to_dom_fragment(document, hostname)) +@@ -886,15 +888,15 @@ class HostDiff(object): + if hostnames_elem.hasChildNodes(): + host_elem.appendChild(hostnames_elem) + +- ports_elem = document.createElement(u"ports") ++ ports_elem = document.createElement("ports") + # Extraports. + if host_a.extraports == host_b.extraports: + ports_elem.appendChild(host_a.extraports_to_dom_fragment(document)) + else: +- a_elem = document.createElement(u"a") ++ a_elem = document.createElement("a") + a_elem.appendChild(host_a.extraports_to_dom_fragment(document)) + ports_elem.appendChild(a_elem) +- b_elem = document.createElement(u"b") ++ b_elem = document.createElement("b") + b_elem.appendChild(host_b.extraports_to_dom_fragment(document)) + ports_elem.appendChild(b_elem) + # Port list. +@@ -910,18 +912,18 @@ class HostDiff(object): + + # OS changes. + if self.os_changed or verbose: +- os_elem = document.createElement(u"os") ++ os_elem = document.createElement("os") + # os_diffs is a list of 5-tuples returned by + # difflib.SequenceMatcher. + for op, i1, i2, j1, j2 in self.os_diffs: + if op == "replace" or op == "delete": +- a_elem = document.createElement(u"a") ++ a_elem = document.createElement("a") + for i in range(i1, i2): + a_elem.appendChild(host_a.os_to_dom_fragment( + document, host_a.os[i])) + os_elem.appendChild(a_elem) + if op == "replace" or op == "insert": +- b_elem = document.createElement(u"b") ++ b_elem = document.createElement("b") + for i in range(j1, j2): + b_elem.appendChild(host_b.os_to_dom_fragment( + document, host_b.os[i])) +@@ -935,7 +937,7 @@ class HostDiff(object): + + # Host script changes. + if len(self.script_result_diffs) > 0 or verbose: +- hostscript_elem = document.createElement(u"hostscript") ++ hostscript_elem = document.createElement("hostscript") + host_elem.appendChild(script_result_diffs_to_dom_fragment( + hostscript_elem, host_a.script_results, + host_b.script_results, self.script_result_diffs, +@@ -988,38 +990,38 @@ class PortDiff(object): + self.port_b.service.version_string()] + if a_columns == b_columns: + if verbose or self.script_result_diffs > 0: +- table.append([u" "] + a_columns) ++ table.append([" "] + a_columns) + else: + if not host_a.is_extraports(self.port_a.state): +- table.append([u"-"] + a_columns) ++ table.append(["-"] + a_columns) + if not host_b.is_extraports(self.port_b.state): +- table.append([u"+"] + b_columns) ++ table.append(["+"] + b_columns) + + for sr_diff in self.script_result_diffs: + sr_diff.append_to_port_table(table) + + def to_dom_fragment(self, document): + frag = document.createDocumentFragment() +- portdiff_elem = document.createElement(u"portdiff") ++ portdiff_elem = document.createElement("portdiff") + frag.appendChild(portdiff_elem) + if (self.port_a.spec == self.port_b.spec and + self.port_a.state == self.port_b.state): +- port_elem = document.createElement(u"port") +- port_elem.setAttribute(u"portid", unicode(self.port_a.spec[0])) +- port_elem.setAttribute(u"protocol", self.port_a.spec[1]) ++ port_elem = document.createElement("port") ++ port_elem.setAttribute("portid", str(self.port_a.spec[0])) ++ port_elem.setAttribute("protocol", self.port_a.spec[1]) + if self.port_a.state is not None: +- state_elem = document.createElement(u"state") +- state_elem.setAttribute(u"state", self.port_a.state) ++ state_elem = document.createElement("state") ++ state_elem.setAttribute("state", self.port_a.state) + port_elem.appendChild(state_elem) + if self.port_a.service == self.port_b.service: + port_elem.appendChild( + self.port_a.service.to_dom_fragment(document)) + else: +- a_elem = document.createElement(u"a") ++ a_elem = document.createElement("a") + a_elem.appendChild( + self.port_a.service.to_dom_fragment(document)) + port_elem.appendChild(a_elem) +- b_elem = document.createElement(u"b") ++ b_elem = document.createElement("b") + b_elem.appendChild( + self.port_b.service.to_dom_fragment(document)) + port_elem.appendChild(b_elem) +@@ -1027,10 +1029,10 @@ class PortDiff(object): + port_elem.appendChild(sr_diff.to_dom_fragment(document)) + portdiff_elem.appendChild(port_elem) + else: +- a_elem = document.createElement(u"a") ++ a_elem = document.createElement("a") + a_elem.appendChild(self.port_a.to_dom_fragment(document)) + portdiff_elem.appendChild(a_elem) +- b_elem = document.createElement(u"b") ++ b_elem = document.createElement("b") + b_elem.appendChild(self.port_b.to_dom_fragment(document)) + portdiff_elem.appendChild(b_elem) + +@@ -1085,13 +1087,13 @@ class ScriptResultDiff(object): + for op, i1, i2, j1, j2 in diffs.get_opcodes(): + if op == "replace" or op == "delete": + for k in range(i1, i2): +- table.append_raw(u"-" + a_lines[k]) ++ table.append_raw("-" + a_lines[k]) + if op == "replace" or op == "insert": + for k in range(j1, j2): +- table.append_raw(u"+" + b_lines[k]) ++ table.append_raw("+" + b_lines[k]) + if op == "equal": + for k in range(i1, i2): +- table.append_raw(u" " + a_lines[k]) ++ table.append_raw(" " + a_lines[k]) + + def to_dom_fragment(self, document): + frag = document.createDocumentFragment() +@@ -1101,11 +1103,11 @@ class ScriptResultDiff(object): + frag.appendChild(self.sr_a.to_dom_fragment(document)) + else: + if self.sr_a is not None: +- a_elem = document.createElement(u"a") ++ a_elem = document.createElement("a") + a_elem.appendChild(self.sr_a.to_dom_fragment(document)) + frag.appendChild(a_elem) + if self.sr_b is not None: +- b_elem = document.createElement(u"b") ++ b_elem = document.createElement("b") + b_elem.appendChild(self.sr_b.to_dom_fragment(document)) + frag.appendChild(b_elem) + return frag +@@ -1119,7 +1121,7 @@ class Table(object): + copied to the output.""" + self.widths = [] + self.rows = [] +- self.prefix = u"" ++ self.prefix = "" + self.padding = [] + j = 0 + while j < len(template) and template[j] != "*": +@@ -1144,7 +1146,7 @@ class Table(object): + + for i in range(len(row)): + if row[i] is None: +- s = u"" ++ s = "" + else: + s = str(row[i]) + if i == len(self.widths): +@@ -1166,7 +1168,7 @@ class Table(object): + for row in self.rows: + parts = [self.prefix] + i = 0 +- if isinstance(row, basestring): ++ if isinstance(row, str): + # A raw string. + lines.append(row) + else: +@@ -1175,13 +1177,13 @@ class Table(object): + if i < len(self.padding): + parts.append(self.padding[i]) + i += 1 +- lines.append(u"".join(parts).rstrip()) +- return u"\n".join(lines) ++ lines.append("".join(parts).rstrip()) ++ return "\n".join(lines) + + + def warn(str): + """Print a warning to stderr.""" +- print >> sys.stderr, str ++ print(str, file=sys.stderr) + + + class NmapContentHandler(xml.sax.handler.ContentHandler): +@@ -1201,24 +1203,24 @@ class NmapContentHandler(xml.sax.handler.ContentHandle + self.skip_over = False + + self._start_elem_handlers = { +- u"nmaprun": self._start_nmaprun, +- u"host": self._start_host, +- u"hosthint": self._start_hosthint, +- u"status": self._start_status, +- u"address": self._start_address, +- u"hostname": self._start_hostname, +- u"extraports": self._start_extraports, +- u"port": self._start_port, +- u"state": self._start_state, +- u"service": self._start_service, +- u"script": self._start_script, +- u"osmatch": self._start_osmatch, +- u"finished": self._start_finished, ++ "nmaprun": self._start_nmaprun, ++ "host": self._start_host, ++ "hosthint": self._start_hosthint, ++ "status": self._start_status, ++ "address": self._start_address, ++ "hostname": self._start_hostname, ++ "extraports": self._start_extraports, ++ "port": self._start_port, ++ "state": self._start_state, ++ "service": self._start_service, ++ "script": self._start_script, ++ "osmatch": self._start_osmatch, ++ "finished": self._start_finished, + } + self._end_elem_handlers = { +- u'host': self._end_host, +- u"hosthint": self._end_hosthint, +- u'port': self._end_port, ++ 'host': self._end_host, ++ "hosthint": self._end_hosthint, ++ 'port': self._end_port, + } + + def parent_element(self): +@@ -1248,72 +1250,72 @@ class NmapContentHandler(xml.sax.handler.ContentHandle + def _start_nmaprun(self, name, attrs): + assert self.parent_element() is None + if "start" in attrs: +- start_timestamp = int(attrs.get(u"start")) ++ start_timestamp = int(attrs.get("start")) + self.scan.start_date = datetime.datetime.fromtimestamp( + start_timestamp) +- self.scan.scanner = attrs.get(u"scanner") +- self.scan.args = attrs.get(u"args") +- self.scan.version = attrs.get(u"version") ++ self.scan.scanner = attrs.get("scanner") ++ self.scan.args = attrs.get("args") ++ self.scan.version = attrs.get("version") + + def _start_host(self, name, attrs): +- assert self.parent_element() == u"nmaprun" ++ assert self.parent_element() == "nmaprun" + self.current_host = Host() + self.scan.hosts.append(self.current_host) + + def _start_hosthint(self, name, attrs): +- assert self.parent_element() == u"nmaprun" ++ assert self.parent_element() == "nmaprun" + self.skip_over = True + + def _start_status(self, name, attrs): +- assert self.parent_element() == u"host" ++ assert self.parent_element() == "host" + assert self.current_host is not None +- state = attrs.get(u"state") ++ state = attrs.get("state") + if state is None: +- warn(u'%s element of host %s is missing the "state" attribute; ' +- 'assuming \unknown\.' % ( ++ warn('%s element of host %s is missing the "state" attribute; ' ++ 'assuming \\unknown\.' % ( + name, self.current_host.format_name())) + return + self.current_host.state = state + + def _start_address(self, name, attrs): +- assert self.parent_element() == u"host" ++ assert self.parent_element() == "host" + assert self.current_host is not None +- addr = attrs.get(u"addr") ++ addr = attrs.get("addr") + if addr is None: +- warn(u'%s element of host %s is missing the "addr" ' ++ warn('%s element of host %s is missing the "addr" ' + 'attribute; skipping.' % ( + name, self.current_host.format_name())) + return +- addrtype = attrs.get(u"addrtype", u"ipv4") ++ addrtype = attrs.get("addrtype", "ipv4") + self.current_host.add_address(Address.new(addrtype, addr)) + + def _start_hostname(self, name, attrs): +- assert self.parent_element() == u"hostnames" ++ assert self.parent_element() == "hostnames" + assert self.current_host is not None +- hostname = attrs.get(u"name") ++ hostname = attrs.get("name") + if hostname is None: +- warn(u'%s element of host %s is missing the "name" ' ++ warn('%s element of host %s is missing the "name" ' + 'attribute; skipping.' % ( + name, self.current_host.format_name())) + return + self.current_host.add_hostname(hostname) + + def _start_extraports(self, name, attrs): +- assert self.parent_element() == u"ports" ++ assert self.parent_element() == "ports" + assert self.current_host is not None +- state = attrs.get(u"state") ++ state = attrs.get("state") + if state is None: +- warn(u'%s element of host %s is missing the "state" ' ++ warn('%s element of host %s is missing the "state" ' + 'attribute; assuming "unknown".' % ( + name, self.current_host.format_name())) + state = None + if state in self.current_host.extraports: +- warn(u'Duplicate extraports state "%s" in host %s.' % ( ++ warn('Duplicate extraports state "%s" in host %s.' % ( + state, self.current_host.format_name())) + +- count = attrs.get(u"count") ++ count = attrs.get("count") + if count is None: +- warn(u'%s element of host %s is missing the "count" ' ++ warn('%s element of host %s is missing the "count" ' + 'attribute; assuming 0.' % ( + name, self.current_host.format_name())) + count = 0 +@@ -1321,99 +1323,99 @@ class NmapContentHandler(xml.sax.handler.ContentHandle + try: + count = int(count) + except ValueError: +- warn(u"Can't convert extraports count \"%s\" " ++ warn("Can't convert extraports count \"%s\" " + "to an integer in host %s; assuming 0." % ( +- attrs[u"count"], self.current_host.format_name())) ++ attrs["count"], self.current_host.format_name())) + count = 0 + self.current_host.extraports[state] = count + + def _start_port(self, name, attrs): +- assert self.parent_element() == u"ports" ++ assert self.parent_element() == "ports" + assert self.current_host is not None +- portid_str = attrs.get(u"portid") ++ portid_str = attrs.get("portid") + if portid_str is None: +- warn(u'%s element of host %s missing the "portid" ' ++ warn('%s element of host %s missing the "portid" ' + 'attribute; skipping.' % ( + name, self.current_host.format_name())) + return + try: + portid = int(portid_str) + except ValueError: +- warn(u"Can't convert portid \"%s\" to an integer " ++ warn("Can't convert portid \"%s\" to an integer " + "in host %s; skipping port." % ( + portid_str, self.current_host.format_name())) + return +- protocol = attrs.get(u"protocol") ++ protocol = attrs.get("protocol") + if protocol is None: +- warn(u'%s element of host %s missing the "protocol" ' ++ warn('%s element of host %s missing the "protocol" ' + 'attribute; skipping.' % ( + name, self.current_host.format_name())) + return + self.current_port = Port((portid, protocol)) + + def _start_state(self, name, attrs): +- assert self.parent_element() == u"port" ++ assert self.parent_element() == "port" + assert self.current_host is not None + if self.current_port is None: + return + if "state" not in attrs: +- warn(u'%s element of port %s is missing the "state" ' ++ warn('%s element of port %s is missing the "state" ' + 'attribute; assuming "unknown".' % ( + name, self.current_port.spec_string())) + return +- self.current_port.state = attrs[u"state"] ++ self.current_port.state = attrs["state"] + self.current_host.add_port(self.current_port) + + def _start_service(self, name, attrs): +- assert self.parent_element() == u"port" ++ assert self.parent_element() == "port" + assert self.current_host is not None + if self.current_port is None: + return +- self.current_port.service.name = attrs.get(u"name") +- self.current_port.service.product = attrs.get(u"product") +- self.current_port.service.version = attrs.get(u"version") +- self.current_port.service.extrainfo = attrs.get(u"extrainfo") +- self.current_port.service.tunnel = attrs.get(u"tunnel") ++ self.current_port.service.name = attrs.get("name") ++ self.current_port.service.product = attrs.get("product") ++ self.current_port.service.version = attrs.get("version") ++ self.current_port.service.extrainfo = attrs.get("extrainfo") ++ self.current_port.service.tunnel = attrs.get("tunnel") + + def _start_script(self, name, attrs): + result = ScriptResult() +- result.id = attrs.get(u"id") ++ result.id = attrs.get("id") + if result.id is None: +- warn(u'%s element missing the "id" attribute; skipping.' % name) ++ warn('%s element missing the "id" attribute; skipping.' % name) + return + +- result.output = attrs.get(u"output") ++ result.output = attrs.get("output") + if result.output is None: +- warn(u'%s element missing the "output" attribute; skipping.' ++ warn('%s element missing the "output" attribute; skipping.' + % name) + return +- if self.parent_element() == u"prescript": ++ if self.parent_element() == "prescript": + self.scan.pre_script_results.append(result) +- elif self.parent_element() == u"postscript": ++ elif self.parent_element() == "postscript": + self.scan.post_script_results.append(result) +- elif self.parent_element() == u"hostscript": ++ elif self.parent_element() == "hostscript": + self.current_host.script_results.append(result) +- elif self.parent_element() == u"port": ++ elif self.parent_element() == "port": + self.current_port.script_results.append(result) + else: +- warn(u"%s element not inside prescript, postscript, hostscript, " ++ warn("%s element not inside prescript, postscript, hostscript, " + "or port element; ignoring." % name) + return + + def _start_osmatch(self, name, attrs): +- assert self.parent_element() == u"os" ++ assert self.parent_element() == "os" + assert self.current_host is not None + if "name" not in attrs: +- warn(u'%s element of host %s is missing the "name" ' ++ warn('%s element of host %s is missing the "name" ' + 'attribute; skipping.' % ( + name, self.current_host.format_name())) + return +- self.current_host.os.append(attrs[u"name"]) ++ self.current_host.os.append(attrs["name"]) + + def _start_finished(self, name, attrs): +- assert self.parent_element() == u"runstats" ++ assert self.parent_element() == "runstats" + if "time" in attrs: +- end_timestamp = int(attrs.get(u"time")) ++ end_timestamp = int(attrs.get("time")) + self.scan.end_date = datetime.datetime.fromtimestamp(end_timestamp) + + def _end_host(self, name): +@@ -1435,23 +1437,23 @@ class XMLWriter (xml.sax.saxutils.XMLGenerator): + + def frag(self, frag): + for node in frag.childNodes: +- node.writexml(self.f, newl=u"\n") ++ node.writexml(self.f, newl="\n") + + def frag_a(self, frag): +- self.startElement(u"a", {}) ++ self.startElement("a", {}) + for node in frag.childNodes: +- node.writexml(self.f, newl=u"\n") +- self.endElement(u"a") ++ node.writexml(self.f, newl="\n") ++ self.endElement("a") + + def frag_b(self, frag): +- self.startElement(u"b", {}) ++ self.startElement("b", {}) + for node in frag.childNodes: +- node.writexml(self.f, newl=u"\n") +- self.endElement(u"b") ++ node.writexml(self.f, newl="\n") ++ self.endElement("b") + + + def usage(): +- print u"""\ ++ print("""\ + Usage: %s [option] FILE1 FILE2 + Compare two Nmap XML files and display a list of their differences. + Differences include host state changes, port state changes, and changes to +@@ -1461,7 +1463,7 @@ service and OS detection. + -v, --verbose also show hosts and ports that haven't changed. + --text display output in text format (default) + --xml display output in XML format\ +-""" % sys.argv[0] ++""" % sys.argv[0]) + + EXIT_EQUAL = 0 + EXIT_DIFFERENT = 1 +@@ -1469,8 +1471,8 @@ EXIT_ERROR = 2 + + + def usage_error(msg): +- print >> sys.stderr, u"%s: %s" % (sys.argv[0], msg) +- print >> sys.stderr, u"Try '%s -h' for help." % sys.argv[0] ++ print("%s: %s" % (sys.argv[0], msg), file=sys.stderr) ++ print("Try '%s -h' for help." % sys.argv[0], file=sys.stderr) + sys.exit(EXIT_ERROR) + + +@@ -1481,7 +1483,7 @@ def main(): + try: + opts, input_filenames = getopt.gnu_getopt( + sys.argv[1:], "hv", ["help", "text", "verbose", "xml"]) +- except getopt.GetoptError, e: ++ except getopt.GetoptError as e: + usage_error(e.msg) + for o, a in opts: + if o == "-h" or o == "--help": +@@ -1491,15 +1493,15 @@ def main(): + verbose = True + elif o == "--text": + if output_format is not None and output_format != "text": +- usage_error(u"contradictory output format options.") ++ usage_error("contradictory output format options.") + output_format = "text" + elif o == "--xml": + if output_format is not None and output_format != "xml": +- usage_error(u"contradictory output format options.") ++ usage_error("contradictory output format options.") + output_format = "xml" + + if len(input_filenames) != 2: +- usage_error(u"need exactly two input filenames.") ++ usage_error("need exactly two input filenames.") + + if output_format is None: + output_format = "text" +@@ -1512,8 +1514,8 @@ def main(): + scan_a.load_from_file(filename_a) + scan_b = Scan() + scan_b.load_from_file(filename_b) +- except IOError, e: +- print >> sys.stderr, u"Can't open file: %s" % str(e) ++ except IOError as e: ++ print("Can't open file: %s" % str(e), file=sys.stderr) + sys.exit(EXIT_ERROR) + + if output_format == "text": diff --git a/net/nmap/patches/patch-ndiff_ndifftest_py b/net/nmap/patches/patch-ndiff_ndifftest_py new file mode 100644 index 00000000000..749510d8e53 --- /dev/null +++ b/net/nmap/patches/patch-ndiff_ndifftest_py @@ -0,0 +1,207 @@ +apply 2to3 + +Index: ndiff/ndifftest.py +--- ndiff/ndifftest.py.orig ++++ ndiff/ndifftest.py +@@ -22,7 +22,7 @@ for x in dir(ndiff): + sys.dont_write_bytecode = dont_write_bytecode + del dont_write_bytecode + +-import StringIO ++import io + + + class scan_test(unittest.TestCase): +@@ -52,7 +52,7 @@ class scan_test(unittest.TestCase): + scan.load_from_file("test-scans/single.xml") + host = scan.hosts[0] + self.assertEqual(len(host.ports), 5) +- self.assertEqual(host.extraports.items(), [("filtered", 95)]) ++ self.assertEqual(list(host.extraports.items()), [("filtered", 95)]) + + def test_extraports_multi(self): + """Test that the correct number of known ports is returned when there +@@ -68,9 +68,9 @@ class scan_test(unittest.TestCase): + """Test that nmaprun information is recorded.""" + scan = Scan() + scan.load_from_file("test-scans/empty.xml") +- self.assertEqual(scan.scanner, u"nmap") +- self.assertEqual(scan.version, u"4.90RC2") +- self.assertEqual(scan.args, u"nmap -oX empty.xml -p 1-100") ++ self.assertEqual(scan.scanner, "nmap") ++ self.assertEqual(scan.version, "4.90RC2") ++ self.assertEqual(scan.args, "nmap -oX empty.xml -p 1-100") + + def test_addresses(self): + """Test that addresses are recorded.""" +@@ -84,7 +84,7 @@ class scan_test(unittest.TestCase): + scan = Scan() + scan.load_from_file("test-scans/simple.xml") + host = scan.hosts[0] +- self.assertEqual(host.hostnames, [u"scanme.nmap.org"]) ++ self.assertEqual(host.hostnames, ["scanme.nmap.org"]) + + def test_os(self): + """Test that OS information is recorded.""" +@@ -99,7 +99,7 @@ class scan_test(unittest.TestCase): + scan.load_from_file("test-scans/complex.xml") + host = scan.hosts[0] + self.assertTrue(len(host.script_results) > 0) +- self.assertTrue(len(host.ports[(22, u"tcp")].script_results) > 0) ++ self.assertTrue(len(host.ports[(22, "tcp")].script_results) > 0) + + # This test is commented out because Nmap XML doesn't store any information + # about down hosts, not even the fact that they are down. Recovering the list +@@ -128,16 +128,16 @@ class host_test(unittest.TestCase): + + def test_format_name(self): + h = Host() +- self.assertTrue(isinstance(h.format_name(), basestring)) +- h.add_address(IPv4Address(u"127.0.0.1")) +- self.assertTrue(u"127.0.0.1" in h.format_name()) ++ self.assertTrue(isinstance(h.format_name(), str)) ++ h.add_address(IPv4Address("127.0.0.1")) ++ self.assertTrue("127.0.0.1" in h.format_name()) + h.add_address(IPv6Address("::1")) +- self.assertTrue(u"127.0.0.1" in h.format_name()) +- self.assertTrue(u"::1" in h.format_name()) +- h.add_hostname(u"localhost") +- self.assertTrue(u"127.0.0.1" in h.format_name()) +- self.assertTrue(u"::1" in h.format_name()) +- self.assertTrue(u"localhost" in h.format_name()) ++ self.assertTrue("127.0.0.1" in h.format_name()) ++ self.assertTrue("::1" in h.format_name()) ++ h.add_hostname("localhost") ++ self.assertTrue("127.0.0.1" in h.format_name()) ++ self.assertTrue("::1" in h.format_name()) ++ self.assertTrue("localhost" in h.format_name()) + + def test_empty_get_port(self): + h = Host() +@@ -197,8 +197,8 @@ class host_test(unittest.TestCase): + h = s.hosts[0] + self.assertEqual(len(h.ports), 5) + self.assertEqual(len(h.extraports), 1) +- self.assertEqual(h.extraports.keys()[0], u"filtered") +- self.assertEqual(h.extraports.values()[0], 95) ++ self.assertEqual(list(h.extraports.keys())[0], "filtered") ++ self.assertEqual(list(h.extraports.values())[0], 95) + self.assertEqual(h.state, "up") + + +@@ -241,13 +241,13 @@ class port_test(unittest.TestCase): + """Test the Port class.""" + def test_spec_string(self): + p = Port((10, "tcp")) +- self.assertEqual(p.spec_string(), u"10/tcp") ++ self.assertEqual(p.spec_string(), "10/tcp") + p = Port((100, "ip")) +- self.assertEqual(p.spec_string(), u"100/ip") ++ self.assertEqual(p.spec_string(), "100/ip") + + def test_state_string(self): + p = Port((10, "tcp")) +- self.assertEqual(p.state_string(), u"unknown") ++ self.assertEqual(p.state_string(), "unknown") + + + class service_test(unittest.TestCase): +@@ -255,47 +255,47 @@ class service_test(unittest.TestCase): + def test_compare(self): + """Test that services with the same contents compare equal.""" + a = Service() +- a.name = u"ftp" +- a.product = u"FooBar FTP" +- a.version = u"1.1.1" +- a.tunnel = u"ssl" ++ a.name = "ftp" ++ a.product = "FooBar FTP" ++ a.version = "1.1.1" ++ a.tunnel = "ssl" + self.assertEqual(a, a) + b = Service() +- b.name = u"ftp" +- b.product = u"FooBar FTP" +- b.version = u"1.1.1" +- b.tunnel = u"ssl" ++ b.name = "ftp" ++ b.product = "FooBar FTP" ++ b.version = "1.1.1" ++ b.tunnel = "ssl" + self.assertEqual(a, b) +- b.name = u"http" ++ b.name = "http" + self.assertNotEqual(a, b) + c = Service() + self.assertNotEqual(a, c) + + def test_tunnel(self): + serv = Service() +- serv.name = u"http" +- serv.tunnel = u"ssl" +- self.assertEqual(serv.name_string(), u"ssl/http") ++ serv.name = "http" ++ serv.tunnel = "ssl" ++ self.assertEqual(serv.name_string(), "ssl/http") + + def test_version_string(self): + serv = Service() +- serv.product = u"FooBar" ++ serv.product = "FooBar" + self.assertTrue(len(serv.version_string()) > 0) + serv = Service() +- serv.version = u"1.2.3" ++ serv.version = "1.2.3" + self.assertTrue(len(serv.version_string()) > 0) + serv = Service() +- serv.extrainfo = u"misconfigured" ++ serv.extrainfo = "misconfigured" + self.assertTrue(len(serv.version_string()) > 0) + serv = Service() +- serv.product = u"FooBar" +- serv.version = u"1.2.3" ++ serv.product = "FooBar" ++ serv.version = "1.2.3" + # Must match Nmap output. + self.assertEqual(serv.version_string(), +- u"%s %s" % (serv.product, serv.version)) +- serv.extrainfo = u"misconfigured" ++ "%s %s" % (serv.product, serv.version)) ++ serv.extrainfo = "misconfigured" + self.assertEqual(serv.version_string(), +- u"%s %s (%s)" % (serv.product, serv.version, serv.extrainfo)) ++ "%s %s (%s)" % (serv.product, serv.version, serv.extrainfo)) + + + class ScanDiffSub(ScanDiff): +@@ -703,7 +703,7 @@ class scan_diff_xml_test(unittest.TestCase): + a.load_from_file("test-scans/empty.xml") + b = Scan() + b.load_from_file("test-scans/simple.xml") +- f = StringIO.StringIO() ++ f = io.StringIO() + self.scan_diff = ScanDiffXML(a, b, f) + self.scan_diff.output() + self.xml = f.getvalue() +@@ -712,8 +712,8 @@ class scan_diff_xml_test(unittest.TestCase): + def test_well_formed(self): + try: + document = xml.dom.minidom.parseString(self.xml) +- except Exception, e: +- self.fail(u"Parsing XML diff output caused the exception: %s" ++ except Exception as e: ++ self.fail("Parsing XML diff output caused the exception: %s" + % str(e)) + + +@@ -739,8 +739,8 @@ def host_apply_diff(host, diff): + host.os = diff.host_b.os[:] + + if diff.extraports_changed: +- for state in host.extraports.keys(): +- for port in host.ports.values(): ++ for state in list(host.extraports.keys()): ++ for port in list(host.ports.values()): + if port.state == state: + del host.ports[port.spec] + host.extraports = diff.host_b.extraports.copy() diff --git a/net/nmap/patches/patch-ndiff_scripts_ndiff b/net/nmap/patches/patch-ndiff_scripts_ndiff new file mode 100644 index 00000000000..4a67e7b6b80 --- /dev/null +++ b/net/nmap/patches/patch-ndiff_scripts_ndiff @@ -0,0 +1,27 @@ +apply 2to3 + +Index: ndiff/scripts/ndiff +--- ndiff/scripts/ndiff.orig ++++ ndiff/scripts/ndiff +@@ -67,15 +67,15 @@ if INSTALL_LIB is not None and is_secure_dir(INSTALL_L + + try: + import ndiff +-except ImportError, e: +- print >> sys.stderr, """\ ++except ImportError as e: ++ print("""\ + Could not import the ndiff module: %s. +-I checked in these directories:""" % repr(e.message) ++I checked in these directories:""" % repr(e.message), file=sys.stderr) + for dir in sys.path: +- print >> sys.stderr, " %s" % dir +- print >> sys.stderr, """\ ++ print(" %s" % dir, file=sys.stderr) ++ print("""\ + If you installed Ndiff in another directory, you may have to add the +-modules directory to the PYTHONPATH environment variable.""" ++modules directory to the PYTHONPATH environment variable.""", file=sys.stderr) + sys.exit(1) + + import ndiff diff --git a/net/nmap/patches/patch-ndiff_setup_py b/net/nmap/patches/patch-ndiff_setup_py index 44ba64fe622..bfb10d29f3a 100644 --- a/net/nmap/patches/patch-ndiff_setup_py +++ b/net/nmap/patches/patch-ndiff_setup_py @@ -1,11 +1,70 @@ +apply 2to3 and additional fixes + Index: ndiff/setup.py --- ndiff/setup.py.orig +++ ndiff/setup.py -@@ -306,7 +306,7 @@ class my_uninstall(distutils.cmd.Command): +@@ -94,7 +94,7 @@ class checked_install(distutils.command.install.instal + self.saved_prefix = sys.prefix + try: + distutils.command.install.install.finalize_options(self) +- except distutils.errors.DistutilsPlatformError, e: ++ except distutils.errors.DistutilsPlatformError as e: + raise distutils.errors.DistutilsPlatformError(str(e) + """ + Installing your distribution's python-dev package may solve this problem.""") - distutils.core.setup(name="ndiff", scripts=["scripts/ndiff"], - py_modules=["ndiff"], -- data_files=[("share/man/man1", ["docs/ndiff.1"])], +@@ -227,7 +227,7 @@ for dir in dirs: + uninstaller_file.close() + + # Set exec bit for uninstaller +- mode = ((os.stat(uninstaller_filename)[ST_MODE]) | 0555) & 07777 ++ mode = ((os.stat(uninstaller_filename)[ST_MODE]) | 0o555) & 0o7777 + os.chmod(uninstaller_filename, mode) + + def write_installed_files(self): +@@ -241,7 +241,7 @@ for dir in dirs: + with open(INSTALLED_FILES_NAME, "w") as f: + for output in self.get_installed_files(): + assert "\n" not in output +- print >> f, output ++ print(output, file=f) + + + class my_uninstall(distutils.cmd.Command): +@@ -263,7 +263,7 @@ class my_uninstall(distutils.cmd.Command): + # Read the list of installed files. + try: + f = open(INSTALLED_FILES_NAME, "r") +- except IOError, e: ++ except IOError as e: + if e.errno == errno.ENOENT: + log.error("Couldn't open the installation record '%s'. " + "Have you installed yet?" % INSTALLED_FILES_NAME) +@@ -286,7 +286,7 @@ class my_uninstall(distutils.cmd.Command): + try: + if not self.dry_run: + os.remove(file) +- except OSError, e: ++ except OSError as e: + log.error(str(e)) + # Delete the directories. First reverse-sort the normalized paths by + # length so that child directories are deleted before their parents. +@@ -297,16 +297,16 @@ class my_uninstall(distutils.cmd.Command): + log.info("Removing the directory '%s'." % dir) + if not self.dry_run: + os.rmdir(dir) +- except OSError, e: ++ except OSError as e: + if e.errno == errno.ENOTEMPTY: + log.info("Directory '%s' not empty; not removing." % dir) + else: + log.error(str(e)) + + +-distutils.core.setup(name=u"ndiff", scripts=[u"scripts/ndiff"], +- py_modules=[u"ndiff"], +- data_files=[(u"share/man/man1", [u"docs/ndiff.1"])], ++distutils.core.setup(name="ndiff", scripts=["scripts/ndiff"], ++ py_modules=["ndiff"], + data_files=[("man/man1", ["docs/ndiff.1"])], cmdclass={ "install_egg_info": null_command,