dlls/webservices/channel.c

   1 /*
   2  * Copyright 2016 Hans Leidekker for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20
  21 #include "windef.h"
  22 #include "winbase.h"
  23 #include "winuser.h"
  24 #include "webservices.h"
  25
  26 #include "wine/debug.h"
  27 #include "wine/list.h"
  28 #include "wine/unicode.h"
  29 #include "webservices_private.h"
  30 #include "sock.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(webservices);
  33
  34 static const struct prop_desc channel_props[] =
  35 {
  36     { sizeof(ULONG), FALSE },                               /* WS_CHANNEL_PROPERTY_MAX_BUFFERED_MESSAGE_SIZE */
  37     { sizeof(UINT64), FALSE },                              /* WS_CHANNEL_PROPERTY_MAX_STREAMED_MESSAGE_SIZE */
  38     { sizeof(ULONG), FALSE },                               /* WS_CHANNEL_PROPERTY_MAX_STREAMED_START_SIZE */
  39     { sizeof(ULONG), FALSE },                               /* WS_CHANNEL_PROPERTY_MAX_STREAMED_FLUSH_SIZE */
  40     { sizeof(WS_ENCODING), FALSE },                         /* WS_CHANNEL_PROPERTY_ENCODING */
  41     { sizeof(WS_ENVELOPE_VERSION), FALSE },                 /* WS_CHANNEL_PROPERTY_ENVELOPE_VERSION */
  42     { sizeof(WS_ADDRESSING_VERSION), FALSE },               /* WS_CHANNEL_PROPERTY_ADDRESSING_VERSION */
  43     { sizeof(ULONG), FALSE },                               /* WS_CHANNEL_PROPERTY_MAX_SESSION_DICTIONARY_SIZE */
  44     { sizeof(WS_CHANNEL_STATE), TRUE },                     /* WS_CHANNEL_PROPERTY_STATE */
  45     { sizeof(WS_CALLBACK_MODEL), FALSE },                   /* WS_CHANNEL_PROPERTY_ASYNC_CALLBACK_MODEL */
  46     { sizeof(WS_IP_VERSION), FALSE },                       /* WS_CHANNEL_PROPERTY_IP_VERSION */
  47     { sizeof(ULONG), FALSE },                               /* WS_CHANNEL_PROPERTY_RESOLVE_TIMEOUT */
  48     { sizeof(ULONG), FALSE },                               /* WS_CHANNEL_PROPERTY_CONNECT_TIMEOUT */
  49     { sizeof(ULONG), FALSE },                               /* WS_CHANNEL_PROPERTY_SEND_TIMEOUT */
  50     { sizeof(ULONG), FALSE },                               /* WS_CHANNEL_PROPERTY_RECEIVE_RESPONSE_TIMEOUT */
  51     { sizeof(ULONG), FALSE },                               /* WS_CHANNEL_PROPERTY_RECEIVE_TIMEOUT */
  52     { sizeof(ULONG), FALSE },                               /* WS_CHANNEL_PROPERTY_CLOSE_TIMEOUT */
  53     { sizeof(BOOL), FALSE },                                /* WS_CHANNEL_PROPERTY_ENABLE_TIMEOUTS */
  54     { sizeof(WS_TRANSFER_MODE), FALSE },                    /* WS_CHANNEL_PROPERTY_TRANSFER_MODE */
  55     { sizeof(ULONG), FALSE },                               /* WS_CHANNEL_PROPERTY_MULTICAST_INTERFACE */
  56     { sizeof(ULONG), FALSE },                               /* WS_CHANNEL_PROPERTY_MULTICAST_HOPS */
  57     { sizeof(WS_ENDPOINT_ADDRESS), TRUE },                  /* WS_CHANNEL_PROPERTY_REMOTE_ADDRESS */
  58     { sizeof(SOCKADDR_STORAGE), TRUE },                     /* WS_CHANNEL_PROPERTY_REMOTE_IP_ADDRESS */
  59     { sizeof(ULONGLONG), TRUE },                            /* WS_CHANNEL_PROPERTY_HTTP_CONNECTION_ID */
  60     { sizeof(WS_CUSTOM_CHANNEL_CALLBACKS), FALSE },         /* WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_CALLBACKS */
  61     { 0, FALSE },                                           /* WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_PARAMETERS */
  62     { sizeof(void *), FALSE },                              /* WS_CHANNEL_PROPERTY_CUSTOM_CHANNEL_INSTANCE */
  63     { sizeof(WS_STRING), TRUE },                            /* WS_CHANNEL_PROPERTY_TRANSPORT_URL */
  64     { sizeof(BOOL), FALSE },                                /* WS_CHANNEL_PROPERTY_NO_DELAY */
  65     { sizeof(BOOL), FALSE },                                /* WS_CHANNEL_PROPERTY_SEND_KEEP_ALIVES */
  66     { sizeof(ULONG), FALSE },                               /* WS_CHANNEL_PROPERTY_KEEP_ALIVE_TIME */
  67     { sizeof(ULONG), FALSE },                               /* WS_CHANNEL_PROPERTY_KEEP_ALIVE_INTERVAL */
  68     { sizeof(ULONG), FALSE },                               /* WS_CHANNEL_PROPERTY_MAX_HTTP_SERVER_CONNECTIONS */
  69     { sizeof(BOOL), TRUE },                                 /* WS_CHANNEL_PROPERTY_IS_SESSION_SHUT_DOWN */
  70     { sizeof(WS_CHANNEL_TYPE), TRUE },                      /* WS_CHANNEL_PROPERTY_CHANNEL_TYPE */
  71     { sizeof(ULONG), FALSE },                               /* WS_CHANNEL_PROPERTY_TRIM_BUFFERED_MESSAGE_SIZE */
  72     { sizeof(WS_CHANNEL_ENCODER), FALSE },                  /* WS_CHANNEL_PROPERTY_ENCODER */
  73     { sizeof(WS_CHANNEL_DECODER), FALSE },                  /* WS_CHANNEL_PROPERTY_DECODER */
  74     { sizeof(WS_PROTECTION_LEVEL), TRUE },                  /* WS_CHANNEL_PROPERTY_PROTECTION_LEVEL */
  75     { sizeof(WS_COOKIE_MODE), FALSE },                      /* WS_CHANNEL_PROPERTY_COOKIE_MODE */
  76     { sizeof(WS_HTTP_PROXY_SETTING_MODE), FALSE },          /* WS_CHANNEL_PROPERTY_HTTP_PROXY_SETTING_MODE */
  77     { sizeof(WS_CUSTOM_HTTP_PROXY), FALSE },                /* WS_CHANNEL_PROPERTY_CUSTOM_HTTP_PROXY */
  78     { sizeof(WS_HTTP_MESSAGE_MAPPING), FALSE },             /* WS_CHANNEL_PROPERTY_HTTP_MESSAGE_MAPPING */
  79     { sizeof(BOOL), FALSE },                                /* WS_CHANNEL_PROPERTY_ENABLE_HTTP_REDIRECT */
  80     { sizeof(WS_HTTP_REDIRECT_CALLBACK_CONTEXT), FALSE },   /* WS_CHANNEL_PROPERTY_HTTP_REDIRECT_CALLBACK_CONTEXT */
  81     { sizeof(BOOL), FALSE },                                /* WS_CHANNEL_PROPERTY_FAULTS_AS_ERRORS */
  82     { sizeof(BOOL), FALSE },                                /* WS_CHANNEL_PROPERTY_ALLOW_UNSECURED_FAULTS */
  83     { sizeof(WCHAR *), TRUE },                              /* WS_CHANNEL_PROPERTY_HTTP_SERVER_SPN */
  84     { sizeof(WCHAR *), TRUE },                              /* WS_CHANNEL_PROPERTY_HTTP_PROXY_SPN */
  85     { sizeof(ULONG), FALSE }                                /* WS_CHANNEL_PROPERTY_MAX_HTTP_REQUEST_HEADERS_BUFFER_SIZE */
  86 };
  87
  88 struct channel
  89 {
  90     ULONG                   magic;
  91     CRITICAL_SECTION        cs;
  92     WS_CHANNEL_TYPE         type;
  93     WS_CHANNEL_BINDING      binding;
  94     WS_CHANNEL_STATE        state;
  95     WS_ENDPOINT_ADDRESS     addr;
  96     WS_XML_WRITER          *writer;
  97     WS_XML_READER          *reader;
  98     WS_MESSAGE             *msg;
  99     union
 100     {
 101         struct
 102         {
 103             HINTERNET session;
 104             HINTERNET connect;
 105             HINTERNET request;
 106         } http;
 107         struct
 108         {
 109             SOCKET socket;
 110         } tcp;
 111         struct
 112         {
 113             SOCKET socket;
 114         } udp;
 115     } u;
 116     char                   *read_buf;
 117     ULONG                   read_buflen;
 118     ULONG                   read_size;
 119     ULONG                   prop_count;
 120     struct prop             prop[sizeof(channel_props)/sizeof(channel_props[0])];
 121 };
 122
 123 #define CHANNEL_MAGIC (('C' << 24) | ('H' << 16) | ('A' << 8) | 'N')
 124
 125 static struct channel *alloc_channel(void)
 126 {
 127     static const ULONG count = sizeof(channel_props)/sizeof(channel_props[0]);
 128     struct channel *ret;
 129     ULONG size = sizeof(*ret) + prop_size( channel_props, count );
 130
 131     if (!(ret = heap_alloc_zero( size ))) return NULL;
 132
 133     ret->magic      = CHANNEL_MAGIC;
 134     InitializeCriticalSection( &ret->cs );
 135     ret->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": channel.cs");
 136
 137     prop_init( channel_props, count, ret->prop, &ret[1] );
 138     ret->prop_count = count;
 139     return ret;
 140 }
 141
 142 static void reset_channel( struct channel *channel )
 143 {
 144     channel->state           = WS_CHANNEL_STATE_CREATED;
 145     heap_free( channel->addr.url.chars );
 146     channel->addr.url.chars  = NULL;
 147     channel->addr.url.length = 0;
 148     channel->msg             = NULL;
 149     channel->read_size       = 0;
 150
 151     switch (channel->binding)
 152     {
 153     case WS_HTTP_CHANNEL_BINDING:
 154         WinHttpCloseHandle( channel->u.http.request );
 155         channel->u.http.request = NULL;
 156         WinHttpCloseHandle( channel->u.http.connect );
 157         channel->u.http.connect = NULL;
 158         WinHttpCloseHandle( channel->u.http.session );
 159         channel->u.http.session = NULL;
 160         break;
 161
 162     case WS_TCP_CHANNEL_BINDING:
 163         closesocket( channel->u.tcp.socket );
 164         channel->u.tcp.socket = -1;
 165         break;
 166
 167     case WS_UDP_CHANNEL_BINDING:
 168         closesocket( channel->u.udp.socket );
 169         channel->u.udp.socket = -1;
 170         break;
 171
 172     default: break;
 173     }
 174 }
 175
 176 static void free_channel( struct channel *channel )
 177 {
 178     reset_channel( channel );
 179
 180     WsFreeWriter( channel->writer );
 181     WsFreeReader( channel->reader );
 182
 183     heap_free( channel->read_buf );
 184
 185     channel->cs.DebugInfo->Spare[0] = 0;
 186     DeleteCriticalSection( &channel->cs );
 187     heap_free( channel );
 188 }
 189
 190 static HRESULT create_channel( WS_CHANNEL_TYPE type, WS_CHANNEL_BINDING binding,
 191                                const WS_CHANNEL_PROPERTY *properties, ULONG count, struct channel **ret )
 192 {
 193     struct channel *channel;
 194     ULONG i, msg_size = 65536;
 195     HRESULT hr;
 196
 197     if (!(channel = alloc_channel())) return E_OUTOFMEMORY;
 198
 199     prop_set( channel->prop, channel->prop_count, WS_CHANNEL_PROPERTY_MAX_BUFFERED_MESSAGE_SIZE,
 200               &msg_size, sizeof(msg_size) );
 201
 202     for (i = 0; i < count; i++)
 203     {
 204         hr = prop_set( channel->prop, channel->prop_count, properties[i].id, properties[i].value,
 205                        properties[i].valueSize );
 206         if (hr != S_OK)
 207         {
 208             free_channel( channel );
 209             return hr;
 210         }
 211     }
 212
 213     channel->type    = type;
 214     channel->binding = binding;
 215
 216     switch (channel->binding)
 217     {
 218     case WS_TCP_CHANNEL_BINDING:
 219         channel->u.tcp.socket = -1;
 220         break;
 221
 222     case WS_UDP_CHANNEL_BINDING:
 223         channel->u.udp.socket = -1;
 224         break;
 225
 226     default: break;
 227     }
 228
 229     *ret = channel;
 230     return S_OK;
 231 }
 232
 233 /**************************************************************************
 234  *          WsCreateChannel             [webservices.@]
 235  */
 236 HRESULT WINAPI WsCreateChannel( WS_CHANNEL_TYPE type, WS_CHANNEL_BINDING binding,
 237                                 const WS_CHANNEL_PROPERTY *properties, ULONG count,
 238                                 const WS_SECURITY_DESCRIPTION *desc, WS_CHANNEL **handle,
 239                                 WS_ERROR *error )
 240 {
 241     struct channel *channel;
 242     HRESULT hr;
 243
 244     TRACE( "%u %u %p %u %p %p %p\n", type, binding, properties, count, desc, handle, error );
 245     if (error) FIXME( "ignoring error parameter\n" );
 246     if (desc) FIXME( "ignoring security description\n" );
 247
 248     if (!handle) return E_INVALIDARG;
 249
 250     if (type != WS_CHANNEL_TYPE_REQUEST && type != WS_CHANNEL_TYPE_DUPLEX &&
 251         type != WS_CHANNEL_TYPE_DUPLEX_SESSION)
 252     {
 253         FIXME( "channel type %u not implemented\n", type );
 254         return E_NOTIMPL;
 255     }
 256     if (binding != WS_HTTP_CHANNEL_BINDING && binding != WS_TCP_CHANNEL_BINDING &&
 257         binding != WS_UDP_CHANNEL_BINDING)
 258     {
 259         FIXME( "channel binding %u not implemented\n", binding );
 260         return E_NOTIMPL;
 261     }
 262
 263     if ((hr = create_channel( type, binding, properties, count, &channel )) != S_OK) return hr;
 264
 265     *handle = (WS_CHANNEL *)channel;
 266     return S_OK;
 267 }
 268
 269 /**************************************************************************
 270  *          WsCreateChannelForListener          [webservices.@]
 271  */
 272 HRESULT WINAPI WsCreateChannelForListener( WS_LISTENER *listener_handle, const WS_CHANNEL_PROPERTY *properties,
 273                                            ULONG count, WS_CHANNEL **handle, WS_ERROR *error )
 274 {
 275     struct channel *channel;
 276     WS_CHANNEL_TYPE type;
 277     WS_CHANNEL_BINDING binding;
 278     HRESULT hr;
 279
 280     TRACE( "%p %p %u %p %p\n", listener_handle, properties, count, handle, error );
 281     if (error) FIXME( "ignoring error parameter\n" );
 282
 283     if (!listener_handle || !handle) return E_INVALIDARG;
 284
 285     if ((hr = WsGetListenerProperty( listener_handle, WS_LISTENER_PROPERTY_CHANNEL_TYPE, &type,
 286                                      sizeof(type), NULL )) != S_OK) return hr;
 287
 288     if ((hr = WsGetListenerProperty( listener_handle, WS_LISTENER_PROPERTY_CHANNEL_BINDING, &binding,
 289                                      sizeof(binding), NULL )) != S_OK) return hr;
 290
 291     if ((hr = create_channel( type, binding, properties, count, &channel )) != S_OK) return hr;
 292
 293     *handle = (WS_CHANNEL *)channel;
 294     return S_OK;
 295 }
 296
 297 /**************************************************************************
 298  *          WsFreeChannel               [webservices.@]
 299  */
 300 void WINAPI WsFreeChannel( WS_CHANNEL *handle )
 301 {
 302     struct channel *channel = (struct channel *)handle;
 303
 304     TRACE( "%p\n", handle );
 305
 306     if (!channel) return;
 307
 308     EnterCriticalSection( &channel->cs );
 309
 310     if (channel->magic != CHANNEL_MAGIC)
 311     {
 312         LeaveCriticalSection( &channel->cs );
 313         return;
 314     }
 315
 316     channel->magic = 0;
 317
 318     LeaveCriticalSection( &channel->cs );
 319     free_channel( channel );
 320 }
 321
 322 /**************************************************************************
 323  *          WsResetChannel              [webservices.@]
 324  */
 325 HRESULT WINAPI WsResetChannel( WS_CHANNEL *handle, WS_ERROR *error )
 326 {
 327     struct channel *channel = (struct channel *)handle;
 328
 329     TRACE( "%p %p\n", handle, error );
 330     if (error) FIXME( "ignoring error parameter\n" );
 331
 332     if (!channel) return E_INVALIDARG;
 333
 334     EnterCriticalSection( &channel->cs );
 335
 336     if (channel->magic != CHANNEL_MAGIC)
 337     {
 338         LeaveCriticalSection( &channel->cs );
 339         return E_INVALIDARG;
 340     }
 341
 342     if (channel->state != WS_CHANNEL_STATE_CREATED && channel->state != WS_CHANNEL_STATE_CLOSED)
 343     {
 344         LeaveCriticalSection( &channel->cs );
 345         return WS_E_INVALID_OPERATION;
 346     }
 347
 348     reset_channel( channel );
 349
 350     LeaveCriticalSection( &channel->cs );
 351     return S_OK;
 352 }
 353
 354 /**************************************************************************
 355  *          WsGetChannelProperty                [webservices.@]
 356  */
 357 HRESULT WINAPI WsGetChannelProperty( WS_CHANNEL *handle, WS_CHANNEL_PROPERTY_ID id, void *buf,
 358                                      ULONG size, WS_ERROR *error )
 359 {
 360     struct channel *channel = (struct channel *)handle;
 361     HRESULT hr = S_OK;
 362
 363     TRACE( "%p %u %p %u %p\n", handle, id, buf, size, error );
 364     if (error) FIXME( "ignoring error parameter\n" );
 365
 366     if (!channel) return E_INVALIDARG;
 367
 368     EnterCriticalSection( &channel->cs );
 369
 370     if (channel->magic != CHANNEL_MAGIC)
 371     {
 372         LeaveCriticalSection( &channel->cs );
 373         return E_INVALIDARG;
 374     }
 375
 376     switch (id)
 377     {
 378     case WS_CHANNEL_PROPERTY_CHANNEL_TYPE:
 379         if (!buf || size != sizeof(channel->type)) hr = E_INVALIDARG;
 380         else *(WS_CHANNEL_TYPE *)buf = channel->type;
 381         break;
 382
 383     default:
 384         hr = prop_get( channel->prop, channel->prop_count, id, buf, size );
 385     }
 386
 387     LeaveCriticalSection( &channel->cs );
 388     return hr;
 389 }
 390
 391 /**************************************************************************
 392  *          WsSetChannelProperty                [webservices.@]
 393  */
 394 HRESULT WINAPI WsSetChannelProperty( WS_CHANNEL *handle, WS_CHANNEL_PROPERTY_ID id, const void *value,
 395                                      ULONG size, WS_ERROR *error )
 396 {
 397     struct channel *channel = (struct channel *)handle;
 398     HRESULT hr;
 399
 400     TRACE( "%p %u %p %u\n", handle, id, value, size );
 401     if (error) FIXME( "ignoring error parameter\n" );
 402
 403     if (!channel) return E_INVALIDARG;
 404
 405     EnterCriticalSection( &channel->cs );
 406
 407     if (channel->magic != CHANNEL_MAGIC)
 408     {
 409         LeaveCriticalSection( &channel->cs );
 410         return E_INVALIDARG;
 411     }
 412
 413     hr = prop_set( channel->prop, channel->prop_count, id, value, size );
 414
 415     LeaveCriticalSection( &channel->cs );
 416     return hr;
 417 }
 418
 419 static HRESULT open_channel( struct channel *channel, const WS_ENDPOINT_ADDRESS *endpoint )
 420 {
 421     if (endpoint->headers || endpoint->extensions || endpoint->identity)
 422     {
 423         FIXME( "headers, extensions or identity not supported\n" );
 424         return E_NOTIMPL;
 425     }
 426
 427     if (!(channel->addr.url.chars = heap_alloc( endpoint->url.length * sizeof(WCHAR) ))) return E_OUTOFMEMORY;
 428     memcpy( channel->addr.url.chars, endpoint->url.chars, endpoint->url.length * sizeof(WCHAR) );
 429     channel->addr.url.length = endpoint->url.length;
 430
 431     channel->state = WS_CHANNEL_STATE_OPEN;
 432     return S_OK;
 433 }
 434
 435 /**************************************************************************
 436  *          WsOpenChannel               [webservices.@]
 437  */
 438 HRESULT WINAPI WsOpenChannel( WS_CHANNEL *handle, const WS_ENDPOINT_ADDRESS *endpoint,
 439                               const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error )
 440 {
 441     struct channel *channel = (struct channel *)handle;
 442     HRESULT hr;
 443
 444     TRACE( "%p %p %p %p\n", handle, endpoint, ctx, error );
 445     if (error) FIXME( "ignoring error parameter\n" );
 446     if (ctx) FIXME( "ignoring ctx parameter\n" );
 447
 448     if (!channel || !endpoint) return E_INVALIDARG;
 449
 450     EnterCriticalSection( &channel->cs );
 451
 452     if (channel->magic != CHANNEL_MAGIC)
 453     {
 454         LeaveCriticalSection( &channel->cs );
 455         return E_INVALIDARG;
 456     }
 457
 458     if (channel->state != WS_CHANNEL_STATE_CREATED)
 459     {
 460         LeaveCriticalSection( &channel->cs );
 461         return WS_E_INVALID_OPERATION;
 462     }
 463
 464     hr = open_channel( channel, endpoint );
 465
 466     LeaveCriticalSection( &channel->cs );
 467     return hr;
 468 }
 469
 470 static void close_channel( struct channel *channel )
 471 {
 472     reset_channel( channel );
 473     channel->state = WS_CHANNEL_STATE_CLOSED;
 474 }
 475
 476 /**************************************************************************
 477  *          WsCloseChannel              [webservices.@]
 478  */
 479 HRESULT WINAPI WsCloseChannel( WS_CHANNEL *handle, const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error )
 480 {
 481     struct channel *channel = (struct channel *)handle;
 482
 483     TRACE( "%p %p %p\n", handle, ctx, error );
 484     if (error) FIXME( "ignoring error parameter\n" );
 485     if (ctx) FIXME( "ignoring ctx parameter\n" );
 486
 487     if (!channel) return E_INVALIDARG;
 488
 489     EnterCriticalSection( &channel->cs );
 490
 491     if (channel->magic != CHANNEL_MAGIC)
 492     {
 493         LeaveCriticalSection( &channel->cs );
 494         return E_INVALIDARG;
 495     }
 496
 497     close_channel( channel );
 498
 499     LeaveCriticalSection( &channel->cs );
 500     return S_OK;
 501 }
 502
 503 static HRESULT parse_http_url( const WCHAR *url, ULONG len, URL_COMPONENTS *uc )
 504 {
 505     HRESULT hr = E_OUTOFMEMORY;
 506     WCHAR *tmp;
 507     DWORD err;
 508
 509     memset( uc, 0, sizeof(*uc) );
 510     uc->dwStructSize      = sizeof(*uc);
 511     uc->dwHostNameLength  = 128;
 512     uc->lpszHostName      = heap_alloc( uc->dwHostNameLength * sizeof(WCHAR) );
 513     uc->dwUrlPathLength   = 128;
 514     uc->lpszUrlPath       = heap_alloc( uc->dwUrlPathLength * sizeof(WCHAR) );
 515     uc->dwExtraInfoLength = 128;
 516     uc->lpszExtraInfo     = heap_alloc( uc->dwExtraInfoLength * sizeof(WCHAR) );
 517     if (!uc->lpszHostName || !uc->lpszUrlPath || !uc->lpszExtraInfo) goto error;
 518
 519     if (!WinHttpCrackUrl( url, len, ICU_DECODE, uc ))
 520     {
 521         if ((err = GetLastError()) != ERROR_INSUFFICIENT_BUFFER)
 522         {
 523             hr = HRESULT_FROM_WIN32( err );
 524             goto error;
 525         }
 526         if (!(tmp = heap_realloc( uc->lpszHostName, uc->dwHostNameLength * sizeof(WCHAR) ))) goto error;
 527         uc->lpszHostName = tmp;
 528         if (!(tmp = heap_realloc( uc->lpszUrlPath, uc->dwUrlPathLength * sizeof(WCHAR) ))) goto error;
 529         uc->lpszUrlPath = tmp;
 530         if (!(tmp = heap_realloc( uc->lpszExtraInfo, uc->dwExtraInfoLength * sizeof(WCHAR) ))) goto error;
 531         uc->lpszExtraInfo = tmp;
 532         WinHttpCrackUrl( url, len, ICU_DECODE, uc );
 533     }
 534
 535     return S_OK;
 536
 537 error:
 538     heap_free( uc->lpszHostName );
 539     heap_free( uc->lpszUrlPath );
 540     heap_free( uc->lpszExtraInfo );
 541     return hr;
 542 }
 543
 544 static HRESULT connect_channel_http( struct channel *channel )
 545 {
 546     static const WCHAR agentW[] =
 547         {'M','S','-','W','e','b','S','e','r','v','i','c','e','s','/','1','.','0',0};
 548     static const WCHAR postW[] =
 549         {'P','O','S','T',0};
 550     HINTERNET ses = NULL, con = NULL, req = NULL;
 551     WCHAR *path;
 552     URL_COMPONENTS uc;
 553     DWORD flags = 0;
 554     HRESULT hr;
 555
 556     if (channel->u.http.request) return S_OK;
 557
 558     if ((hr = parse_http_url( channel->addr.url.chars, channel->addr.url.length, &uc )) != S_OK) return hr;
 559     if (!uc.dwExtraInfoLength) path = uc.lpszUrlPath;
 560     else if (!(path = heap_alloc( (uc.dwUrlPathLength + uc.dwExtraInfoLength + 1) * sizeof(WCHAR) )))
 561     {
 562         hr = E_OUTOFMEMORY;
 563         goto done;
 564     }
 565     else
 566     {
 567         strcpyW( path, uc.lpszUrlPath );
 568         strcatW( path, uc.lpszExtraInfo );
 569     }
 570
 571     switch (uc.nScheme)
 572     {
 573     case INTERNET_SCHEME_HTTP: break;
 574     case INTERNET_SCHEME_HTTPS:
 575         flags |= WINHTTP_FLAG_SECURE;
 576         break;
 577
 578     default:
 579         hr = WS_E_INVALID_ENDPOINT_URL;
 580         goto done;
 581     }
 582
 583     if (!(ses = WinHttpOpen( agentW, 0, NULL, NULL, 0 )))
 584     {
 585         hr = HRESULT_FROM_WIN32( GetLastError() );
 586         goto done;
 587     }
 588     if (!(con = WinHttpConnect( ses, uc.lpszHostName, uc.nPort, 0 )))
 589     {
 590         hr = HRESULT_FROM_WIN32( GetLastError() );
 591         goto done;
 592     }
 593     if (!(req = WinHttpOpenRequest( con, postW, path, NULL, NULL, NULL, flags )))
 594     {
 595         hr = HRESULT_FROM_WIN32( GetLastError() );
 596         goto done;
 597     }
 598
 599     if ((hr = message_insert_http_headers( channel->msg, req )) != S_OK) goto done;
 600
 601     channel->u.http.session = ses;
 602     channel->u.http.connect = con;
 603     channel->u.http.request = req;
 604
 605 done:
 606     if (hr != S_OK)
 607     {
 608         WinHttpCloseHandle( req );
 609         WinHttpCloseHandle( con );
 610         WinHttpCloseHandle( ses );
 611     }
 612     heap_free( uc.lpszHostName );
 613     heap_free( uc.lpszUrlPath );
 614     heap_free( uc.lpszExtraInfo );
 615     if (path != uc.lpszUrlPath) heap_free( path );
 616     return hr;
 617 }
 618
 619 static HRESULT connect_channel_tcp( struct channel *channel )
 620 {
 621     struct sockaddr_storage storage;
 622     struct sockaddr *addr = (struct sockaddr *)&storage;
 623     int addr_len;
 624     WS_URL_SCHEME_TYPE scheme;
 625     WCHAR *host;
 626     USHORT port;
 627     HRESULT hr;
 628
 629     if (channel->u.tcp.socket != -1) return S_OK;
 630
 631     if ((hr = parse_url( &channel->addr.url, &scheme, &host, &port )) != S_OK) return hr;
 632     if (scheme != WS_URL_NETTCP_SCHEME_TYPE)
 633     {
 634         heap_free( host );
 635         return WS_E_INVALID_ENDPOINT_URL;
 636     }
 637
 638     winsock_init();
 639
 640     hr = resolve_hostname( host, port, addr, &addr_len );
 641     heap_free( host );
 642     if (hr != S_OK) return hr;
 643
 644     if ((channel->u.tcp.socket = socket( addr->sa_family, SOCK_STREAM, 0 )) == -1)
 645         return HRESULT_FROM_WIN32( WSAGetLastError() );
 646
 647     if (connect( channel->u.tcp.socket, addr, addr_len ) < 0)
 648     {
 649         closesocket( channel->u.tcp.socket );
 650         channel->u.tcp.socket = -1;
 651         return HRESULT_FROM_WIN32( WSAGetLastError() );
 652     }
 653
 654     return S_OK;
 655 }
 656
 657 static HRESULT connect_channel_udp( struct channel *channel )
 658 {
 659     struct sockaddr_storage storage;
 660     struct sockaddr *addr = (struct sockaddr *)&storage;
 661     int addr_len;
 662     WS_URL_SCHEME_TYPE scheme;
 663     WCHAR *host;
 664     USHORT port;
 665     HRESULT hr;
 666
 667     if (channel->u.udp.socket != -1) return S_OK;
 668
 669     if ((hr = parse_url( &channel->addr.url, &scheme, &host, &port )) != S_OK) return hr;
 670     if (scheme != WS_URL_SOAPUDP_SCHEME_TYPE)
 671     {
 672         heap_free( host );
 673         return WS_E_INVALID_ENDPOINT_URL;
 674     }
 675
 676     winsock_init();
 677
 678     hr = resolve_hostname( host, port, addr, &addr_len );
 679     heap_free( host );
 680     if (hr != S_OK) return hr;
 681
 682     if ((channel->u.udp.socket = socket( addr->sa_family, SOCK_DGRAM, 0 )) == -1)
 683         return HRESULT_FROM_WIN32( WSAGetLastError() );
 684
 685     if (connect( channel->u.udp.socket, addr, addr_len ) < 0)
 686     {
 687         closesocket( channel->u.udp.socket );
 688         channel->u.udp.socket = -1;
 689         return HRESULT_FROM_WIN32( WSAGetLastError() );
 690     }
 691
 692     return S_OK;
 693 }
 694
 695 static HRESULT connect_channel( struct channel *channel )
 696 {
 697     switch (channel->binding)
 698     {
 699     case WS_HTTP_CHANNEL_BINDING:
 700         return connect_channel_http( channel );
 701
 702     case WS_TCP_CHANNEL_BINDING:
 703         return connect_channel_tcp( channel );
 704
 705     case WS_UDP_CHANNEL_BINDING:
 706         return connect_channel_udp( channel );
 707
 708     default:
 709         ERR( "unhandled binding %u\n", channel->binding );
 710         return E_NOTIMPL;
 711     }
 712 }
 713
 714 static HRESULT write_message( WS_MESSAGE *handle, WS_XML_WRITER *writer, const WS_ELEMENT_DESCRIPTION *desc,
 715                               WS_WRITE_OPTION option, const void *body, ULONG size )
 716 {
 717     HRESULT hr;
 718     if ((hr = WsWriteEnvelopeStart( handle, writer, NULL, NULL, NULL )) != S_OK) return hr;
 719     if ((hr = WsWriteBody( handle, desc, option, body, size, NULL )) != S_OK) return hr;
 720     return WsWriteEnvelopeEnd( handle, NULL );
 721 }
 722
 723 static HRESULT send_message_http( HANDLE request, BYTE *data, ULONG len )
 724 {
 725     if (!WinHttpSendRequest( request, NULL, 0, data, len, len, 0 ))
 726         return HRESULT_FROM_WIN32( GetLastError() );
 727
 728     if (!WinHttpReceiveResponse( request, NULL ))
 729         return HRESULT_FROM_WIN32( GetLastError() );
 730     return S_OK;
 731 }
 732
 733 static HRESULT send_message_sock( SOCKET socket, BYTE *data, ULONG len )
 734 {
 735     if (send( socket, (const char *)data, len, 0 ) < 0)
 736         return HRESULT_FROM_WIN32( WSAGetLastError() );
 737     return S_OK;
 738 }
 739
 740 static HRESULT send_message( struct channel *channel, WS_MESSAGE *msg )
 741 {
 742     WS_XML_WRITER *writer;
 743     WS_BYTES buf;
 744     HRESULT hr;
 745
 746     channel->msg = msg;
 747     if ((hr = connect_channel( channel )) != S_OK) return hr;
 748
 749     WsGetMessageProperty( channel->msg, WS_MESSAGE_PROPERTY_BODY_WRITER, &writer, sizeof(writer), NULL );
 750     WsGetWriterProperty( writer, WS_XML_WRITER_PROPERTY_BYTES, &buf, sizeof(buf), NULL );
 751
 752     switch (channel->binding)
 753     {
 754     case WS_HTTP_CHANNEL_BINDING:
 755         return send_message_http( channel->u.http.request, buf.bytes, buf.length );
 756
 757     case WS_TCP_CHANNEL_BINDING:
 758         return send_message_sock( channel->u.tcp.socket, buf.bytes, buf.length );
 759
 760     case WS_UDP_CHANNEL_BINDING:
 761         return send_message_sock( channel->u.udp.socket, buf.bytes, buf.length );
 762
 763     default:
 764         ERR( "unhandled binding %u\n", channel->binding );
 765         return E_NOTIMPL;
 766     }
 767 }
 768
 769 HRESULT channel_send_message( WS_CHANNEL *handle, WS_MESSAGE *msg )
 770 {
 771     struct channel *channel = (struct channel *)handle;
 772     HRESULT hr;
 773
 774     EnterCriticalSection( &channel->cs );
 775
 776     if (channel->magic != CHANNEL_MAGIC)
 777     {
 778         LeaveCriticalSection( &channel->cs );
 779         return E_INVALIDARG;
 780     }
 781
 782     hr = send_message( channel, msg );
 783
 784     LeaveCriticalSection( &channel->cs );
 785     return hr;
 786 }
 787
 788 HRESULT set_output( WS_XML_WRITER *writer )
 789 {
 790     WS_XML_WRITER_TEXT_ENCODING text = { {WS_XML_WRITER_ENCODING_TYPE_TEXT}, WS_CHARSET_UTF8 };
 791     WS_XML_WRITER_BUFFER_OUTPUT buf = { {WS_XML_WRITER_OUTPUT_TYPE_BUFFER} };
 792     return WsSetOutput( writer, &text.encoding, &buf.output, NULL, 0, NULL );
 793 }
 794
 795 static HRESULT init_writer( struct channel *channel )
 796 {
 797     HRESULT hr;
 798     if (!channel->writer && (hr = WsCreateWriter( NULL, 0, &channel->writer, NULL )) != S_OK) return hr;
 799     return set_output( channel->writer );
 800 }
 801
 802 /**************************************************************************
 803  *          WsSendMessage               [webservices.@]
 804  */
 805 HRESULT WINAPI WsSendMessage( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_MESSAGE_DESCRIPTION *desc,
 806                               WS_WRITE_OPTION option, const void *body, ULONG size, const WS_ASYNC_CONTEXT *ctx,
 807                               WS_ERROR *error )
 808 {
 809     struct channel *channel = (struct channel *)handle;
 810     HRESULT hr;
 811
 812     TRACE( "%p %p %p %08x %p %u %p %p\n", handle, msg, desc, option, body, size, ctx, error );
 813     if (error) FIXME( "ignoring error parameter\n" );
 814     if (ctx) FIXME( "ignoring ctx parameter\n" );
 815
 816     if (!channel || !msg || !desc) return E_INVALIDARG;
 817
 818     EnterCriticalSection( &channel->cs );
 819
 820     if (channel->magic != CHANNEL_MAGIC)
 821     {
 822         LeaveCriticalSection( &channel->cs );
 823         return E_INVALIDARG;
 824     }
 825
 826     if ((hr = WsInitializeMessage( msg, WS_REQUEST_MESSAGE, NULL, NULL )) != S_OK) goto done;
 827     if ((hr = WsAddressMessage( msg, &channel->addr, NULL )) != S_OK) goto done;
 828     if ((hr = message_set_action( msg, desc->action )) != S_OK) goto done;
 829
 830     if ((hr = init_writer( channel )) != S_OK) goto done;
 831     if ((hr = write_message( msg, channel->writer, desc->bodyElementDescription, option, body, size )) != S_OK)
 832         goto done;
 833     hr = send_message( channel, msg );
 834
 835 done:
 836     LeaveCriticalSection( &channel->cs );
 837     return hr;
 838 }
 839
 840 static HRESULT resize_read_buffer( struct channel *channel, ULONG size )
 841 {
 842     if (!channel->read_buf)
 843     {
 844         if (!(channel->read_buf = heap_alloc( size ))) return E_OUTOFMEMORY;
 845         channel->read_buflen = size;
 846         return S_OK;
 847     }
 848     if (channel->read_buflen < size)
 849     {
 850         char *tmp;
 851         ULONG new_size = max( size, channel->read_buflen * 2 );
 852         if (!(tmp = heap_realloc( channel->read_buf, new_size ))) return E_OUTOFMEMORY;
 853         channel->read_buf = tmp;
 854         channel->read_buflen = new_size;
 855     }
 856     return S_OK;
 857 }
 858
 859 static HRESULT set_input( WS_XML_READER *reader, char *data, ULONG size )
 860 {
 861     WS_XML_READER_TEXT_ENCODING text = {{WS_XML_READER_ENCODING_TYPE_TEXT}, WS_CHARSET_UTF8};
 862     WS_XML_READER_BUFFER_INPUT buf;
 863
 864     buf.input.inputType = WS_XML_READER_INPUT_TYPE_BUFFER;
 865     buf.encodedData     = data;
 866     buf.encodedDataSize = size;
 867     return WsSetInput( reader, &text.encoding, &buf.input, NULL, 0, NULL );
 868 }
 869
 870 static HRESULT init_reader( struct channel *channel )
 871 {
 872     HRESULT hr;
 873     if (!channel->reader && (hr = WsCreateReader( NULL, 0, &channel->reader, NULL )) != S_OK) return hr;
 874     return set_input( channel->reader, channel->read_buf, channel->read_size );
 875 }
 876
 877 #define INITIAL_READ_BUFFER_SIZE 4096
 878 static HRESULT receive_message_http( struct channel *channel )
 879 {
 880     DWORD len, bytes_read, offset = 0, size = INITIAL_READ_BUFFER_SIZE;
 881     ULONG max_len;
 882     HRESULT hr;
 883
 884     prop_get( channel->prop, channel->prop_count, WS_CHANNEL_PROPERTY_MAX_BUFFERED_MESSAGE_SIZE,
 885               &max_len, sizeof(max_len) );
 886
 887     if ((hr = resize_read_buffer( channel, size )) != S_OK) return hr;
 888     channel->read_size = 0;
 889     for (;;)
 890     {
 891         if (!WinHttpQueryDataAvailable( channel->u.http.request, &len ))
 892         {
 893             return HRESULT_FROM_WIN32( GetLastError() );
 894         }
 895         if (!len) break;
 896         if (channel->read_size + len > max_len) return WS_E_QUOTA_EXCEEDED;
 897         if ((hr = resize_read_buffer( channel, channel->read_size + len )) != S_OK) return hr;
 898
 899         if (!WinHttpReadData( channel->u.http.request, channel->read_buf + offset, len, &bytes_read ))
 900         {
 901             return HRESULT_FROM_WIN32( GetLastError() );
 902         }
 903         if (!bytes_read) break;
 904         channel->read_size += bytes_read;
 905         offset += bytes_read;
 906     }
 907
 908     return init_reader( channel );
 909 }
 910
 911 static HRESULT receive_message_sock( struct channel *channel, SOCKET socket )
 912 {
 913     int bytes_read;
 914     ULONG max_len;
 915     HRESULT hr;
 916
 917     prop_get( channel->prop, channel->prop_count, WS_CHANNEL_PROPERTY_MAX_BUFFERED_MESSAGE_SIZE,
 918               &max_len, sizeof(max_len) );
 919
 920     if ((hr = resize_read_buffer( channel, max_len )) != S_OK) return hr;
 921
 922     channel->read_size = 0;
 923     if ((bytes_read = recv( socket, channel->read_buf, max_len, 0 )) < 0)
 924     {
 925         return HRESULT_FROM_WIN32( WSAGetLastError() );
 926     }
 927     channel->read_size = bytes_read;
 928
 929     return init_reader( channel );
 930 }
 931
 932 static HRESULT receive_message( struct channel *channel )
 933 {
 934     HRESULT hr;
 935
 936     if ((hr = connect_channel( channel )) != S_OK) return hr;
 937
 938     switch (channel->binding)
 939     {
 940     case WS_HTTP_CHANNEL_BINDING:
 941         return receive_message_http( channel );
 942
 943     case WS_TCP_CHANNEL_BINDING:
 944         return receive_message_sock( channel, channel->u.tcp.socket );
 945
 946     case WS_UDP_CHANNEL_BINDING:
 947         return receive_message_sock( channel, channel->u.udp.socket );
 948
 949     default:
 950         ERR( "unhandled binding %u\n", channel->binding );
 951         return E_NOTIMPL;
 952     }
 953 }
 954
 955 HRESULT channel_receive_message( WS_CHANNEL *handle )
 956 {
 957     struct channel *channel = (struct channel *)handle;
 958     HRESULT hr;
 959
 960     EnterCriticalSection( &channel->cs );
 961
 962     if (channel->magic != CHANNEL_MAGIC)
 963     {
 964         LeaveCriticalSection( &channel->cs );
 965         return E_INVALIDARG;
 966     }
 967
 968     hr = receive_message( channel );
 969
 970     LeaveCriticalSection( &channel->cs );
 971     return hr;
 972 }
 973
 974 HRESULT channel_get_reader( WS_CHANNEL *handle, WS_XML_READER **reader )
 975 {
 976     struct channel *channel = (struct channel *)handle;
 977
 978     EnterCriticalSection( &channel->cs );
 979
 980     if (channel->magic != CHANNEL_MAGIC)
 981     {
 982         LeaveCriticalSection( &channel->cs );
 983         return E_INVALIDARG;
 984     }
 985
 986     *reader = channel->reader;
 987
 988     LeaveCriticalSection( &channel->cs );
 989     return S_OK;
 990 }
 991
 992 static HRESULT read_message( WS_MESSAGE *handle, WS_XML_READER *reader, const WS_ELEMENT_DESCRIPTION *desc,
 993                              WS_READ_OPTION option, WS_HEAP *heap, void *body, ULONG size )
 994 {
 995     HRESULT hr;
 996     if ((hr = WsReadEnvelopeStart( handle, reader, NULL, NULL, NULL )) != S_OK) return hr;
 997     if ((hr = WsReadBody( handle, desc, option, heap, body, size, NULL )) != S_OK) return hr;
 998     return WsReadEnvelopeEnd( handle, NULL );
 999 }
