python/samba/test/dcerpc: Py3 port of samba.tests.dcerpc.raw_protocol

Port code to allow this test run with either py2 or py3
Signed-off-by: Noel Power <noel.power@suse.com>
Reviewed-by: Andrew Bartlett <abartlet@samba.org>

diff --git a/python/samba/tests/dcerpc/raw_protocol.py b/python/samba/tests/dcerpc/raw_protocol.py
index d000f040821b1efa9fc1b4e9a8e86c311c4400b8..4ee1cb3593d68de68b830aec9402a1413b1b2e41 100755 (executable)
--- a/python/samba/tests/dcerpc/raw_protocol.py
+++ b/python/samba/tests/dcerpc/raw_protocol.py
@@ -32,6 +32,7 @@ import samba.dcerpc.netlogon
 import struct
 from samba import gensec
 from samba.tests.dcerpc.raw_testcase import RawDCERPCTest
+from samba.compat import binary_type
 
 global_ndr_print = False
 global_hexdump = False
@@ -73,13 +74,13 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.ctx_list[0].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         # And now try a request
         req = self.generate_request(call_id=1,
                                     context_id=ctx1.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -118,7 +119,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.ctx_list[0].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         # And now try a alter context
         req = self.generate_alter(call_id=0, pfc_flags=req_pfc_flags, ctx_list=[ctx1])
@@ -140,13 +141,13 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.ctx_list[0].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         # And now try a request
         req = self.generate_request(call_id=1,
                                     context_id=ctx1.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -372,7 +373,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
         self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
         self.assertEquals(len(rep.u._pad), 3)
-        self.assertEquals(rep.u._pad, '\0' * 3)
+        self.assertEquals(rep.u._pad, b'\0' * 3)
 
     def test_invalid_auth_noctx(self):
         req = self.generate_bind(call_id=0)
@@ -387,7 +388,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
         self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
         self.assertEquals(len(rep.u._pad), 3)
-        self.assertEquals(rep.u._pad, '\0' * 3)
+        self.assertEquals(rep.u._pad, b'\0' * 3)
 
     def test_no_auth_valid_valid_request(self):
         ndr32 = base.transfer_syntax_ndr()
@@ -410,14 +411,14 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.secondary_address_size, 4)
         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
         self.assertEquals(len(rep.u._pad1), 2)
-        self.assertEquals(rep.u._pad1, '\0' * 2)
+        self.assertEquals(rep.u._pad1, b'\0' * 2)
         self.assertEquals(rep.u.num_results, 1)
         self.assertEquals(rep.u.ctx_list[0].result,
                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
         self.assertEquals(rep.u.ctx_list[0].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         # Send a bind again
         tsf2_list = [ndr32]
@@ -438,7 +439,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
         self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
         self.assertEquals(len(rep.u._pad), 3)
-        self.assertEquals(rep.u._pad, '\0' * 3)
+        self.assertEquals(rep.u._pad, b'\0' * 3)
 
         # wait for a disconnect
         rep = self.recv_pdu()
@@ -458,7 +459,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
         self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
         self.assertEquals(len(rep.u._pad), 3)
-        self.assertEquals(rep.u._pad, '\0' * 3)
+        self.assertEquals(rep.u._pad, b'\0' * 3)
 
         # wait for a disconnect
         rep = self.recv_pdu()
@@ -486,14 +487,14 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.secondary_address_size, 4)
         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
         self.assertEquals(len(rep.u._pad1), 2)
-        self.assertEquals(rep.u._pad1, '\0' * 2)
+        self.assertEquals(rep.u._pad1, b'\0' * 2)
         self.assertEquals(rep.u.num_results, 1)
         self.assertEquals(rep.u.ctx_list[0].result,
                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
         self.assertEquals(rep.u.ctx_list[0].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         # Send a alter
         req = self.generate_alter(call_id=1, ctx_list=[])
@@ -539,14 +540,14 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.secondary_address_size, 4)
         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
         self.assertEquals(len(rep.u._pad1), 2)
-        self.assertEquals(rep.u._pad1, '\0' * 2)
+        self.assertEquals(rep.u._pad1, b'\0' * 2)
         self.assertEquals(rep.u.num_results, 1)
         self.assertEquals(rep.u.ctx_list[0].result,
                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
         self.assertEquals(rep.u.ctx_list[0].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         # Send a alter
         req = self.generate_alter(call_id=1, ctx_list=[ctx1])
@@ -566,12 +567,12 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.ctx_list[0].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         req = self.generate_request(call_id=2,
                                     context_id=ctx1.context_id,
                                     opnum=0xffff,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
@@ -609,14 +610,14 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.secondary_address_size, 4)
         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
         self.assertEquals(len(rep.u._pad1), 2)
-        self.assertEquals(rep.u._pad1, '\0' * 2)
+        self.assertEquals(rep.u._pad1, b'\0' * 2)
         self.assertEquals(rep.u.num_results, 1)
         self.assertEquals(rep.u.ctx_list[0].result,
                           dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
         self.assertEquals(rep.u.ctx_list[0].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         # Send a alter
         req = self.generate_alter(call_id=1, ctx_list=[ctx1])
@@ -636,12 +637,12 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.ctx_list[0].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         req = self.generate_request(call_id=2,
                                     context_id=12345,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
@@ -674,7 +675,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.ctx_list[0].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
     def test_no_auth_presentation_ctx_invalid2(self):
         ndr32 = base.transfer_syntax_ndr()
@@ -699,7 +700,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
         self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
         self.assertEquals(len(rep.u._pad), 3)
-        self.assertEquals(rep.u._pad, '\0' * 3)
+        self.assertEquals(rep.u._pad, b'\0' * 3)
 
         # wait for a disconnect
         rep = self.recv_pdu()
@@ -729,14 +730,14 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.secondary_address_size, 4)
         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
         self.assertEquals(len(rep.u._pad1), 2)
-        self.assertEquals(rep.u._pad1, '\0' * 2)
+        self.assertEquals(rep.u._pad1, b'\0' * 2)
         self.assertEquals(rep.u.num_results, 1)
         self.assertEquals(rep.u.ctx_list[0].result,
                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
         self.assertEquals(rep.u.ctx_list[0].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         tsf1b_list = []
         ctx1b = dcerpc.ctx_list()
@@ -790,14 +791,14 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.secondary_address_size, 4)
         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
         self.assertEquals(len(rep.u._pad1), 2)
-        self.assertEquals(rep.u._pad1, '\0' * 2)
+        self.assertEquals(rep.u._pad1, b'\0' * 2)
         self.assertEquals(rep.u.num_results, 1)
         self.assertEquals(rep.u.ctx_list[0].result,
                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
         self.assertEquals(rep.u.ctx_list[0].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         # With a known but wrong syntax we get a protocol error
         # see test_no_auth_presentation_ctx_valid2
@@ -852,14 +853,14 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.secondary_address_size, 4)
         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
         self.assertEquals(len(rep.u._pad1), 2)
-        self.assertEquals(rep.u._pad1, '\0' * 2)
+        self.assertEquals(rep.u._pad1, b'\0' * 2)
         self.assertEquals(rep.u.num_results, 1)
         self.assertEquals(rep.u.ctx_list[0].result,
                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
         self.assertEquals(rep.u.ctx_list[0].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         # With a unknown but wrong syntaxes we get NO protocol error
         # see test_no_auth_presentation_ctx_invalid4
@@ -888,12 +889,12 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.ctx_list[0].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         req = self.generate_request(call_id=2,
                                     context_id=ctx1a.context_id,
                                     opnum=0xffff,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req.call_id,
@@ -930,14 +931,14 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.secondary_address_size, 4)
         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
         self.assertEquals(len(rep.u._pad1), 2)
-        self.assertEquals(rep.u._pad1, '\0' * 2)
+        self.assertEquals(rep.u._pad1, b'\0' * 2)
         self.assertEquals(rep.u.num_results, 1)
         self.assertEquals(rep.u.ctx_list[0].result,
                           dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
         self.assertEquals(rep.u.ctx_list[0].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         tsf0_list = [ndr32]
         ctx0 = dcerpc.ctx_list()
@@ -963,12 +964,12 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.ctx_list[0].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         req = self.generate_request(call_id=1,
                                     context_id=ctx0.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -1002,12 +1003,12 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.ctx_list[0].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         req = self.generate_request(call_id=1,
                                     context_id=ctx1.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -1041,12 +1042,12 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.ctx_list[0].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         req = self.generate_request(call_id=1,
                                     context_id=ctx2.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -1092,12 +1093,12 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.ctx_list[1].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[1].syntax, zero_syntax)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         req = self.generate_request(call_id=1,
                                     context_id=ctx3.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -1129,12 +1130,12 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.ctx_list[1].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[1].syntax, zero_syntax)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         req = self.generate_request(call_id=1,
                                     context_id=ctx4.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -1147,7 +1148,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         req = self.generate_request(call_id=1,
                                     context_id=ctx3.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -1179,12 +1180,12 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.ctx_list[1].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[1].syntax, zero_syntax)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         req = self.generate_request(call_id=1,
                                     context_id=ctx4.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -1197,7 +1198,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         req = self.generate_request(call_id=1,
                                     context_id=ctx3.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -1243,12 +1244,12 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.ctx_list[1].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[1].syntax, zero_syntax)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         req = self.generate_request(call_id=1,
                                     context_id=ctx5mgmt.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -1280,12 +1281,12 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.ctx_list[1].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[1].syntax, zero_syntax)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         req = self.generate_request(call_id=1,
                                     context_id=ctx5mgmt.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -1319,13 +1320,13 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.secondary_address_size, 4)
         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
         self.assertEquals(len(rep.u._pad1), 2)
-        self.assertEquals(rep.u._pad1, '\0' * 2)
+        self.assertEquals(rep.u._pad1, b'\0' * 2)
         self.assertEquals(rep.u.num_results, 1)
         self.assertEquals(rep.u.ctx_list[0].result,
                           dcerpc.DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK)
         self.assertEquals(rep.u.ctx_list[0].reason, features)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
     def test_no_auth_bind_time_none_ignore_additional(self):
         features1 = 0
@@ -1356,13 +1357,13 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.secondary_address_size, 4)
         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
         self.assertEquals(len(rep.u._pad1), 2)
-        self.assertEquals(rep.u._pad1, '\0' * 2)
+        self.assertEquals(rep.u._pad1, b'\0' * 2)
         self.assertEquals(rep.u.num_results, 1)
         self.assertEquals(rep.u.ctx_list[0].result,
                           dcerpc.DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK)
         self.assertEquals(rep.u.ctx_list[0].reason, features1)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
     def test_no_auth_bind_time_only_first(self):
         features1 = dcerpc.DCERPC_BIND_TIME_KEEP_CONNECTION_ON_ORPHAN
@@ -1391,14 +1392,14 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.secondary_address_size, 4)
         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
         self.assertEquals(len(rep.u._pad1), 2)
-        self.assertEquals(rep.u._pad1, '\0' * 2)
+        self.assertEquals(rep.u._pad1, b'\0' * 2)
         self.assertEquals(rep.u.num_results, 1)
         self.assertEquals(rep.u.ctx_list[0].result,
                           dcerpc.DCERPC_BIND_ACK_RESULT_PROVIDER_REJECTION)
         self.assertEquals(rep.u.ctx_list[0].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
     def test_no_auth_bind_time_twice(self):
         features1 = dcerpc.DCERPC_BIND_TIME_KEEP_CONNECTION_ON_ORPHAN
@@ -1434,7 +1435,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
         self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
         self.assertEquals(len(rep.u._pad), 3)
-        self.assertEquals(rep.u._pad, '\0' * 3)
+        self.assertEquals(rep.u._pad, b'\0' * 3)
 
         # wait for a disconnect
         rep = self.recv_pdu()
@@ -1465,13 +1466,13 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.secondary_address_size, 4)
         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
         self.assertEquals(len(rep.u._pad1), 2)
-        self.assertEquals(rep.u._pad1, '\0' * 2)
+        self.assertEquals(rep.u._pad1, b'\0' * 2)
         self.assertEquals(rep.u.num_results, 1)
         self.assertEquals(rep.u.ctx_list[0].result,
                           dcerpc.DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK)
         self.assertEquals(rep.u.ctx_list[0].reason, features)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
     def test_no_auth_bind_time_keep_on_orphan_ignore_additional(self):
         features1 = dcerpc.DCERPC_BIND_TIME_KEEP_CONNECTION_ON_ORPHAN
@@ -1501,13 +1502,13 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.secondary_address_size, 4)
         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
         self.assertEquals(len(rep.u._pad1), 2)
-        self.assertEquals(rep.u._pad1, '\0' * 2)
+        self.assertEquals(rep.u._pad1, b'\0' * 2)
         self.assertEquals(rep.u.num_results, 1)
         self.assertEquals(rep.u.ctx_list[0].result,
                           dcerpc.DCERPC_BIND_ACK_RESULT_NEGOTIATE_ACK)
         self.assertEquals(rep.u.ctx_list[0].reason, features1)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, zero_syntax)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
     def _test_auth_type_level_bind_nak(self, auth_type, auth_level, creds=None,
                                        reason=dcerpc.DCERPC_BIND_NAK_REASON_INVALID_AUTH_TYPE):
@@ -1530,7 +1531,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
                                                        auth_level=auth_level,
                                                        auth_context_id=auth_context_id,
                                                        g_auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY)
-            from_server = ""
+            from_server = b""
             (finished, to_server) = auth_context["gensec"].update(from_server)
             self.assertFalse(finished)
 
@@ -1539,7 +1540,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
                                            auth_context_id=auth_context["auth_context_id"],
                                            auth_blob=to_server)
         else:
-            to_server = "none"
+            to_server = b"none"
             auth_info = self.generate_auth(auth_type=auth_type,
                                            auth_level=auth_level,
                                            auth_context_id=auth_context_id,
@@ -1557,7 +1558,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
         self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
         self.assertEquals(len(rep.u._pad), 3)
-        self.assertEquals(rep.u._pad, '\0' * 3)
+        self.assertEquals(rep.u._pad, b'\0' * 3)
 
         # wait for a disconnect
         rep = self.recv_pdu()
@@ -1626,7 +1627,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.secondary_address_size, 4)
         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
         self.assertEquals(len(rep.u._pad1), 2)
-        self.assertEquals(rep.u._pad1, '\0' * 2)
+        self.assertEquals(rep.u._pad1, b'\0' * 2)
         self.assertEquals(rep.u.num_results, 1)
         self.assertEquals(rep.u.ctx_list[0].result,
                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
@@ -1639,7 +1640,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         req = self.generate_request(call_id=2,
                                     context_id=ctx1.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -1652,12 +1653,12 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_info = self.generate_auth(auth_type=auth_type,
                                        auth_level=auth_level,
                                        auth_context_id=auth_context_id,
-                                       auth_blob="none")
+                                       auth_blob=b"none")
 
         req = self.generate_request(call_id=3,
                                     context_id=ctx1.context_id,
                                     opnum=0,
-                                    stub="",
+                                    stub=b"",
                                     auth_info=auth_info)
         self.send_pdu(req)
         rep = self.recv_pdu()
@@ -1715,14 +1716,14 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.secondary_address_size, 4)
         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
         self.assertEquals(len(rep.u._pad1), 2)
-        self.assertEquals(rep.u._pad1, '\0' * 2)
+        self.assertEquals(rep.u._pad1, b'\0' * 2)
         self.assertEquals(rep.u.num_results, 1)
         self.assertEquals(rep.u.ctx_list[0].result,
                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
         self.assertEquals(rep.u.ctx_list[0].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         assoc_group_id = rep.u.assoc_group_id
         if alter_xmit is None:
@@ -1753,14 +1754,14 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.ctx_list[0].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         chunk_size = rep_both - dcerpc.DCERPC_REQUEST_LENGTH
         req = self.generate_request(call_id=2,
                                     context_id=ctx1.context_id,
                                     opnum=0,
                                     alloc_hint=0xffffffff,
-                                    stub="\00" * chunk_size)
+                                    stub=b"\00" * chunk_size)
         self.send_pdu(req, ndr_print=True, hexdump=True)
         rep = self.recv_pdu(ndr_print=True, hexdump=True)
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -1775,7 +1776,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
                                     context_id=ctx1.context_id,
                                     opnum=0,
                                     alloc_hint=0xffffffff,
-                                    stub="\00" * chunk_size)
+                                    stub=b"\00" * chunk_size)
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -1790,7 +1791,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
                                     context_id=ctx1.context_id,
                                     opnum=0,
                                     alloc_hint=0xffffffff,
-                                    stub="\00" * chunk_size)
+                                    stub=b"\00" * chunk_size)
         self.send_pdu(req)
         rep = self.recv_pdu()
         # We get a fault
@@ -1875,21 +1876,21 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.secondary_address_size, 4)
         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
         self.assertEquals(len(rep.u._pad1), 2)
-        self.assertEquals(rep.u._pad1, '\0' * 2)
+        self.assertEquals(rep.u._pad1, b'\0' * 2)
         self.assertEquals(rep.u.num_results, 1)
         self.assertEquals(rep.u.ctx_list[0].result,
                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
         self.assertEquals(rep.u.ctx_list[0].reason,
                           dcerpc.DCERPC_BIND_ACK_REASON_NOT_SPECIFIED)
         self.assertNDRSyntaxEquals(rep.u.ctx_list[0].syntax, ndr32)
-        self.assertEquals(rep.u.auth_info, '\0' * 0)
+        self.assertEquals(rep.u.auth_info, b'\0' * 0)
 
         # And now try a request without auth_info
         req = self.generate_request(call_id=2,
                                     context_id=ctx.context_id,
                                     opnum=0,
                                     alloc_hint=0xffffffff,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -1903,7 +1904,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
                                     context_id=ctx.context_id,
                                     opnum=1,
                                     alloc_hint=0xffffffff,
-                                    stub="\04\00\00\00\00\00\00\00")
+                                    stub=b"\04\00\00\00\00\00\00\00")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -1917,7 +1918,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
                                     context_id=ctx.context_id,
                                     opnum=1,
                                     alloc_hint=1,
-                                    stub="\04\00\00\00\00\00\00\00")
+                                    stub=b"\04\00\00\00\00\00\00\00")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -1935,20 +1936,26 @@ class TestDCERPC_BIND(RawDCERPCTest):
                                                epmap=True, return_ack=True)
 
         server = '\\\\' + self.target_hostname
-        server_utf16 = unicode(server, 'utf-8').encode('utf-16-le')
+        if isinstance(server, binary_type):
+            server_utf16 = server.decode('utf-8').encode('utf-16-le')
+        else:
+            server_utf16 = server.encode('utf-16-le')
         computer = 'UNKNOWNCOMPUTER'
-        computer_utf16 = unicode(computer, 'utf-8').encode('utf-16-le')
+        if isinstance(server, binary_type):
+            computer_utf16 = computer.decode('utf-8').encode('utf-16-le')
+        else:
+            computer_utf16 = computer.encode('utf-16-le')
 
         real_stub = struct.pack('<IIII', 0x00200000,
                                  len(server) + 1, 0, len(server) + 1)
-        real_stub += server_utf16 + '\x00\x00'
+        real_stub += server_utf16 + b'\x00\x00'
         mod_len = len(real_stub) % 4
         if mod_len != 0:
-            real_stub += '\x00' * (4 - mod_len)
+            real_stub += b'\x00' * (4 - mod_len)
         real_stub += struct.pack('<III',
                                  len(computer) + 1, 0, len(computer) + 1)
-        real_stub += computer_utf16 + '\x00\x00'
-        real_stub += '\x11\x22\x33\x44\x55\x66\x77\x88'
+        real_stub += computer_utf16 + b'\x00\x00'
+        real_stub += b'\x11\x22\x33\x44\x55\x66\x77\x88'
 
         return (ctx, ack, real_stub)
 
@@ -1969,9 +1976,9 @@ class TestDCERPC_BIND(RawDCERPCTest):
             if first:
                 pfc_flags |= dcerpc.DCERPC_PFC_FLAG_FIRST
                 first = False
-                stub = real_stub + '\x00' * (thistime - len(real_stub))
+                stub = real_stub + b'\x00' * (thistime - len(real_stub))
             else:
-                stub = "\x00" * thistime
+                stub = b"\x00" * thistime
 
             if remaining == 0:
                 pfc_flags |= dcerpc.DCERPC_PFC_FLAG_LAST
@@ -2336,7 +2343,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         req = self.generate_request(call_id=1,
                                     context_id=ctx.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -2355,7 +2362,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
                                     pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
                                     context_id=ctx.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu(timeout=0.01)
         self.assertIsNone(rep)
@@ -2371,7 +2378,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
                                     pfc_flags=dcerpc.DCERPC_PFC_FLAG_LAST,
                                     context_id=ctx.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -2385,7 +2392,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         req = self.generate_request(call_id=2,
                                     context_id=ctx.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -2410,7 +2417,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         req = self.generate_request(call_id=1,
                                     context_id=ctx.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -2429,7 +2436,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
                                     pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
                                     context_id=ctx.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu(timeout=0.1)
         self.assertIsNone(rep)
@@ -2445,7 +2452,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
                                     pfc_flags=dcerpc.DCERPC_PFC_FLAG_LAST,
                                     context_id=ctx.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -2459,7 +2466,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         req = self.generate_request(call_id=2,
                                     context_id=ctx.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -2482,7 +2489,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
                                     pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
                                     context_id=ctx.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu(timeout=0.1)
         self.assertIsNone(rep)
@@ -2498,7 +2505,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
                                     pfc_flags=dcerpc.DCERPC_PFC_FLAG_LAST,
                                     context_id=ctx.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -2512,7 +2519,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         req = self.generate_request(call_id=2,
                                     context_id=ctx.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -2531,7 +2538,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
                                      pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
                                      context_id=ctx.context_id,
                                      opnum=0,
-                                     stub="")
+                                     stub=b"")
         self.send_pdu(req1)
         rep = self.recv_pdu(timeout=0.1)
         self.assertIsNone(rep)
@@ -2547,7 +2554,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         req2 = self.generate_request(call_id=2,
                                      context_id=ctx.context_id,
                                      opnum=0,
-                                     stub="")
+                                     stub=b"")
         self.send_pdu(req2)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req1.call_id,
@@ -2579,7 +2586,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
                                      pfc_flags=dcerpc.DCERPC_PFC_FLAG_FIRST,
                                      context_id=ctx.context_id,
                                      opnum=0,
-                                     stub="")
+                                     stub=b"")
         self.send_pdu(req1)
         rep = self.recv_pdu(timeout=0.1)
         self.assertIsNone(rep)
@@ -2595,7 +2602,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         req2 = self.generate_request(call_id=2,
                                      context_id=ctx.context_id - 1,
                                      opnum=0,
-                                     stub="")
+                                     stub=b"")
         self.send_pdu(req2)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_FAULT, req2.call_id,
@@ -2632,7 +2639,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
         auth_context_id = 2
         g.start_mech_by_authtype(auth_type, auth_level)
-        from_server = ""
+        from_server = b""
         (finished, to_server) = g.update(from_server)
         self.assertFalse(finished)
 
@@ -2654,7 +2661,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.secondary_address_size, 4)
         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
         self.assertEquals(len(rep.u._pad1), 2)
-        self.assertEquals(rep.u._pad1, '\0' * 2)
+        self.assertEquals(rep.u._pad1, b'\0' * 2)
         self.assertEquals(rep.u.num_results, 1)
         self.assertEquals(rep.u.ctx_list[0].result,
                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
@@ -2705,7 +2712,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         req = self.generate_request(call_id=2,
                                     context_id=ctx1.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -2719,11 +2726,11 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_info = self.generate_auth(auth_type=auth_type,
                                        auth_level=auth_level,
                                        auth_context_id=auth_context_id,
-                                       auth_blob="\x01" +"\x00" *15)
+                                       auth_blob=b"\x01" +b"\x00" *15)
         req = self.generate_request(call_id=3,
                                     context_id=ctx1.context_id,
                                     opnum=0,
-                                    stub="",
+                                    stub=b"",
                                     auth_info=auth_info)
         self.send_pdu(req)
         rep = self.recv_pdu()
@@ -2739,11 +2746,11 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_info = self.generate_auth(auth_type=auth_type,
                                        auth_level=dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY,
                                        auth_context_id=auth_context_id,
-                                       auth_blob="\x01" + "\x00" * 15)
+                                       auth_blob=b"\x01" + b"\x00" * 15)
         req = self.generate_request(call_id=4,
                                     context_id=ctx1.context_id,
                                     opnum=0,
-                                    stub="",
+                                    stub=b"",
                                     auth_info=auth_info)
         self.send_pdu(req)
         rep = self.recv_pdu()
@@ -2782,7 +2789,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_level = dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY
         auth_context_id = 2
         g.start_mech_by_authtype(auth_type, auth_level)
-        from_server = ""
+        from_server = b""
         (finished, to_server) = g.update(from_server)
         self.assertFalse(finished)
 
@@ -2804,7 +2811,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.secondary_address_size, 4)
         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
         self.assertEquals(len(rep.u._pad1), 2)
-        self.assertEquals(rep.u._pad1, '\0' * 2)
+        self.assertEquals(rep.u._pad1, b'\0' * 2)
         self.assertEquals(rep.u.num_results, 1)
         self.assertEquals(rep.u.ctx_list[0].result,
                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
@@ -2855,11 +2862,11 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_info = self.generate_auth(auth_type=auth_type,
                                        auth_level=dcerpc.DCERPC_AUTH_LEVEL_CONNECT,
                                        auth_context_id=auth_context_id,
-                                       auth_blob="\x01" + "\x00" * 15)
+                                       auth_blob=b"\x01" + b"\x00" * 15)
         req = self.generate_request(call_id=3,
                                     context_id=ctx1.context_id,
                                     opnum=0,
-                                    stub="",
+                                    stub=b"",
                                     auth_info=auth_info)
         self.send_pdu(req)
         rep = self.recv_pdu()
@@ -2898,7 +2905,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
         auth_context_id = 2
         g.start_mech_by_authtype(auth_type, auth_level)
-        from_server = ""
+        from_server = b""
         (finished, to_server) = g.update(from_server)
         self.assertFalse(finished)
 
@@ -2921,7 +2928,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.secondary_address_size, 4)
         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
         self.assertEquals(len(rep.u._pad1), 2)
