summaryrefslogtreecommitdiff
path: root/source4/torture/local/binding_string.c
blob: 5e346b4831dc8aace8498e4c03cea3b76a7fda82 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
/* 
   Unix SMB/CIFS implementation.

   local testing of RPC binding string parsing 

   Copyright (C) Jelmer Vernooij 2004
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
   
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

#include "includes.h"

static BOOL test_BindingString(TALLOC_CTX *mem_ctx, const char *binding)
{
	struct dcerpc_binding b, b2;
	const char *s, *s2;
	struct epm_tower tower;
	NTSTATUS status;

	/* Parse */
	status = dcerpc_parse_binding(mem_ctx, binding, &b);
	if (NT_STATUS_IS_ERR(status)) {
		DEBUG(0, ("Error parsing binding string '%s': %s\n", binding, nt_errstr(status)));
		return False;
	}

	s = dcerpc_binding_string(mem_ctx, &b);
	if (!s) {
		DEBUG(0, ("Error converting binding back to string for '%s'\n", binding)); 
		return False;
	}

	if (strcasecmp(binding, s) != 0) {
		DEBUG(0, ("Mismatch while comparing original and regenerated binding strings: '%s' <> '%s'\n", binding, s));
		return False;
	}

	/* Generate protocol towers */
	status = dcerpc_binding_build_tower(mem_ctx, &b, &tower);
	if (NT_STATUS_IS_ERR(status)) {
		DEBUG(0, ("Error generating protocol tower from '%s': %s\n", binding, nt_errstr(status)));
		return False;
	}

	/* Convert back to binding and then back to string and compare */

	status = dcerpc_binding_from_tower(mem_ctx, &tower, &b2);
	if (NT_STATUS_IS_ERR(status)) {
		DEBUG(0, ("Error generating binding from tower for original binding '%s': %s\n", binding, nt_errstr(status)));
		return False;
	}

	/* Compare to a stripped down version of the binding string because 
	 * the protocol tower doesn't contain the extra option data */
	if (b.options && b.options[0]) {
		b.options[1] = NULL; 
	}

	b.flags = 0;
	
	s = dcerpc_binding_string(mem_ctx, &b);
	if (!s) {
		DEBUG(0, ("Error converting binding back to string for (stripped down) '%s'\n", binding)); 
		return False;
	}


	s2 = dcerpc_binding_string(mem_ctx, &b2);
	if (!s) {
		DEBUG(0, ("Error converting binding back to string for '%s'\n", binding)); 
		return False;
	}

	if (strcasecmp(s, s2) != 0) {
		DEBUG(0, ("Mismatch while comparing original and from protocol tower generated binding strings: '%s' <> '%s'\n", s, s2));
		return False;
	}

	return True;
}

static const char *test_strings[] = {
	"ncacn_np:", 
	"ncalrpc:", 
	"ncalrpc:[,Security=Sane]", 
	"ncacn_np:[rpcecho]",
	"ncacn_np:127.0.0.1[rpcecho]",
	"ncacn_ip_tcp:127.0.0.1",
	"ncacn_np:localhost[rpcecho]",
	"ncacn_np:[/pipe/rpcecho]",
	"ncacn_np:localhost[/pipe/rpcecho,sign,seal]",
	"ncacn_np:[,sign]",
	"ncadg_ip_udp:",
	"308FB580-1EB2-11CA-923B-08002B1075A7@ncacn_np:localhost",
	"308FB580-1EB2-11CA-923B-08002B1075A7@ncacn_ip_tcp:127.0.0.1",
	"ncacn_unix_stream:[/tmp/epmapper]",
	"ncalrpc:[IDENTIFIER]",
	"ncacn_unix_stream:[/tmp/epmapper,sign]",
};

BOOL torture_local_binding_string(int dummy) 
{
	BOOL ret = True;
	TALLOC_CTX *mem_ctx = talloc_init("test_BindingString");
	int i;

	for (i = 0; i < ARRAY_SIZE(test_strings); i++) {
		ret &= test_BindingString(mem_ctx, test_strings[i]);
	}

	talloc_destroy(mem_ctx);

	return ret;
}