lib/client-handshake.c

   1 #include "private-libwebsockets.h"
   2
   3 struct libwebsocket *libwebsocket_client_connect_2(
   4         struct libwebsocket_context *context,
   5         struct libwebsocket *wsi
   6 ) {
   7         struct pollfd pfd;
   8         struct hostent *server_hostent;
   9         struct sockaddr_in server_addr;
  10         struct sockaddr_in client_addr;
  11         int n;
  12         int plen = 0;
  13         const char *ads;
  14
  15        lwsl_client("libwebsocket_client_connect_2\n");
  16
  17         /*
  18          * proxy?
  19          */
  20
  21         if (context->http_proxy_port) {
  22                 plen = sprintf((char *)context->service_buffer,
  23                         "CONNECT %s:%u HTTP/1.0\x0d\x0a"
  24                         "User-agent: libwebsockets\x0d\x0a"
  25 /*Proxy-authorization: basic aGVsbG86d29ybGQ= */
  26                         "\x0d\x0a",
  27                         lws_hdr_simple_ptr(wsi, _WSI_TOKEN_CLIENT_PEER_ADDRESS),
  28                         wsi->u.hdr.ah->c_port);
  29                 ads = context->http_proxy_address;
  30                 server_addr.sin_port = htons(context->http_proxy_port);
  31         } else {
  32                 ads = lws_hdr_simple_ptr(wsi, _WSI_TOKEN_CLIENT_PEER_ADDRESS);
  33                 server_addr.sin_port = htons(wsi->u.hdr.ah->c_port);
  34         }
  35
  36         /*
  37          * prepare the actual connection (to the proxy, if any)
  38          */
  39        lwsl_client("libwebsocket_client_connect_2: address %s\n", ads);
  40
  41         server_hostent = gethostbyname(ads);
  42         if (server_hostent == NULL) {
  43                 lwsl_err("Unable to get host name from %s\n", ads);
  44                 goto oom4;
  45         }
  46
  47         if (wsi->sock < 0) {
  48
  49                 wsi->sock = socket(AF_INET, SOCK_STREAM, 0);
  50
  51                 if (wsi->sock < 0) {
  52                         lwsl_warn("Unable to open socket\n");
  53                         goto oom4;
  54                 }
  55
  56                 if (lws_set_socket_options(context, wsi->sock)) {
  57                         lwsl_err("Failed to set wsi socket options\n");
  58                         compatible_close(wsi->sock);
  59                         goto oom4;
  60                 }
  61
  62                 wsi->mode = LWS_CONNMODE_WS_CLIENT_WAITING_CONNECT;
  63
  64                 insert_wsi_socket_into_fds(context, wsi);
  65
  66                 libwebsocket_set_timeout(wsi,
  67                         PENDING_TIMEOUT_AWAITING_CONNECT_RESPONSE,
  68                                                               AWAITING_TIMEOUT);
  69
  70                 bzero((char *) &client_addr, sizeof(client_addr));
  71                 client_addr.sin_family = AF_INET;
  72
  73                 if (context->iface != NULL) {
  74                         if (interface_to_sa(context->iface, &client_addr,
  75                                                 sizeof(client_addr)) < 0) {
  76                                 lwsl_err("Unable to find interface %s\n", context->iface);
  77                                 compatible_close(wsi->sock);
  78                                 goto failed;
  79                         }
  80
  81                         if (bind(wsi->sock, (struct sockaddr *) &client_addr,
  82                                                         sizeof(client_addr)) < 0) {
  83                                 lwsl_err("Error binding to interface %s", context->iface);
  84                                 compatible_close(wsi->sock);
  85                                 goto failed;
  86                         }
  87                 }
  88         }
  89
  90         server_addr.sin_family = AF_INET;
  91         server_addr.sin_addr = *((struct in_addr *)server_hostent->h_addr);
  92
  93         bzero(&server_addr.sin_zero, 8);
  94
  95         if (connect(wsi->sock, (struct sockaddr *)&server_addr,
  96                           sizeof(struct sockaddr)) == -1 || LWS_ERRNO == LWS_EISCONN)  {
  97
  98                 if (LWS_ERRNO == LWS_EALREADY || LWS_ERRNO == LWS_EINPROGRESS) {
  99                         lwsl_client("nonblocking connect retry\n");
 100
 101                         /*
 102                          * must do specifically a POLLOUT poll to hear
 103                          * about the connect completion
 104                          */
 105                         lws_change_pollfd(wsi, 0, POLLOUT);
 106
 107                         return wsi;
 108                 }
 109
 110                 if (LWS_ERRNO != LWS_EISCONN) {
 111
 112                         lwsl_debug("Connect failed errno=%d\n", LWS_ERRNO);
 113                         goto failed;
 114                 }
 115         }
 116
 117         lwsl_client("connected\n");
 118
 119         /* we are connected to server, or proxy */
 120
 121         if (context->http_proxy_port) {
 122
 123                 /* OK from now on we talk via the proxy, so connect to that */
 124
 125                 /*
 126                  * (will overwrite existing pointer,
 127                  * leaving old string/frag there but unreferenced)
 128                  */
 129                 if (lws_hdr_simple_create(wsi, _WSI_TOKEN_CLIENT_PEER_ADDRESS,
 130                                                    context->http_proxy_address))
 131                         goto failed;
 132                 wsi->u.hdr.ah->c_port = context->http_proxy_port;
 133
 134                 n = send(wsi->sock, context->service_buffer, plen, MSG_NOSIGNAL);
 135                 if (n < 0) {
 136                         lwsl_debug("ERROR writing to proxy socket\n");
 137                         goto failed;
 138                 }
 139
 140                 libwebsocket_set_timeout(wsi,
 141                         PENDING_TIMEOUT_AWAITING_PROXY_RESPONSE,
 142                                                               AWAITING_TIMEOUT);
 143
 144                 wsi->mode = LWS_CONNMODE_WS_CLIENT_WAITING_PROXY_REPLY;
 145
 146                 return wsi;
 147         }
 148
 149         /*
 150          * provoke service to issue the handshake directly
 151          * we need to do it this way because in the proxy case, this is the
 152          * next state and executed only if and when we get a good proxy
 153          * response inside the state machine... but notice in SSL case this
 154          * may not have sent anything yet with 0 return, and won't until some
 155          * many retries from main loop.  To stop that becoming endless,
 156          * cover with a timeout.
 157          */
 158
 159         libwebsocket_set_timeout(wsi,
 160                 PENDING_TIMEOUT_SENT_CLIENT_HANDSHAKE, AWAITING_TIMEOUT);
 161
 162         wsi->mode = LWS_CONNMODE_WS_CLIENT_ISSUE_HANDSHAKE;
 163         pfd.fd = wsi->sock;
 164         pfd.revents = POLLIN;
 165
 166         n = libwebsocket_service_fd(context, &pfd);
 167
 168         if (n < 0)
 169                 goto failed;
 170
 171         if (n) /* returns 1 on failure after closing wsi */
 172                 return NULL;
 173
 174         return wsi;
 175
 176 oom4:
 177         free(wsi->u.hdr.ah);
 178         free(wsi);
 179         return NULL;
 180
 181 failed:
 182         libwebsocket_close_and_free_session(context, wsi,
 183                                                      LWS_CLOSE_STATUS_NOSTATUS);
 184         return NULL;
 185 }
 186
 187 /**
 188  * libwebsocket_client_connect() - Connect to another websocket server
 189  * @context:    Websocket context
 190  * @address:    Remote server address, eg, "myserver.com"
 191  * @port:       Port to connect to on the remote server, eg, 80
 192  * @ssl_connection:     0 = ws://, 1 = wss:// encrypted, 2 = wss:// allow self
 193  *                      signed certs
 194  * @path:       Websocket path on server
 195  * @host:       Hostname on server
 196  * @origin:     Socket origin name
 197  * @protocol:   Comma-separated list of protocols being asked for from
 198  *              the server, or just one.  The server will pick the one it
 199  *              likes best.
 200  * @ietf_version_or_minus_one: -1 to ask to connect using the default, latest
 201  *              protocol supported, or the specific protocol ordinal
 202  *
 203  *      This function creates a connection to a remote server
 204  */
 205
 206 LWS_VISIBLE struct libwebsocket *
 207 libwebsocket_client_connect(struct libwebsocket_context *context,
 208                               const char *address,
 209                               int port,
 210                               int ssl_connection,
 211                               const char *path,
 212                               const char *host,
 213                               const char *origin,
 214                               const char *protocol,
 215                               int ietf_version_or_minus_one)
 216 {
 217         struct libwebsocket *wsi;
 218 #ifndef LWS_NO_EXTENSIONS
 219         int n;
 220         int m;
 221         struct libwebsocket_extension *ext;
 222         int handled;
 223 #endif
 224
 225 #ifndef LWS_OPENSSL_SUPPORT
 226         if (ssl_connection) {
 227                 lwsl_err("libwebsockets not configured for ssl\n");
 228                 return NULL;
 229         }
 230 #endif
 231
 232         wsi = (struct libwebsocket *) malloc(sizeof(struct libwebsocket));
 233         if (wsi == NULL)
 234                 goto bail;
 235
 236         memset(wsi, 0, sizeof(*wsi));
 237         wsi->sock = -1;
 238
 239         /* -1 means just use latest supported */
 240
 241         if (ietf_version_or_minus_one == -1)
 242                 ietf_version_or_minus_one = SPEC_LATEST_SUPPORTED;
 243
 244         wsi->ietf_spec_revision = ietf_version_or_minus_one;
 245         wsi->user_space = NULL;
 246         wsi->state = WSI_STATE_CLIENT_UNCONNECTED;
 247         wsi->protocol = NULL;
 248         wsi->pending_timeout = NO_PENDING_TIMEOUT;
 249 #ifndef LWS_NO_EXTENSIONS
 250         wsi->count_active_extensions = 0;
 251 #endif
 252 #ifdef LWS_OPENSSL_SUPPORT
 253         wsi->use_ssl = ssl_connection;
 254 #endif
 255
 256         if (lws_allocate_header_table(wsi))
 257                 goto bail;
 258
 259         /*
 260          * we're not necessarily in a position to action these right away,
 261          * stash them... we only need during connect phase so u.hdr is fine
 262          */
 263         wsi->u.hdr.ah->c_port = port;
 264         if (lws_hdr_simple_create(wsi, _WSI_TOKEN_CLIENT_PEER_ADDRESS, address))
 265                 goto bail1;
 266
 267         /* these only need u.hdr lifetime as well */
 268
 269         if (lws_hdr_simple_create(wsi, _WSI_TOKEN_CLIENT_URI, path))
 270                 goto bail1;
 271
 272         if (lws_hdr_simple_create(wsi, _WSI_TOKEN_CLIENT_HOST, host))
 273                 goto bail1;
 274
 275         if (origin)
 276                 if (lws_hdr_simple_create(wsi,
 277                                 _WSI_TOKEN_CLIENT_ORIGIN, origin))
 278                         goto bail1;
 279         /*
 280          * this is a list of protocols we tell the server we're okay with
 281          * stash it for later when we compare server response with it
 282          */
 283         if (protocol)
 284                 if (lws_hdr_simple_create(wsi,
 285                                 _WSI_TOKEN_CLIENT_SENT_PROTOCOLS, protocol))
 286                         goto bail1;
 287
 288         wsi->protocol = &context->protocols[0];
 289
 290 #ifndef LWS_NO_EXTENSIONS
 291         /*
 292          * Check with each extension if it is able to route and proxy this
 293          * connection for us.  For example, an extension like x-google-mux
 294          * can handle this and then we don't need an actual socket for this
 295          * connection.
 296          */
 297
 298         handled = 0;
 299         ext = context->extensions;
 300         n = 0;
 301
 302         while (ext && ext->callback && !handled) {
 303                 m = ext->callback(context, ext, wsi,
 304                         LWS_EXT_CALLBACK_CAN_PROXY_CLIENT_CONNECTION,
 305                                  (void *)(long)n, (void *)address, port);
 306                 if (m)
 307                         handled = 1;
 308
 309                 ext++;
 310                 n++;
 311         }
 312
 313         if (handled) {
 314                 lwsl_client("libwebsocket_client_connect: ext handling conn\n");
 315
 316                 libwebsocket_set_timeout(wsi,
 317                         PENDING_TIMEOUT_AWAITING_EXTENSION_CONNECT_RESPONSE,
 318                                                               AWAITING_TIMEOUT);
 319
 320                 wsi->mode = LWS_CONNMODE_WS_CLIENT_WAITING_EXTENSION_CONNECT;
 321                 return wsi;
 322         }
 323 #endif
 324         lwsl_client("libwebsocket_client_connect: direct conn\n");
 325
 326        return libwebsocket_client_connect_2(context, wsi);
 327
 328 bail1:
 329         free(wsi->u.hdr.ah);
 330 bail:
 331         free(wsi);
 332
 333         return NULL;
 334 }
 335
 336
 337 /**
 338  * libwebsocket_client_connect_extended() - Connect to another websocket server
 339  * @context:    Websocket context
 340  * @address:    Remote server address, eg, "myserver.com"
 341  * @port:       Port to connect to on the remote server, eg, 80
 342  * @ssl_connection:     0 = ws://, 1 = wss:// encrypted, 2 = wss:// allow self
 343  *                      signed certs
 344  * @path:       Websocket path on server
 345  * @host:       Hostname on server
 346  * @origin:     Socket origin name
 347  * @protocol:   Comma-separated list of protocols being asked for from
 348  *              the server, or just one.  The server will pick the one it
 349  *              likes best.
 350  * @ietf_version_or_minus_one: -1 to ask to connect using the default, latest
 351  *              protocol supported, or the specific protocol ordinal
 352  * @userdata: Pre-allocated user data
 353  *
 354  *      This function creates a connection to a remote server
 355  */
 356
 357 LWS_VISIBLE struct libwebsocket *
 358 libwebsocket_client_connect_extended(struct libwebsocket_context *context,
 359                               const char *address,
 360                               int port,
 361                               int ssl_connection,
 362                               const char *path,
 363                               const char *host,
 364                               const char *origin,
 365                               const char *protocol,
 366                               int ietf_version_or_minus_one,
 367                               void *userdata)
 368 {
 369         struct libwebsocket *ws =
 370                 libwebsocket_client_connect(context, address, port,
 371                         ssl_connection, path, host, origin, protocol,
 372                                                      ietf_version_or_minus_one);
 373
 374         if (ws && !ws->user_space && userdata)
 375                 ws->user_space = userdata ;
 376
 377         return ws ;
 378 }