-        self.assertEquals(rep.u._pad1, '\0' * 2)
+        self.assertEquals(rep.u._pad1, b'\0' * 2)
         self.assertEquals(rep.u.num_results, 1)
         self.assertEquals(rep.u.ctx_list[0].result,
                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
@@ -2939,11 +2946,11 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_info = self.generate_auth(auth_type=auth_type,
                                        auth_level=auth_level,
                                        auth_context_id=auth_context_id,
-                                       auth_blob="\x01" + "\x00" * 15)
+                                       auth_blob=b"\x01" + b"\x00" * 15)
         req = self.generate_request(call_id=1,
                                     context_id=ctx1.context_id,
                                     opnum=0,
-                                    stub="",
+                                    stub=b"",
                                     auth_info=auth_info)
         self.send_pdu(req)
         rep = self.recv_pdu()
@@ -2984,7 +2991,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
         auth_context_id = 2
         g.start_mech_by_authtype(auth_type, auth_level)
-        from_server = ""
+        from_server = b""
         (finished, to_server) = g.update(from_server)
         self.assertFalse(finished)
 
@@ -3033,7 +3040,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         req = self.generate_request(call_id=2,
                                     context_id=ctx1.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         # We get a fault back
@@ -3072,7 +3079,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
         auth_context_id = 2
         g.start_mech_by_authtype(auth_type, auth_level)
-        from_server = ""
+        from_server = b""
         (finished, to_server) = g.update(from_server)
         self.assertFalse(finished)
 
@@ -3094,7 +3101,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.secondary_address_size, 4)
         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
         self.assertEquals(len(rep.u._pad1), 2)
