1 /*
2 Unix SMB/CIFS implementation.
3 SMB torture tester
4 Copyright (C) Kai Blin 2012
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "includes.h"
21 #include "torture/smbtorture.h"
22 #include <talloc.h>
23 #include "lib/addns/dns.h"
24
setup_connection(struct torture_context * tctx)25 static struct dns_connection *setup_connection(struct torture_context *tctx)
26 {
27 DNS_ERROR err;
28 struct dns_connection *conn;
29
30 err = dns_open_connection(getenv("DC_SERVER_IP"), DNS_TCP, tctx, &conn);
31 if (!ERR_DNS_IS_OK(err)) {
32 printf("Failed to open connection to DNS server\n");
33 return NULL;
34 }
35
36 return conn;
37 }
38
get_dns_domain(struct torture_context * tctx)39 static char *get_dns_domain(struct torture_context *tctx)
40 {
41 return strlower_talloc(tctx, getenv("REALM"));
42 }
43
str_to_sockaddr(TALLOC_CTX * mem_ctx,const char * ip_string)44 static struct sockaddr_storage *str_to_sockaddr(TALLOC_CTX *mem_ctx, const char *ip_string)
45 {
46 struct sockaddr_storage *ss = talloc_zero(mem_ctx, struct sockaddr_storage);
47 int ret;
48
49 if (ss == NULL) {
50 return NULL;
51 }
52
53 ss->ss_family = AF_INET;
54
55 ret = inet_pton(AF_INET, ip_string, &(((struct sockaddr_in *)ss)->sin_addr));
56 if (ret != 1) {
57 return NULL;
58 }
59
60 return ss;
61 }
62
test_internal_dns_query_self(struct torture_context * tctx)63 static bool test_internal_dns_query_self(struct torture_context *tctx)
64 {
65 struct dns_connection *conn;
66 struct dns_request *req, *resp;
67 char *host;
68 DNS_ERROR err;
69
70 conn = setup_connection(tctx);
71 if (conn == NULL) {
72 return false;
73 }
74
75 host = talloc_asprintf(tctx, "%s.%s", getenv("DC_SERVER"), get_dns_domain(tctx));
76 if (host == NULL) {
77 return false;
78 }
79
80 err = dns_create_query(conn, host, QTYPE_A, DNS_CLASS_IN, &req);
81 if (!ERR_DNS_IS_OK(err)) {
82 printf("Failed to create A record query\n");
83 return false;
84 }
85
86 err = dns_transaction(conn, conn, req, &resp);
87 if (!ERR_DNS_IS_OK(err)) {
88 printf("Failed to query DNS server\n");
89 return false;
90 }
91
92 if (dns_response_code(resp->flags) != DNS_NO_ERROR) {
93 printf("Query returned %u\n", dns_response_code(resp->flags));
94 return false;
95 }
96
97 /* FIXME: is there _any_ way to unmarshal the response to check this? */
98
99 return true;
100 }
101
test_internal_dns_update_self(struct torture_context * tctx)102 static bool test_internal_dns_update_self(struct torture_context *tctx)
103 {
104 struct dns_connection *conn;
105 struct dns_update_request *req, *resp;
106 struct dns_rrec *rec = NULL;
107 char *host;
108 DNS_ERROR err;
109 struct sockaddr_storage *ss;
110
111 conn = setup_connection(tctx);
112 if (conn == NULL) {
113 return false;
114 }
115
116 host = talloc_asprintf(tctx, "%s.%s", getenv("DC_SERVER"), get_dns_domain(tctx));
117 if (host == NULL) {
118 return false;
119 }
120
121 err = dns_create_update(conn, get_dns_domain(tctx), &req);
122 if (!ERR_DNS_IS_OK(err)) {
123 printf("Failed to update packet\n");
124 return false;
125 }
126
127 ss = str_to_sockaddr(conn, getenv("DC_SERVER_IP"));
128 if (ss == NULL) {
129 printf("Converting '%s' to sockaddr_storage failed\n", getenv("DC_SERVER_IP"));
130 return false;
131 }
132
133 err = dns_create_a_record(req, host, 300, ss, &rec);
134 if (!ERR_DNS_IS_OK(err)) {
135 printf("Failed to create A update record\n");
136 return false;
137 }
138
139 err = dns_add_rrec(req, rec, &req->num_updates, &req->updates);
140 if (!ERR_DNS_IS_OK(err)) {
141 printf("Failed to add A update record to update packet\n");
142 return false;
143 }
144
145 err = dns_update_transaction(conn, conn, req, &resp);
146 if (!ERR_DNS_IS_OK(err)) {
147 printf("Failed to send update\n");
148 return false;
149 }
150
151 if (dns_response_code(resp->flags) != DNS_REFUSED) {
152 printf("Update returned %u\n", dns_response_code(resp->flags));
153 return false;
154 }
155
156 /* FIXME: is there _any_ way to unmarshal the response to check this? */
157
158 return true;
159 }
160
internal_dns_suite(TALLOC_CTX * ctx)161 static struct torture_suite *internal_dns_suite(TALLOC_CTX *ctx)
162 {
163 struct torture_suite *suite = torture_suite_create(ctx, "dns_internal");
164
165 suite->description = talloc_strdup(suite,
166 "Tests for the internal DNS server");
167 torture_suite_add_simple_test(suite, "queryself", test_internal_dns_query_self);
168 torture_suite_add_simple_test(suite, "updateself", test_internal_dns_update_self);
169 return suite;
170 }
171
172
173 /* Silence silly compiler warning */
174 NTSTATUS torture_internal_dns_init(TALLOC_CTX *);
175
176 /**
177 * DNS torture module initialization
178 */
torture_internal_dns_init(TALLOC_CTX * ctx)179 NTSTATUS torture_internal_dns_init(TALLOC_CTX *ctx)
180 {
181 struct torture_suite *suite;
182
183 /* register internal DNS torture test cases */
184 suite = internal_dns_suite(ctx);
185 if (!suite) return NT_STATUS_NO_MEMORY;
186 torture_register_suite(ctx, suite);
187
188 return NT_STATUS_OK;
189 }
190