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 "webservices_private.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(webservices);
  31
  32 static const struct prop_desc channel_props[] =
  33 {
  34     { sizeof(ULONG), FALSE },                   /* WS_CHANNEL_PROPERTY_MAX_BUFFERED_MESSAGE_SIZE */
  35     { sizeof(UINT64), FALSE },                  /* WS_CHANNEL_PROPERTY_MAX_STREAMED_MESSAGE_SIZE */
  36     { sizeof(ULONG), FALSE },                   /* WS_CHANNEL_PROPERTY_MAX_STREAMED_START_SIZE */
  37     { sizeof(ULONG), FALSE },                   /* WS_CHANNEL_PROPERTY_MAX_STREAMED_FLUSH_SIZE */
  38     { sizeof(WS_ENCODING), FALSE },             /* WS_CHANNEL_PROPERTY_ENCODING */
  39     { sizeof(WS_ENVELOPE_VERSION), FALSE },     /* WS_CHANNEL_PROPERTY_ENVELOPE_VERSION */
  40     { sizeof(WS_ADDRESSING_VERSION), FALSE },   /* WS_CHANNEL_PROPERTY_ADDRESSING_VERSION */
  41     { sizeof(ULONG), FALSE },                   /* WS_CHANNEL_PROPERTY_MAX_SESSION_DICTIONARY_SIZE */
  42     { sizeof(WS_CHANNEL_STATE), TRUE },         /* WS_CHANNEL_PROPERTY_STATE */
  43 };
  44
  45 static struct channel *alloc_channel(void)
  46 {
  47     static const ULONG count = sizeof(channel_props)/sizeof(channel_props[0]);
  48     struct channel *ret;
  49     ULONG size = sizeof(*ret) + prop_size( channel_props, count );
  50
  51     if (!(ret = heap_alloc_zero( size ))) return NULL;
  52     prop_init( channel_props, count, ret->prop, &ret[1] );
  53     ret->prop_count = count;
  54     return ret;
  55 }
  56
  57 void free_channel( struct channel *channel )
  58 {
  59     heap_free( channel );
  60 }
  61
  62 HRESULT create_channel( WS_CHANNEL_TYPE type, WS_CHANNEL_BINDING binding,
  63                         const WS_CHANNEL_PROPERTY *properties, ULONG count, struct channel **ret )
  64 {
  65     struct channel *channel;
  66     ULONG i, msg_size = 65536;
  67     HRESULT hr;
  68
  69     if (!(channel = alloc_channel())) return E_OUTOFMEMORY;
  70
  71     prop_set( channel->prop, channel->prop_count, WS_CHANNEL_PROPERTY_MAX_BUFFERED_MESSAGE_SIZE,
  72               &msg_size, sizeof(msg_size) );
  73
  74     for (i = 0; i < count; i++)
  75     {
  76         hr = prop_set( channel->prop, channel->prop_count, properties[i].id, properties[i].value,
  77                        properties[i].valueSize );
  78         if (hr != S_OK)
  79         {
  80             free_channel( channel );
  81             return hr;
  82         }
  83     }
  84
  85     channel->type    = type;
  86     channel->binding = binding;
  87
  88     *ret = channel;
  89     return S_OK;
  90 }
  91
  92 /**************************************************************************
  93  *          WsCreateChannel             [webservices.@]
  94  */
  95 HRESULT WINAPI WsCreateChannel( WS_CHANNEL_TYPE type, WS_CHANNEL_BINDING binding,
  96                                 const WS_CHANNEL_PROPERTY *properties, ULONG count,
  97                                 const WS_SECURITY_DESCRIPTION *desc, WS_CHANNEL **handle,
  98                                 WS_ERROR *error )
  99 {
 100     struct channel *channel;
 101     HRESULT hr;
 102
 103     TRACE( "%u %u %p %u %p %p %p\n", type, binding, properties, count, desc, handle, error );
 104     if (error) FIXME( "ignoring error parameter\n" );
 105     if (desc) FIXME( "ignoring security description\n" );
 106
 107     if (!handle) return E_INVALIDARG;
 108
 109     if (type != WS_CHANNEL_TYPE_REQUEST)
 110     {
 111         FIXME( "channel type %u not implemented\n", type );
 112         return E_NOTIMPL;
 113     }
 114     if (binding != WS_HTTP_CHANNEL_BINDING)
 115     {
 116         FIXME( "channel binding %u not implemented\n", binding );
 117         return E_NOTIMPL;
 118     }
 119
 120     if ((hr = create_channel( type, binding, properties, count, &channel )) != S_OK)
 121         return hr;
 122
 123     *handle = (WS_CHANNEL *)channel;
 124     return S_OK;
 125 }
 126
 127 /**************************************************************************
 128  *          WsFreeChannel               [webservices.@]
 129  */
 130 void WINAPI WsFreeChannel( WS_CHANNEL *handle )
 131 {
 132     struct channel *channel = (struct channel *)handle;
 133
 134     TRACE( "%p\n", handle );
 135     free_channel( channel );
 136 }
 137
 138 /**************************************************************************
 139  *          WsGetChannelProperty                [webservices.@]
 140  */
 141 HRESULT WINAPI WsGetChannelProperty( WS_CHANNEL *handle, WS_CHANNEL_PROPERTY_ID id, void *buf,
 142                                      ULONG size, WS_ERROR *error )
 143 {
 144     struct channel *channel = (struct channel *)handle;
 145
 146     TRACE( "%p %u %p %u %p\n", handle, id, buf, size, error );
 147     if (error) FIXME( "ignoring error parameter\n" );
 148
 149     return prop_get( channel->prop, channel->prop_count, id, buf, size );
 150 }
 151
 152 /**************************************************************************
 153  *          WsSetChannelProperty                [webservices.@]
 154  */
 155 HRESULT WINAPI WsSetChannelProperty( WS_CHANNEL *handle, WS_CHANNEL_PROPERTY_ID id, const void *value,
 156                                      ULONG size, WS_ERROR *error )
 157 {
 158     struct channel *channel = (struct channel *)handle;
 159
 160     TRACE( "%p %u %p %u\n", handle, id, value, size );
 161     if (error) FIXME( "ignoring error parameter\n" );
 162
 163     return prop_set( channel->prop, channel->prop_count, id, value, size );
 164 }
 165
 166 HRESULT open_channel( struct channel *channel, const WS_ENDPOINT_ADDRESS *endpoint )
 167 {
 168     channel->state = WS_CHANNEL_STATE_OPEN;
 169     return S_OK;
 170 }
 171
 172 /**************************************************************************
 173  *          WsOpenChannel               [webservices.@]
 174  */
 175 HRESULT WINAPI WsOpenChannel( WS_CHANNEL *handle, const WS_ENDPOINT_ADDRESS *endpoint,
 176                               const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error )
 177 {
 178     struct channel *channel = (struct channel *)handle;
 179
 180     TRACE( "%p %p %p %p\n", handle, endpoint, ctx, error );
 181     if (error) FIXME( "ignoring error parameter\n" );
 182     if (ctx) FIXME( "ignoring ctx parameter\n" );
 183
 184     if (!endpoint) return E_INVALIDARG;
 185     if (channel->state != WS_CHANNEL_STATE_CREATED) return WS_E_INVALID_OPERATION;
 186
 187     return open_channel( channel, endpoint );
 188 }
 189
 190 HRESULT close_channel( struct channel *channel )
 191 {
 192     channel->state = WS_CHANNEL_STATE_CLOSED;
 193     return S_OK;
 194 }
 195
 196 /**************************************************************************
 197  *          WsCloseChannel              [webservices.@]
 198  */
 199 HRESULT WINAPI WsCloseChannel( WS_CHANNEL *handle, const WS_ASYNC_CONTEXT *ctx, WS_ERROR *error )
 200 {
 201     struct channel *channel = (struct channel *)handle;
 202
 203     TRACE( "%p %p %p\n", handle, ctx, error );
 204     if (error) FIXME( "ignoring error parameter\n" );
 205     if (ctx) FIXME( "ignoring ctx parameter\n" );
 206
 207     return close_channel( channel );
 208 }