-        self.assertEquals(rep.u._pad1, '\0' * 2)
+        self.assertEquals(rep.u._pad1, b'\0' * 2)
         self.assertEquals(rep.u.num_results, 1)
         self.assertEquals(rep.u.ctx_list[0].result,
                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
@@ -3143,7 +3150,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         req = self.generate_request(call_id=2,
                                     context_id=ctx1.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -3157,11 +3164,11 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_info = self.generate_auth(auth_type=auth_type,
                                        auth_level=auth_level,
                                        auth_context_id=auth_context_id,
-                                       auth_blob="\x01" + "\x00" * 15)
+                                       auth_blob=b"\x01" + b"\x00" * 15)
         req = self.generate_request(call_id=3,
                                     context_id=ctx1.context_id,
                                     opnum=0,
-                                    stub="",
+                                    stub=b"",
                                     auth_info=auth_info)
         self.send_pdu(req)
         rep = self.recv_pdu()
@@ -3182,7 +3189,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
         auth_context_id = 2
         g.start_mech_by_authtype(auth_type, auth_level)
-        from_server = ""
+        from_server = b""
         (finished, to_server) = g.update(from_server)
         self.assertFalse(finished)
 
@@ -3233,7 +3240,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
         auth_context_id = 2
         g.start_mech_by_authtype(auth_type, auth_level)
-        from_server = ""
+        from_server = b""
         (finished, to_server) = g.update(from_server)
         self.assertFalse(finished)
 
@@ -3255,7 +3262,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.secondary_address_size, 4)
         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
         self.assertEquals(len(rep.u._pad1), 2)
