source4/lib/socket/connect_multi.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   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.
   7
   8    Copyright (C) Volker Lendecke 2005
   9
  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.
  14
  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.
  19
  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/>.
  22 */
  23
  24 #include "includes.h"
  25 #include "lib/socket/socket.h"
  26 #include "lib/events/events.h"
  27 #include "libcli/composite/composite.h"
  28 #include "libcli/resolve/resolve.h"
  29
  30 #define MULTI_PORT_DELAY 2000 /* microseconds */
  31
  32 /*
  33   overall state
  34 */
  35 struct connect_multi_state {
  36         struct socket_address *server_address;
  37         int num_ports;
  38         uint16_t *ports;
  39
  40         struct socket_context *sock;
  41         uint16_t result_port;
  42
  43         int num_connects_sent, num_connects_recv;
  44 };
  45
  46 /*
  47   state of an individual socket_connect_send() call
  48 */
  49 struct connect_one_state {
  50         struct composite_context *result;
  51         struct socket_context *sock;
  52         struct socket_address *addr;
  53 };
  54
  55 static void continue_resolve_name(struct composite_context *creq);
  56 static void connect_multi_timer(struct tevent_context *ev,
  57                                     struct tevent_timer *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);
  61
  62 /*
  63   setup an async socket_connect, with multiple ports
  64 */
  65 _PUBLIC_ struct composite_context *socket_connect_multi_send(
  66                                                     TALLOC_CTX *mem_ctx,
  67                                                     const char *server_name,
  68                                                     int num_server_ports,
  69                                                     uint16_t *server_ports,
  70                                                     struct resolve_context *resolve_ctx,
  71                                                     struct tevent_context *event_ctx)
  72 {
  73         struct composite_context *result;
  74         struct connect_multi_state *multi;
  75         int i;
  76
  77         struct nbt_name name;
  78         struct composite_context *creq;
  79
  80         result = talloc_zero(mem_ctx, struct composite_context);
  81         if (result == NULL) return NULL;
  82         result->state = COMPOSITE_STATE_IN_PROGRESS;
  83         result->event_ctx = event_ctx;
  84
  85         multi = talloc_zero(result, struct connect_multi_state);
  86         if (composite_nomem(multi, result)) goto failed;
  87         result->private_data = multi;
  88
  89         multi->num_ports = num_server_ports;
  90         multi->ports = talloc_array(multi, uint16_t, multi->num_ports);
  91         if (composite_nomem(multi->ports, result)) goto failed;
  92
  93         for (i=0; i<multi->num_ports; i++) {
  94                 multi->ports[i] = server_ports[i];
  95         }
  96
  97         /*
  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
 101         */
 102         make_nbt_name_server(&name, server_name);
 103
 104         creq = resolve_name_all_send(resolve_ctx, multi, 0, multi->ports[0], &name, result->event_ctx);
 105         if (composite_nomem(creq, result)) goto failed;
 106
 107         composite_continue(result, creq, continue_resolve_name, result);
 108
 109         return result;
 110
 111
 112  failed:
 113         composite_error(result, result->status);
 114         return result;
 115 }
 116
 117 /*
 118   start connecting to the next socket/port in the list
 119 */
 120 static void connect_multi_next_socket(struct composite_context *result)
 121 {
 122         struct connect_multi_state *multi = talloc_get_type(result->private_data,
 123                                                             struct connect_multi_state);
 124         struct connect_one_state *state;
 125         struct composite_context *creq;
 126         int next = multi->num_connects_sent;
 127
 128         if (next == multi->num_ports) {
 129                 /* don't do anything, just wait for the existing ones to finish */
 130                 return;
 131         }
 132
 133         multi->num_connects_sent += 1;
 134
 135         state = talloc(multi, struct connect_one_state);
 136         if (composite_nomem(state, result)) return;
 137
 138         state->result = result;
 139         result->status = socket_create(multi->server_address->family, SOCKET_TYPE_STREAM, &state->sock, 0);
 140         if (!composite_is_ok(result)) return;
 141
 142         state->addr = socket_address_copy(state, multi->server_address);
 143         if (composite_nomem(state->addr, result)) return;
 144
 145         socket_address_set_port(state->addr, multi->ports[next]);
 146
 147         talloc_steal(state, state->sock);
 148
 149         creq = socket_connect_send(state->sock, NULL,
 150                                    state->addr, 0,
 151                                    result->event_ctx);
 152         if (composite_nomem(creq, result)) return;
 153         talloc_steal(state, creq);
 154
 155         composite_continue(result, creq, continue_one, state);
 156
 157         /* if there are more ports to go then setup a timer to fire when we have waited
 158            for a couple of milli-seconds, when that goes off we try the next port regardless
 159            of whether this port has completed */
 160         if (multi->num_ports > multi->num_connects_sent) {
 161                 /* note that this timer is a child of the single
 162                    connect attempt state, so it will go away when this
 163                    request completes */
 164                 tevent_add_timer(result->event_ctx, state,
 165                                 timeval_current_ofs_usec(MULTI_PORT_DELAY),
 166                                 connect_multi_timer, result);
 167         }
 168 }
 169
 170 /*
 171   a timer has gone off telling us that we should try the next port
 172 */
 173 static void connect_multi_timer(struct tevent_context *ev,
 174                                 struct tevent_timer *te,
 175                                 struct timeval tv, void *p)
 176 {
 177         struct composite_context *result = talloc_get_type(p, struct composite_context);
 178         connect_multi_next_socket(result);
 179 }
 180
 181
 182 /*
 183   recv name resolution reply then send the next connect
 184 */
 185 static void continue_resolve_name(struct composite_context *creq)
 186 {
 187         struct composite_context *result = talloc_get_type(creq->async.private_data,
 188                                                            struct composite_context);
 189         struct connect_multi_state *multi = talloc_get_type(result->private_data,
 190                                                             struct connect_multi_state);
 191         struct socket_address **addr;
 192
 193         result->status = resolve_name_all_recv(creq, multi, &addr, NULL);
 194         if (!composite_is_ok(result)) return;
 195
 196         /* Let's just go for the first for now */
 197         multi->server_address = addr[0];
 198
 199         connect_multi_next_socket(result);
 200 }
 201
 202 /*
 203   one of our socket_connect_send() calls hash finished. If it got a
 204   connection or there are none left then we are done
 205 */
 206 static void continue_one(struct composite_context *creq)
 207 {
 208         struct connect_one_state *state = talloc_get_type(creq->async.private_data,
 209                                                           struct connect_one_state);
 210         struct composite_context *result = state->result;
 211         struct connect_multi_state *multi = talloc_get_type(result->private_data,
 212                                                             struct connect_multi_state);
 213         NTSTATUS status;
 214         multi->num_connects_recv++;
 215
 216         status = socket_connect_recv(creq);
 217
 218         if (NT_STATUS_IS_OK(status)) {
 219                 multi->sock = talloc_steal(multi, state->sock);
 220                 multi->result_port = state->addr->port;
 221         }
 222
 223         talloc_free(state);
 224
 225         if (NT_STATUS_IS_OK(status) ||
 226             multi->num_connects_recv == multi->num_ports) {
 227                 result->status = status;
 228                 composite_done(result);
 229                 return;
 230         }
 231
 232         /* try the next port */
 233         connect_multi_next_socket(result);
 234 }
 235
 236 /*
 237   async recv routine for socket_connect_multi()
 238  */
 239 _PUBLIC_ NTSTATUS socket_connect_multi_recv(struct composite_context *ctx,
 240                                    TALLOC_CTX *mem_ctx,
 241                                    struct socket_context **sock,
 242                                    uint16_t *port)
 243 {
 244         NTSTATUS status = composite_wait(ctx);
 245         if (NT_STATUS_IS_OK(status)) {
 246                 struct connect_multi_state *multi =
 247                         talloc_get_type(ctx->private_data,
 248                                         struct connect_multi_state);
 249                 *sock = talloc_steal(mem_ctx, multi->sock);
 250                 *port = multi->result_port;
 251         }
 252         talloc_free(ctx);
 253         return status;
 254 }
 255
 256 NTSTATUS socket_connect_multi(TALLOC_CTX *mem_ctx,
 257                               const char *server_address,
 258                               int num_server_ports, uint16_t *server_ports,
 259                               struct resolve_context *resolve_ctx,
 260                               struct tevent_context *event_ctx,
 261                               struct socket_context **result,
 262                               uint16_t *result_port)
 263 {
 264         struct composite_context *ctx =
 265                 socket_connect_multi_send(mem_ctx, server_address,
 266                                           num_server_ports, server_ports,
 267                                           resolve_ctx,
 268                                           event_ctx);
 269         return socket_connect_multi_recv(ctx, mem_ctx, result, result_port);
 270 }