2 Unix SMB/CIFS implementation.
4 Fire connect requests to a host and a number of ports, with a timeout
5 between the connect request. Return if the first connect comes back
6 successfully or return the last error.
8 Copyright (C) Volker Lendecke 2005
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program. If not, see <http://www.gnu.org/licenses/>.
25 #include "lib/socket/socket.h"
26 #include "lib/events/events.h"
27 #include "libcli/composite/composite.h"
28 #include "libcli/resolve/resolve.h"
30 #define MULTI_PORT_DELAY 2000 /* microseconds */
35 struct connect_multi_state {
36 const char *server_address;
40 struct socket_context *sock;
43 int num_connects_sent, num_connects_recv;
47 state of an individual socket_connect_send() call
49 struct connect_one_state {
50 struct composite_context *result;
51 struct socket_context *sock;
52 struct socket_address *addr;
55 static void continue_resolve_name(struct composite_context *creq);
56 static void connect_multi_timer(struct event_context *ev,
57 struct timed_event *te,
58 struct timeval tv, void *p);
59 static void connect_multi_next_socket(struct composite_context *result);
60 static void continue_one(struct composite_context *creq);
63 setup an async socket_connect, with multiple ports
65 _PUBLIC_ struct composite_context *socket_connect_multi_send(
67 const char *server_address,
69 uint16_t *server_ports,
70 struct event_context *event_ctx)
72 struct composite_context *result;
73 struct connect_multi_state *multi;
76 result = talloc_zero(mem_ctx, struct composite_context);
77 if (result == NULL) return NULL;
78 result->state = COMPOSITE_STATE_IN_PROGRESS;
79 result->event_ctx = event_ctx;
81 multi = talloc_zero(result, struct connect_multi_state);
82 if (composite_nomem(multi, result)) goto failed;
83 result->private_data = multi;
85 multi->server_address = talloc_strdup(multi, server_address);
86 if (composite_nomem(multi->server_address, result)) goto failed;
88 multi->num_ports = num_server_ports;
89 multi->ports = talloc_array(multi, uint16_t, multi->num_ports);
90 if (composite_nomem(multi->ports, result)) goto failed;
92 for (i=0; i<multi->num_ports; i++) {
93 multi->ports[i] = server_ports[i];
96 if (!is_ipaddress(server_address)) {
98 we don't want to do the name resolution separately
99 for each port, so start it now, then only start on
100 the real sockets once we have an IP
102 struct nbt_name name;
103 struct composite_context *creq;
104 make_nbt_name_client(&name, server_address);
105 creq = resolve_name_send(&name, result->event_ctx,
106 lp_name_resolve_order());
107 if (composite_nomem(creq, result)) goto failed;
108 composite_continue(result, creq, continue_resolve_name, result);
112 /* now we've setup the state we can process the first socket */
113 connect_multi_next_socket(result);
115 if (!NT_STATUS_IS_OK(result->status)) {
122 composite_error(result, result->status);
127 start connecting to the next socket/port in the list
129 static void connect_multi_next_socket(struct composite_context *result)
131 struct connect_multi_state *multi = talloc_get_type(result->private_data,
132 struct connect_multi_state);
133 struct connect_one_state *state;
134 struct composite_context *creq;
135 int next = multi->num_connects_sent;
137 if (next == multi->num_ports) {
138 /* don't do anything, just wait for the existing ones to finish */
142 multi->num_connects_sent += 1;
144 state = talloc(multi, struct connect_one_state);
145 if (composite_nomem(state, result)) return;
147 state->result = result;
148 result->status = socket_create("ipv4", SOCKET_TYPE_STREAM, &state->sock, 0);
149 if (!composite_is_ok(result)) return;
151 /* Form up the particular address we are interested in */
152 state->addr = socket_address_from_strings(state, state->sock->backend_name,
153 multi->server_address, multi->ports[next]);
154 if (composite_nomem(state->addr, result)) return;
156 talloc_steal(state, state->sock);
158 creq = socket_connect_send(state->sock, NULL,
159 state->addr, 0, result->event_ctx);
160 if (composite_nomem(creq, result)) return;
161 talloc_steal(state, creq);
163 composite_continue(result, creq, continue_one, state);
165 /* if there are more ports to go then setup a timer to fire when we have waited
166 for a couple of milli-seconds, when that goes off we try the next port regardless
167 of whether this port has completed */
168 if (multi->num_ports > multi->num_connects_sent) {
169 /* note that this timer is a child of the single
170 connect attempt state, so it will go away when this
172 event_add_timed(result->event_ctx, state,
173 timeval_current_ofs(0, MULTI_PORT_DELAY),
174 connect_multi_timer, result);
179 a timer has gone off telling us that we should try the next port
181 static void connect_multi_timer(struct event_context *ev,
182 struct timed_event *te,
183 struct timeval tv, void *p)
185 struct composite_context *result = talloc_get_type(p, struct composite_context);
186 connect_multi_next_socket(result);
191 recv name resolution reply then send the next connect
193 static void continue_resolve_name(struct composite_context *creq)
195 struct composite_context *result = talloc_get_type(creq->async.private_data,
196 struct composite_context);
197 struct connect_multi_state *multi = talloc_get_type(result->private_data,
198 struct connect_multi_state);
201 result->status = resolve_name_recv(creq, multi, &addr);
202 if (!composite_is_ok(result)) return;
204 multi->server_address = addr;
206 connect_multi_next_socket(result);
210 one of our socket_connect_send() calls hash finished. If it got a
211 connection or there are none left then we are done
213 static void continue_one(struct composite_context *creq)
215 struct connect_one_state *state = talloc_get_type(creq->async.private_data,
216 struct connect_one_state);
217 struct composite_context *result = state->result;
218 struct connect_multi_state *multi = talloc_get_type(result->private_data,
219 struct connect_multi_state);
221 multi->num_connects_recv++;
223 status = socket_connect_recv(creq);
225 if (NT_STATUS_IS_OK(status)) {
226 multi->sock = talloc_steal(multi, state->sock);
227 multi->result_port = state->addr->port;
232 if (NT_STATUS_IS_OK(status) ||
233 multi->num_connects_recv == multi->num_ports) {
234 result->status = status;
235 composite_done(result);
239 /* try the next port */
240 connect_multi_next_socket(result);
244 async recv routine for socket_connect_multi()
246 _PUBLIC_ NTSTATUS socket_connect_multi_recv(struct composite_context *ctx,
248 struct socket_context **sock,
251 NTSTATUS status = composite_wait(ctx);
252 if (NT_STATUS_IS_OK(status)) {
253 struct connect_multi_state *multi =
254 talloc_get_type(ctx->private_data,
255 struct connect_multi_state);
256 *sock = talloc_steal(mem_ctx, multi->sock);
257 *port = multi->result_port;
263 NTSTATUS socket_connect_multi(TALLOC_CTX *mem_ctx,
264 const char *server_address,
265 int num_server_ports, uint16_t *server_ports,
266 struct event_context *event_ctx,
267 struct socket_context **result,
268 uint16_t *result_port)
270 struct composite_context *ctx =
271 socket_connect_multi_send(mem_ctx, server_address,
272 num_server_ports, server_ports,
274 return socket_connect_multi_recv(ctx, mem_ctx, result, result_port);