-        self.assertEquals(rep.u._pad1, '\0' * 2)
+        self.assertEquals(rep.u._pad1, b'\0' * 2)
         self.assertEquals(rep.u.num_results, 1)
         self.assertEquals(rep.u.ctx_list[0].result,
                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
@@ -3304,7 +3311,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         req = self.generate_request(call_id=2,
                                     context_id=ctx1.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -3318,11 +3325,11 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_info = self.generate_auth(auth_type=auth_type,
                                        auth_level=auth_level,
                                        auth_context_id=auth_context_id,
-                                       auth_blob="\x01" + "\x00" * 15)
+                                       auth_blob=b"\x01" + b"\x00" * 15)
         req = self.generate_request(call_id=3,
                                     context_id=ctx1.context_id,
                                     opnum=0,
-                                    stub="",
+                                    stub=b"",
                                     auth_info=auth_info)
         self.send_pdu(req)
         rep = self.recv_pdu()
@@ -3343,7 +3350,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
         auth_context_id = 2
         g.start_mech_by_authtype(auth_type, auth_level)
-        from_server = ""
+        from_server = b""
         (finished, to_server) = g.update(from_server)
         self.assertFalse(finished)
 
@@ -3391,7 +3398,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_level = dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY
         auth_context_id = 2
         g.start_mech_by_authtype(auth_type, auth_level)
-        from_server = ""
+        from_server = b""
         (finished, to_server) = g.update(from_server)
         self.assertFalse(finished)
 
@@ -3411,7 +3418,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.secondary_address_size, 4)
         self.assertEquals(rep.u.secondary_address, "%d" % self.tcp_port)
         self.assertEquals(len(rep.u._pad1), 2)