1000
1001 /**************************************************************************
1002  *          WsReceiveMessage            [webservices.@]
1003  */
1004 HRESULT WINAPI WsReceiveMessage( WS_CHANNEL *handle, WS_MESSAGE *msg, const WS_MESSAGE_DESCRIPTION **desc,
1005                                  ULONG count, WS_RECEIVE_OPTION option, WS_READ_OPTION read_option, WS_HEAP *heap,
1006                                  void *value, ULONG size, ULONG *index, const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error )
1007 {
1008     struct channel *channel = (struct channel *)handle;
1009     HRESULT hr;
1010
1011     TRACE( "%p %p %p %u %08x %08x %p %p %u %p %p %p\n", handle, msg, desc, count, option, read_option, heap,
1012            value, size, index, ctx, error );
1013     if (error) FIXME( "ignoring error parameter\n" );
1014     if (ctx) FIXME( "ignoring ctx parameter\n" );
1015     if (index)
1016     {
1017         FIXME( "index parameter not supported\n" );
1018         return E_NOTIMPL;
1019     }
1020     if (count != 1)
1021     {
1022         FIXME( "no support for multiple descriptions\n" );
1023         return E_NOTIMPL;
1024     }
1025     if (option != WS_RECEIVE_REQUIRED_MESSAGE)
1026     {
1027         FIXME( "receive option %08x not supported\n", option );
1028         return E_NOTIMPL;
1029     }
1030
1031     if (!channel || !msg || !desc || !count) return E_INVALIDARG;
1032
1033     EnterCriticalSection( &channel->cs );
1034
1035     if (channel->magic != CHANNEL_MAGIC)
1036     {
1037         LeaveCriticalSection( &channel->cs );
1038         return E_INVALIDARG;
1039     }
1040
1041     if ((hr = receive_message( channel )) != S_OK) goto done;
1042     hr = read_message( msg, channel->reader, desc[0]->bodyElementDescription, read_option, heap, value, size );
1043
1044 done:
1045     LeaveCriticalSection( &channel->cs );
1046     return hr;
1047 }
1048
1049 HRESULT channel_accept_tcp( SOCKET socket, WS_CHANNEL *handle )
1050 {
1051     struct channel *channel = (struct channel *)handle;
1052
1053     EnterCriticalSection( &channel->cs );
1054
1055     if (channel->magic != CHANNEL_MAGIC)
1056     {
1057         LeaveCriticalSection( &channel->cs );
1058         return E_INVALIDARG;
1059     }
1060
1061     if ((channel->u.tcp.socket = accept( socket, NULL, NULL )) == -1)
1062     {
1063         LeaveCriticalSection( &channel->cs );
1064         return HRESULT_FROM_WIN32( WSAGetLastError() );
1065     }
1066
1067     LeaveCriticalSection( &channel->cs );
1068     return S_OK;
1069 }
1070
1071 static HRESULT sock_wait( SOCKET socket )
1072 {
1073     fd_set read;
1074
1075     FD_ZERO( &read );
1076     FD_SET( socket, &read );
1077     if (select( socket + 1, &read, NULL, NULL, NULL ) < 0) return HRESULT_FROM_WIN32( WSAGetLastError() );
1078     return S_OK;
1079 }
1080
1081 HRESULT channel_accept_udp( SOCKET socket, WS_CHANNEL *handle )
1082 {
1083     struct channel *channel = (struct channel *)handle;
1084     HRESULT hr;
1085
1086     EnterCriticalSection( &channel->cs );
1087
1088     if (channel->magic != CHANNEL_MAGIC)
1089     {
1090         LeaveCriticalSection( &channel->cs );
1091         return E_INVALIDARG;
1092     }
1093
1094     if ((hr = sock_wait( socket )) == S_OK) channel->u.udp.socket = socket;
1095
1096     LeaveCriticalSection( &channel->cs );
1097     return hr;
1098 }