-        self.assertEquals(rep.u._pad1, '\0' * 2)
+        self.assertEquals(rep.u._pad1, b'\0' * 2)
         self.assertEquals(rep.u.num_results, 1)
         self.assertEquals(rep.u.ctx_list[0].result,
                           dcerpc.DCERPC_BIND_ACK_RESULT_ACCEPTANCE)
@@ -3476,7 +3483,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_level = dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY
         auth_context_id = 2
         g.start_mech_by_authtype(auth_type, auth_level)
-        from_server = ""
+        from_server = b""
         (finished, to_server) = g.update(from_server)
         self.assertFalse(finished)
 
@@ -3563,7 +3570,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_level = dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY
         auth_context_id = 2
         g.start_mech_by_authtype(auth_type, auth_level)
-        from_server = ""
+        from_server = b""
         (finished, to_server) = g.update(from_server)
         self.assertFalse(finished)
 
@@ -3644,7 +3651,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_level = dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY
         auth_context_id = 2
         g.start_mech_by_authtype(auth_type, auth_level)
-        from_server = ""
+        from_server = b""
         (finished, to_server) = g.update(from_server)
         self.assertFalse(finished)
 
@@ -3732,7 +3739,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_level = dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY
         auth_context_id = 2
         g.start_mech_by_authtype(auth_type, auth_level)
-        from_server = ""
+        from_server = b""
         (finished, to_server) = g.update(from_server)
         self.assertFalse(finished)
 
@@ -3820,7 +3827,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_level = dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY
         auth_context_id = 2
         g.start_mech_by_authtype(auth_type, auth_level)
-        from_server = ""
+        from_server = b""
         (finished, to_server) = g.update(from_server)
         self.assertFalse(finished)
 
@@ -3901,7 +3908,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
         auth_context_id = 2
         g.start_mech_by_authtype(auth_type, auth_level)
-        from_server = ""
+        from_server = b""
         (finished, to_server) = g.update(from_server)
         self.assertFalse(finished)
 
@@ -4002,7 +4009,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         req = self.generate_request(call_id=2,
                                     context_id=ctx1.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -4016,11 +4023,11 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_info = self.generate_auth(auth_type=auth_type,
                                        auth_level=auth_level,
                                        auth_context_id=auth_context_id,
-                                       auth_blob="\x01" + "\x00" * 15)
+                                       auth_blob=b"\x01" + b"\x00" * 15)
         req = self.generate_request(call_id=3,
                                     context_id=ctx1.context_id,
                                     opnum=0,
-                                    stub="",
+                                    stub=b"",
                                     auth_info=auth_info)
         self.send_pdu(req)
         rep = self.recv_pdu()
@@ -4054,7 +4061,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
         auth_context_id = 2
         g.start_mech_by_authtype(auth_type, auth_level)
-        from_server = ""
+        from_server = b""
         (finished, to_server) = g.update(from_server)
         self.assertFalse(finished)
 
@@ -4092,7 +4099,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
         self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
         self.assertEquals(len(rep.u._pad), 3)
-        self.assertEquals(rep.u._pad, '\0' * 3)
+        self.assertEquals(rep.u._pad, b'\0' * 3)
 
         # wait for a disconnect
         rep = self.recv_pdu()
@@ -4118,7 +4125,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
         auth_context_id = 2
         g.start_mech_by_authtype(auth_type, auth_level)
-        from_server = ""
+        from_server = b""
         (finished, to_server) = g.update(from_server)
         self.assertFalse(finished)
 
@@ -4231,7 +4238,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
         auth_context_id = 2
         g.start_mech_by_authtype(auth_type, auth_level)
-        from_server = ""
+        from_server = b""
         (finished, to_server) = g.update(from_server)
         self.assertFalse(finished)
 
@@ -4297,7 +4304,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         req = self.generate_request(call_id=2,
                                     context_id=ctx1.context_id,
                                     opnum=0,
-                                    stub="")
+                                    stub=b"")
         self.send_pdu(req)
         rep = self.recv_pdu()
         self.verify_pdu(rep, dcerpc.DCERPC_PKT_RESPONSE, req.call_id,
@@ -4311,11 +4318,11 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_info = self.generate_auth(auth_type=auth_type,
                                        auth_level=auth_level,
                                        auth_context_id=auth_context_id,
-                                       auth_blob="\x01" + "\x00" * 15)
+                                       auth_blob=b"\x01" + b"\x00" * 15)
         req = self.generate_request(call_id=3,
                                     context_id=ctx1.context_id,
                                     opnum=0,
-                                    stub="",
+                                    stub=b"",
                                     auth_info=auth_info)
         self.send_pdu(req)
         rep = self.recv_pdu()
@@ -4349,7 +4356,7 @@ class TestDCERPC_BIND(RawDCERPCTest):
         auth_level = dcerpc.DCERPC_AUTH_LEVEL_CONNECT
         auth_context_id = 2
         g.start_mech_by_authtype(auth_type, auth_level)
-        from_server = ""
+        from_server = b""
         (finished, to_server) = g.update(from_server)
         self.assertFalse(finished)
 
@@ -4479,18 +4486,18 @@ class TestDCERPC_BIND(RawDCERPCTest):
 
         self.assertIsNotNone(g)
 
-        stub_bin = '\x00' * 17
+        stub_bin = b'\x00' * 17
         mod_len = len(stub_bin) % dcerpc.DCERPC_AUTH_PAD_ALIGNMENT
         auth_pad_length = 0
         if mod_len > 0:
             auth_pad_length = dcerpc.DCERPC_AUTH_PAD_ALIGNMENT - mod_len
-        stub_bin += '\x00' * auth_pad_length
+        stub_bin += b'\x00' * auth_pad_length
 
         if g_auth_level >= dcerpc.DCERPC_AUTH_LEVEL_INTEGRITY:
             sig_size = g.sig_size(len(stub_bin))
         else:
             sig_size = 16
-        zero_sig = "\x00" * sig_size
+        zero_sig = b"\x00" * sig_size
 
         auth_info = self.generate_auth(auth_type=auth_type,
                                        auth_level=auth_level,
@@ -4647,15 +4654,15 @@ class TestDCERPC_BIND(RawDCERPCTest):
                                               auth_context_id=auth_context_id,
                                               ctx=ctx1)
 
-        stub_bin = '\x00' * 0
+        stub_bin = b'\x00' * 0
         mod_len = len(stub_bin) % dcerpc.DCERPC_AUTH_PAD_ALIGNMENT
         auth_pad_length = 0
         if mod_len > 0:
             auth_pad_length = dcerpc.DCERPC_AUTH_PAD_ALIGNMENT - mod_len
-        stub_bin += '\x00' * auth_pad_length
+        stub_bin += b'\x00' * auth_pad_length
 
         sig_size = g.sig_size(len(stub_bin))
-        zero_sig = "\x00" * sig_size
+        zero_sig = b"\x00" * sig_size
 
         auth_info = self.generate_auth(auth_type=auth_type,
                                        auth_level=auth_level,
@@ -4713,15 +4720,15 @@ class TestDCERPC_BIND(RawDCERPCTest):
 
         g.check_packet(rep_data, rep_whole, rep_sig)
 
-        stub_bin = '\x00' * 17
+        stub_bin = b'\x00' * 17
         mod_len = len(stub_bin) % dcerpc.DCERPC_AUTH_PAD_ALIGNMENT
         auth_pad_length = 0
         if mod_len > 0:
             auth_pad_length = dcerpc.DCERPC_AUTH_PAD_ALIGNMENT - mod_len
-        stub_bin += '\x00' * auth_pad_length
+        stub_bin += b'\x00' * auth_pad_length
 
         sig_size = g.sig_size(len(stub_bin))
-        zero_sig = "\x00" * sig_size
+        zero_sig = b"\x00" * sig_size
 
         auth_info = self.generate_auth(auth_type=auth_type,
                                        auth_level=auth_level,
@@ -4764,15 +4771,15 @@ class TestDCERPC_BIND(RawDCERPCTest):
         self.assertEquals(rep.u.reserved, 0)
         self.assertEquals(len(rep.u.error_and_verifier), 0)
 
-        stub_bin = '\x00' * 8
+        stub_bin = b'\x00' * 8
         mod_len = len(stub_bin) % dcerpc.DCERPC_AUTH_PAD_ALIGNMENT
         auth_pad_length = 0
         if mod_len > 0:
             auth_pad_length = dcerpc.DCERPC_AUTH_PAD_ALIGNMENT - mod_len
-        stub_bin += '\x00' * auth_pad_length
+        stub_bin += b'\x00' * auth_pad_length
 
         sig_size = g.sig_size(len(stub_bin))
-        zero_sig = "\x00" * sig_size
+        zero_sig = b"\x00" * sig_size
 
         auth_info = self.generate_auth(auth_type=auth_type,
                                        auth_level=auth_level,
@@ -4829,15 +4836,15 @@ class TestDCERPC_BIND(RawDCERPCTest):
 
         g.check_packet(rep_data, rep_whole, rep_sig)
 
-        stub_bin = '\x00' * 8
+        stub_bin = b'\x00' * 8
         mod_len = len(stub_bin) % dcerpc.DCERPC_AUTH_PAD_ALIGNMENT
         auth_pad_length = 0
         if mod_len > 0:
             auth_pad_length = dcerpc.DCERPC_AUTH_PAD_ALIGNMENT - mod_len
-        stub_bin += '\x00' * auth_pad_length
+        stub_bin += b'\x00' * auth_pad_length
 
         sig_size = g.sig_size(len(stub_bin))
-        zero_sig = "\x00" * sig_size
+        zero_sig = b"\x00" * sig_size
 
         auth_info = self.generate_auth(auth_type=auth_type,
                                        auth_level=auth_level,

diff --git a/python/samba/tests/dcerpc/raw_testcase.py b/python/samba/tests/dcerpc/raw_testcase.py
index 32d45d5329217827c9d43d9ab17291788bc505b7..c4d364128b38fa5f2fbc092a243d6c1c6cb20a95 100644 (file)
--- a/python/samba/tests/dcerpc/raw_testcase.py
+++ b/python/samba/tests/dcerpc/raw_testcase.py
@@ -27,6 +27,7 @@ from samba import gensec
 from samba.credentials import Credentials
 from samba.tests import TestCase
 from samba.ndr import ndr_pack, ndr_unpack, ndr_unpack_out
+from samba.compat import text_type
 
 
 class RawDCERPCTest(TestCase):
@@ -165,7 +166,7 @@ class RawDCERPCTest(TestCase):
             self.assertEquals(rep.u.versions[0].rpc_vers, req.rpc_vers)
             self.assertEquals(rep.u.versions[0].rpc_vers_minor, req.rpc_vers_minor)
             self.assertEquals(len(rep.u._pad), 3)
-            self.assertEquals(rep.u._pad, '\0' * 3)
+            self.assertEquals(rep.u._pad, b'\0' * 3)
             return
         self.verify_pdu(rep, samba.dcerpc.dcerpc.DCERPC_PKT_BIND_ACK, req.call_id,
                         pfc_flags=pfc_flags)
@@ -318,7 +319,7 @@ class RawDCERPCTest(TestCase):
                 sys.stderr.write("stub_in: %d\n%s" % (len(stub_in), self.hexdump(stub_in)))
         else:
             # only used for sig_size calculation
-            stub_in = '\xff' * samba.dcerpc.dcerpc.DCERPC_AUTH_PAD_ALIGNMENT
+            stub_in = b'\xff' * samba.dcerpc.dcerpc.DCERPC_AUTH_PAD_ALIGNMENT
 
         sig_size = 0
         if auth_context is not None:
@@ -326,7 +327,7 @@ class RawDCERPCTest(TestCase):
             auth_pad_length = 0
             if mod_len > 0:
                 auth_pad_length = samba.dcerpc.dcerpc.DCERPC_AUTH_PAD_ALIGNMENT - mod_len
-            stub_in += '\x00' * auth_pad_length
+            stub_in += b'\x00' * auth_pad_length
 
             if auth_context["g_auth_level"] >= samba.dcerpc.dcerpc.DCERPC_AUTH_LEVEL_PACKET:
                 sig_size = auth_context["gensec"].sig_size(len(stub_in))
@@ -463,19 +464,19 @@ class RawDCERPCTest(TestCase):
         floor2.rhs = rhs2
         lhs3 = samba.dcerpc.epmapper.epm_lhs()
         lhs3.protocol = samba.dcerpc.epmapper.EPM_PROTOCOL_NCACN
-        lhs3.lhs_data = ""
+        lhs3.lhs_data = b""
         floor3 = samba.dcerpc.epmapper.epm_floor()
         floor3.lhs = lhs3
         floor3.rhs.minor_version = 0
         lhs4 = samba.dcerpc.epmapper.epm_lhs()
         lhs4.protocol = samba.dcerpc.epmapper.EPM_PROTOCOL_TCP
-        lhs4.lhs_data = ""
+        lhs4.lhs_data = b""
         floor4 = samba.dcerpc.epmapper.epm_floor()
         floor4.lhs = lhs4
         floor4.rhs.port = self.tcp_port
         lhs5 = samba.dcerpc.epmapper.epm_lhs()
         lhs5.protocol = samba.dcerpc.epmapper.EPM_PROTOCOL_IP
-        lhs5.lhs_data = ""
+        lhs5.lhs_data = b""
         floor5 = samba.dcerpc.epmapper.epm_floor()
         floor5.lhs = lhs5
         floor5.rhs.ipaddr = "0.0.0.0"
@@ -647,7 +648,7 @@ class RawDCERPCTest(TestCase):
         if getattr(payload, 'auth_info', None):
             ai = payload.auth_info
         else:
-            ai = ""
+            ai = b""
 
         p = samba.dcerpc.dcerpc.ncacn_packet()
         p.rpc_vers = rpc_vers
@@ -681,7 +682,7 @@ class RawDCERPCTest(TestCase):
         if getattr(p.u, 'auth_info', None):
             ai = p.u.auth_info
         else:
-            ai = ""
+            ai = b""
 
         self.assertEqual(p.rpc_vers, rpc_vers)
         self.assertEqual(p.rpc_vers_minor, rpc_vers_minor)
@@ -708,7 +709,7 @@ class RawDCERPCTest(TestCase):
                       max_recv_frag=5840,
                       assoc_group_id=0,
                       ctx_list=[],
-                      auth_info="",
+                      auth_info=b"",
                       ndr_print=None, hexdump=None):
 
         b = samba.dcerpc.dcerpc.bind()
@@ -734,7 +735,7 @@ class RawDCERPCTest(TestCase):
                        max_recv_frag=5840,
                        assoc_group_id=0,
                        ctx_list=[],
-                       auth_info="",
+                       auth_info=b"",
                        ndr_print=None, hexdump=None):
 
         a = samba.dcerpc.dcerpc.bind()
@@ -756,7 +757,7 @@ class RawDCERPCTest(TestCase):
     def generate_auth3(self, call_id,
                        pfc_flags=(samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_FIRST |
                                   samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_LAST),
-                       auth_info="",
+                       auth_info=b"",
                        ndr_print=None, hexdump=None):
 
         a = samba.dcerpc.dcerpc.auth3()
@@ -778,7 +779,7 @@ class RawDCERPCTest(TestCase):
                          opnum=None,
                          object=None,
                          stub=None,
-                         auth_info="",
+                         auth_info=b"",
                          ndr_print=None, hexdump=None):
 
         if alloc_hint is None:
@@ -806,7 +807,7 @@ class RawDCERPCTest(TestCase):
     def generate_co_cancel(self, call_id,
                            pfc_flags=(samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_FIRST |
                                       samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_LAST),
-                           auth_info="",
+                           auth_info=b"",
                            ndr_print=None, hexdump=None):
 
         c = samba.dcerpc.dcerpc.co_cancel()
@@ -823,7 +824,7 @@ class RawDCERPCTest(TestCase):
     def generate_orphaned(self, call_id,
                           pfc_flags=(samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_FIRST |
                                      samba.dcerpc.dcerpc.DCERPC_PFC_FLAG_LAST),
-                          auth_info="",
+                          auth_info=b"",
                           ndr_print=None, hexdump=None):
 
         o = samba.dcerpc.dcerpc.orphaned()