ReactOS 0.4.15-dev-7670-g69b08be
rpc_transport.c File Reference
#include "ntstatus.h"
#include "ws2tcpip.h"
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "windef.h"
#include "winbase.h"
#include "winnls.h"
#include "winerror.h"
#include "wininet.h"
#include "wine/winternl.h"
#include "winioctl.h"
#include "rpc.h"
#include "rpcndr.h"
#include "wine/debug.h"
#include "rpc_binding.h"
#include "rpc_assoc.h"
#include "rpc_message.h"
#include "rpc_server.h"
#include "epm_towers.h"
Include dependency graph for rpc_transport.c:

Go to the source code of this file.

Classes

struct  _RpcConnection_np
 
struct  _RpcServerProtseq_np
 
struct  _RpcConnection_tcp
 
struct  _RpcServerProtseq_sock
 
struct  _RpcHttpAsyncData
 
struct  authinfo
 
struct  _RpcConnection_http
 
struct  _HttpTimerThreadData
 

Macros

#define WIN32_NO_STATUS
 
#define DEFAULT_NCACN_HTTP_TIMEOUT   (60 * 1000)
 
#define HTTP_IDLE_TIME   60000
 

Typedefs

typedef struct _RpcConnection_np RpcConnection_np
 
typedef struct _RpcServerProtseq_np RpcServerProtseq_np
 
typedef struct _RpcConnection_tcp RpcConnection_tcp
 
typedef struct _RpcServerProtseq_sock RpcServerProtseq_sock
 
typedef struct _RpcHttpAsyncData RpcHttpAsyncData
 
typedef struct _RpcConnection_http RpcConnection_http
 
typedef struct _HttpTimerThreadData HttpTimerThreadData
 

Functions

 WINE_DEFAULT_DEBUG_CHANNEL (rpc)
 
static RpcConnectionrpcrt4_spawn_connection (RpcConnection *old_connection)
 
static RpcConnectionrpcrt4_conn_np_alloc (void)
 
static HANDLE get_np_event (RpcConnection_np *connection)
 
static void release_np_event (RpcConnection_np *connection, HANDLE event)
 
static RPC_STATUS rpcrt4_conn_create_pipe (RpcConnection *conn)
 
static RPC_STATUS rpcrt4_conn_open_pipe (RpcConnection *Connection, LPCSTR pname, BOOL wait)
 
static charncalrpc_pipe_name (const char *endpoint)
 
static RPC_STATUS rpcrt4_ncalrpc_open (RpcConnection *Connection)
 
static RPC_STATUS rpcrt4_protseq_ncalrpc_open_endpoint (RpcServerProtseq *protseq, const char *endpoint)
 
static charncacn_pipe_name (const char *endpoint)
 
static RPC_STATUS rpcrt4_ncacn_np_open (RpcConnection *Connection)
 
static RPC_STATUS rpcrt4_protseq_ncacn_np_open_endpoint (RpcServerProtseq *protseq, const char *endpoint)
 
static void rpcrt4_conn_np_handoff (RpcConnection_np *old_npc, RpcConnection_np *new_npc)
 
static RPC_STATUS rpcrt4_ncacn_np_handoff (RpcConnection *old_conn, RpcConnection *new_conn)
 
static RPC_STATUS is_pipe_listening (const char *pipe_name)
 
static RPC_STATUS rpcrt4_ncacn_np_is_server_listening (const char *endpoint)
 
static RPC_STATUS rpcrt4_ncalrpc_np_is_server_listening (const char *endpoint)
 
static RPC_STATUS rpcrt4_ncalrpc_handoff (RpcConnection *old_conn, RpcConnection *new_conn)
 
static int rpcrt4_conn_np_read (RpcConnection *conn, void *buffer, unsigned int count)
 
static int rpcrt4_conn_np_write (RpcConnection *conn, const void *buffer, unsigned int count)
 
static int rpcrt4_conn_np_close (RpcConnection *conn)
 
static void rpcrt4_conn_np_close_read (RpcConnection *conn)
 
static void rpcrt4_conn_np_cancel_call (RpcConnection *conn)
 
static int rpcrt4_conn_np_wait_for_incoming_data (RpcConnection *conn)
 
static size_t rpcrt4_ncacn_np_get_top_of_tower (unsigned char *tower_data, const char *networkaddr, const char *endpoint)
 
static RPC_STATUS rpcrt4_ncacn_np_parse_top_of_tower (const unsigned char *tower_data, size_t tower_size, char **networkaddr, char **endpoint)
 
static RPC_STATUS rpcrt4_conn_np_impersonate_client (RpcConnection *conn)
 
static RPC_STATUS rpcrt4_conn_np_revert_to_self (RpcConnection *conn)
 
static RpcServerProtseqrpcrt4_protseq_np_alloc (void)
 
static void rpcrt4_protseq_np_signal_state_changed (RpcServerProtseq *protseq)
 
static voidrpcrt4_protseq_np_get_wait_array (RpcServerProtseq *protseq, void *prev_array, unsigned int *count)
 
static void rpcrt4_protseq_np_free_wait_array (RpcServerProtseq *protseq, void *array)
 
static int rpcrt4_protseq_np_wait_for_new_connection (RpcServerProtseq *protseq, unsigned int count, void *wait_array)
 
static size_t rpcrt4_ncalrpc_get_top_of_tower (unsigned char *tower_data, const char *networkaddr, const char *endpoint)
 
static RPC_STATUS rpcrt4_ncalrpc_parse_top_of_tower (const unsigned char *tower_data, size_t tower_size, char **networkaddr, char **endpoint)
 
static BOOL rpcrt4_ncalrpc_is_authorized (RpcConnection *conn)
 
static RPC_STATUS rpcrt4_ncalrpc_authorize (RpcConnection *conn, BOOL first_time, unsigned char *in_buffer, unsigned int in_size, unsigned char *out_buffer, unsigned int *out_size)
 
static RPC_STATUS rpcrt4_ncalrpc_secure_packet (RpcConnection *conn, enum secure_packet_direction dir, RpcPktHdr *hdr, unsigned int hdr_size, unsigned char *stub_data, unsigned int stub_data_size, RpcAuthVerifier *auth_hdr, unsigned char *auth_value, unsigned int auth_value_size)
 
static RPC_STATUS rpcrt4_ncalrpc_inquire_auth_client (RpcConnection *conn, RPC_AUTHZ_HANDLE *privs, RPC_WSTR *server_princ_name, ULONG *authn_level, ULONG *authn_svc, ULONG *authz_svc, ULONG flags)
 
static size_t rpcrt4_ip_tcp_get_top_of_tower (unsigned char *tower_data, const char *networkaddr, unsigned char tcp_protid, const char *endpoint)
 
static RPC_STATUS rpcrt4_ip_tcp_parse_top_of_tower (const unsigned char *tower_data, size_t tower_size, char **networkaddr, unsigned char tcp_protid, char **endpoint)
 
static BOOL rpcrt4_sock_wait_init (RpcConnection_tcp *tcpc)
 
static BOOL rpcrt4_sock_wait_for_recv (RpcConnection_tcp *tcpc)
 
static BOOL rpcrt4_sock_wait_for_send (RpcConnection_tcp *tcpc)
 
static RpcConnectionrpcrt4_conn_tcp_alloc (void)
 
static RPC_STATUS rpcrt4_ncacn_ip_tcp_open (RpcConnection *Connection)
 
static RPC_STATUS rpcrt4_protseq_ncacn_ip_tcp_open_endpoint (RpcServerProtseq *protseq, const char *endpoint)
 
static RPC_STATUS rpcrt4_conn_tcp_handoff (RpcConnection *old_conn, RpcConnection *new_conn)
 
static int rpcrt4_conn_tcp_read (RpcConnection *Connection, void *buffer, unsigned int count)
 
static int rpcrt4_conn_tcp_write (RpcConnection *Connection, const void *buffer, unsigned int count)
 
static int rpcrt4_conn_tcp_close (RpcConnection *conn)
 
static void rpcrt4_conn_tcp_close_read (RpcConnection *conn)
 
static void rpcrt4_conn_tcp_cancel_call (RpcConnection *conn)
 
static RPC_STATUS rpcrt4_conn_tcp_is_server_listening (const char *endpoint)
 
static int rpcrt4_conn_tcp_wait_for_incoming_data (RpcConnection *Connection)
 
static size_t rpcrt4_ncacn_ip_tcp_get_top_of_tower (unsigned char *tower_data, const char *networkaddr, const char *endpoint)
 
static RpcServerProtseqrpcrt4_protseq_sock_alloc (void)
 
static void rpcrt4_protseq_sock_signal_state_changed (RpcServerProtseq *protseq)
 
static voidrpcrt4_protseq_sock_get_wait_array (RpcServerProtseq *protseq, void *prev_array, unsigned int *count)
 
static void rpcrt4_protseq_sock_free_wait_array (RpcServerProtseq *protseq, void *array)
 
static int rpcrt4_protseq_sock_wait_for_new_connection (RpcServerProtseq *protseq, unsigned int count, void *wait_array)
 
static RPC_STATUS rpcrt4_ncacn_ip_tcp_parse_top_of_tower (const unsigned char *tower_data, size_t tower_size, char **networkaddr, char **endpoint)
 
static ULONG RpcHttpAsyncData_AddRef (RpcHttpAsyncData *data)
 
static ULONG RpcHttpAsyncData_Release (RpcHttpAsyncData *data)
 
static void prepare_async_request (RpcHttpAsyncData *async_data)
 
static RPC_STATUS wait_async_request (RpcHttpAsyncData *async_data, BOOL call_ret, HANDLE cancel_event)
 
static RpcConnectionrpcrt4_ncacn_http_alloc (void)
 
static VOID rpcrt4_http_keep_connection_active_timer_proc (PVOID param, BOOLEAN dummy)
 
static DWORD rpcrt4_http_timer_calc_timeout (DWORD *last_sent_time)
 
static DWORD CALLBACK rpcrt4_http_timer_thread (PVOID param)
 
static VOID WINAPI rpcrt4_http_internet_callback (HINTERNET hInternet, DWORD_PTR dwContext, DWORD dwInternetStatus, LPVOID lpvStatusInformation, DWORD dwStatusInformationLength)
 
static RPC_STATUS rpcrt4_http_check_response (HINTERNET hor)
 
static RPC_STATUS rpcrt4_http_internet_connect (RpcConnection_http *httpc)
 
static int rpcrt4_http_async_read (HINTERNET req, RpcHttpAsyncData *async_data, HANDLE cancel_event, void *buffer, unsigned int count)
 
static RPC_STATUS send_echo_request (HINTERNET req, RpcHttpAsyncData *async_data, HANDLE cancel_event)
 
static RPC_STATUS insert_content_length_header (HINTERNET request, DWORD len)
 
static RPC_STATUS rpcrt4_http_prepare_in_pipe (HINTERNET in_request, RpcHttpAsyncData *async_data, HANDLE cancel_event, const UUID *connection_uuid, const UUID *in_pipe_uuid, const UUID *association_uuid, BOOL authorized)
 
static RPC_STATUS rpcrt4_http_read_http_packet (HINTERNET request, RpcHttpAsyncData *async_data, HANDLE cancel_event, RpcPktHdr *hdr, BYTE **data)
 
static RPC_STATUS rpcrt4_http_prepare_out_pipe (HINTERNET out_request, RpcHttpAsyncData *async_data, HANDLE cancel_event, const UUID *connection_uuid, const UUID *out_pipe_uuid, ULONG *flow_control_increment, BOOL authorized)
 
static UINT encode_base64 (const char *bin, unsigned int len, WCHAR *base64)
 
static char decode_char (WCHAR c)
 
static unsigned int decode_base64 (const WCHAR *base64, unsigned int len, char *buf)
 
static struct authinfoalloc_authinfo (void)
 
static void destroy_authinfo (struct authinfo *info)
 
static DWORD auth_scheme_from_header (const WCHAR *header)
 
static BOOL get_authvalue (HINTERNET request, DWORD scheme, WCHAR *buffer, DWORD buflen)
 
static RPC_STATUS do_authorization (HINTERNET request, SEC_WCHAR *servername, const RPC_HTTP_TRANSPORT_CREDENTIALS_W *creds, struct authinfo **auth_ptr)
 
static RPC_STATUS insert_authorization_header (HINTERNET request, ULONG scheme, char *data, int data_len)
 
static void drain_content (HINTERNET request, RpcHttpAsyncData *async_data, HANDLE cancel_event)
 
static RPC_STATUS authorize_request (RpcConnection_http *httpc, HINTERNET request)
 
static BOOL has_credentials (RpcConnection_http *httpc)
 
static BOOL is_secure (RpcConnection_http *httpc)
 
static RPC_STATUS set_auth_cookie (RpcConnection_http *httpc, const WCHAR *value)
 
static RPC_STATUS rpcrt4_ncacn_http_open (RpcConnection *Connection)
 
static RPC_STATUS rpcrt4_ncacn_http_handoff (RpcConnection *old_conn, RpcConnection *new_conn)
 
static int rpcrt4_ncacn_http_read (RpcConnection *Connection, void *buffer, unsigned int count)
 
static RPC_STATUS rpcrt4_ncacn_http_receive_fragment (RpcConnection *Connection, RpcPktHdr **Header, void **Payload)
 
static int rpcrt4_ncacn_http_write (RpcConnection *Connection, const void *buffer, unsigned int count)
 
static int rpcrt4_ncacn_http_close (RpcConnection *Connection)
 
static void rpcrt4_ncacn_http_close_read (RpcConnection *conn)
 
static void rpcrt4_ncacn_http_cancel_call (RpcConnection *Connection)
 
static RPC_STATUS rpcrt4_ncacn_http_is_server_listening (const char *endpoint)
 
static int rpcrt4_ncacn_http_wait_for_incoming_data (RpcConnection *Connection)
 
static size_t rpcrt4_ncacn_http_get_top_of_tower (unsigned char *tower_data, const char *networkaddr, const char *endpoint)
 
static RPC_STATUS rpcrt4_ncacn_http_parse_top_of_tower (const unsigned char *tower_data, size_t tower_size, char **networkaddr, char **endpoint)
 
const struct protseq_opsrpcrt4_get_protseq_ops (const char *protseq)
 
static const struct connection_opsrpcrt4_get_conn_protseq_ops (const char *protseq)
 
RPC_STATUS RPCRT4_OpenClientConnection (RpcConnection *Connection)
 
RPC_STATUS RPCRT4_CloseConnection (RpcConnection *Connection)
 
RPC_STATUS RPCRT4_CreateConnection (RpcConnection **Connection, BOOL server, LPCSTR Protseq, LPCSTR NetworkAddr, LPCSTR Endpoint, LPCWSTR NetworkOptions, RpcAuthInfo *AuthInfo, RpcQualityOfService *QOS, LPCWSTR CookieAuth)
 
void rpcrt4_conn_release_and_wait (RpcConnection *connection)
 
RpcConnectionRPCRT4_GrabConnection (RpcConnection *connection)
 
void RPCRT4_ReleaseConnection (RpcConnection *connection)
 
RPC_STATUS RPCRT4_IsServerListening (const char *protseq, const char *endpoint)
 
RPC_STATUS RpcTransport_GetTopOfTower (unsigned char *tower_data, size_t *tower_size, const char *protseq, const char *networkaddr, const char *endpoint)
 
RPC_STATUS RpcTransport_ParseTopOfTower (const unsigned char *tower_data, size_t tower_size, char **protseq, char **networkaddr, char **endpoint)
 
RPC_STATUS WINAPI RpcNetworkIsProtseqValidW (RPC_WSTR protseq)
 
RPC_STATUS WINAPI RpcNetworkIsProtseqValidA (RPC_CSTR protseq)
 
RPC_STATUS WINAPI RpcProtseqVectorFreeA (RPC_PROTSEQ_VECTORA **protseqs)
 
RPC_STATUS WINAPI RpcProtseqVectorFreeW (RPC_PROTSEQ_VECTORW **protseqs)
 
RPC_STATUS WINAPI RpcNetworkInqProtseqsW (RPC_PROTSEQ_VECTORW **protseqs)
 
RPC_STATUS WINAPI RpcNetworkInqProtseqsA (RPC_PROTSEQ_VECTORA **protseqs)
 

Variables

static const WCHAR basicW [] = {'B','a','s','i','c',0}
 
static const WCHAR ntlmW [] = {'N','T','L','M',0}
 
static const WCHAR passportW [] = {'P','a','s','s','p','o','r','t',0}
 
static const WCHAR digestW [] = {'D','i','g','e','s','t',0}
 
static const WCHAR negotiateW [] = {'N','e','g','o','t','i','a','t','e',0}
 
struct {
   const WCHAR *   str
 
   unsigned int   len
 
   DWORD   scheme
 
auth_schemes []
 
static const struct connection_ops conn_protseq_list []
 
static const struct protseq_ops protseq_list []
 

Macro Definition Documentation

◆ DEFAULT_NCACN_HTTP_TIMEOUT

#define DEFAULT_NCACN_HTTP_TIMEOUT   (60 * 1000)

Definition at line 57 of file rpc_transport.c.

◆ HTTP_IDLE_TIME

#define HTTP_IDLE_TIME   60000

Definition at line 1975 of file rpc_transport.c.

◆ WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 27 of file rpc_transport.c.

Typedef Documentation

◆ HttpTimerThreadData

◆ RpcConnection_http

◆ RpcConnection_np

◆ RpcConnection_tcp

◆ RpcHttpAsyncData

◆ RpcServerProtseq_np

◆ RpcServerProtseq_sock

Function Documentation

◆ alloc_authinfo()

static struct authinfo * alloc_authinfo ( void  )
static

Definition at line 2685 of file rpc_transport.c.

2686{
2687 struct authinfo *ret;
2688
2689 if (!(ret = HeapAlloc(GetProcessHeap(), 0, sizeof(*ret) ))) return NULL;
2690
2691 SecInvalidateHandle(&ret->cred);
2692 SecInvalidateHandle(&ret->ctx);
2693 memset(&ret->exp, 0, sizeof(ret->exp));
2694 ret->scheme = 0;
2695 ret->attr = 0;
2696 ret->max_token = 0;
2697 ret->data = NULL;
2698 ret->data_len = 0;
2699 ret->finished = FALSE;
2700 return ret;
2701}
#define NULL
Definition: types.h:112
#define FALSE
Definition: types.h:117
#define GetProcessHeap()
Definition: compat.h:736
#define HeapAlloc
Definition: compat.h:733
#define SecInvalidateHandle(x)
Definition: sspi.h:58
#define memset(x, y, z)
Definition: compat.h:39
int ret

Referenced by do_authorization().

◆ auth_scheme_from_header()

static DWORD auth_scheme_from_header ( const WCHAR header)
static

Definition at line 2737 of file rpc_transport.c.

2738{
2739 unsigned int i;
2740 for (i = 0; i < ARRAY_SIZE(auth_schemes); i++)
2741 {
2743 (header[auth_schemes[i].len] == ' ' || !header[auth_schemes[i].len])) return auth_schemes[i].scheme;
2744 }
2745 return 0;
2746}
#define ARRAY_SIZE(A)
Definition: main.h:33
GLenum GLsizei len
Definition: glext.h:6722
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
static const struct @542 auth_schemes[]
const WCHAR * str
_Check_return_ _CRTIMP int __cdecl _wcsnicmp(_In_reads_or_z_(_MaxCount) const wchar_t *_Str1, _In_reads_or_z_(_MaxCount) const wchar_t *_Str2, _In_ size_t _MaxCount)

Referenced by do_authorization(), and get_authvalue().

◆ authorize_request()

static RPC_STATUS authorize_request ( RpcConnection_http httpc,
HINTERNET  request 
)
static

Definition at line 2969 of file rpc_transport.c.

2970{
2971 static const WCHAR authW[] = {'A','u','t','h','o','r','i','z','a','t','i','o','n',':','\r','\n',0};
2972 struct authinfo *info = NULL;
2974 BOOL ret;
2975
2976 for (;;)
2977 {
2979 if (status != RPC_S_OK) break;
2980
2981 status = insert_authorization_header(request, info->scheme, info->data, info->data_len);
2982 if (status != RPC_S_OK) break;
2983
2987 if (status != RPC_S_OK || info->finished) break;
2988
2990 if (status != RPC_S_OK && status != ERROR_ACCESS_DENIED) break;
2992 }
2993
2994 if (info->scheme != RPC_C_HTTP_AUTHN_SCHEME_BASIC)
2996
2998 return status;
2999}
#define ERROR_ACCESS_DENIED
Definition: compat.h:97
BOOL WINAPI HttpAddRequestHeadersW(HINTERNET hHttpRequest, LPCWSTR lpszHeader, DWORD dwHeaderLength, DWORD dwModifier)
Definition: http.c:1297
BOOL WINAPI HttpSendRequestW(HINTERNET hHttpRequest, LPCWSTR lpszHeaders, DWORD dwHeaderLength, LPVOID lpOptional, DWORD dwOptionalLength)
Definition: http.c:5595
unsigned int BOOL
Definition: ntddk_ex.h:94
static void drain_content(HINTERNET request, RpcHttpAsyncData *async_data, HANDLE cancel_event)
static RPC_STATUS wait_async_request(RpcHttpAsyncData *async_data, BOOL call_ret, HANDLE cancel_event)
static RPC_STATUS do_authorization(HINTERNET request, SEC_WCHAR *servername, const RPC_HTTP_TRANSPORT_CREDENTIALS_W *creds, struct authinfo **auth_ptr)
static RPC_STATUS insert_authorization_header(HINTERNET request, ULONG scheme, char *data, int data_len)
static void prepare_async_request(RpcHttpAsyncData *async_data)
static RPC_STATUS rpcrt4_http_check_response(HINTERNET hor)
static void destroy_authinfo(struct authinfo *info)
#define RPC_C_HTTP_AUTHN_SCHEME_BASIC
Definition: rpcdce.h:205
#define RPC_S_OK
Definition: rpcnterr.h:22
long RPC_STATUS
Definition: rpc.h:52
union _RPC_SECURITY_QOS_V2_W::@3218 u
RPC_HTTP_TRANSPORT_CREDENTIALS_W * HttpCredentials
Definition: rpcdce.h:279
RpcConnection common
RpcHttpAsyncData * async_data
RpcQualityOfService * QOS
Definition: rpc_binding.h:81
RPC_SECURITY_QOS_V2_W * qos
Definition: rpc_binding.h:57
Definition: tftpd.h:86
Definition: ps.c:97
#define HTTP_ADDREQ_FLAG_REPLACE
Definition: wininet.h:1711
#define HTTP_ADDREQ_FLAG_ADD
Definition: wininet.h:1707
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by rpcrt4_ncacn_http_open().

◆ decode_base64()

static unsigned int decode_base64 ( const WCHAR base64,
unsigned int  len,
char buf 
)
static

Definition at line 2623 of file rpc_transport.c.

2624{
2625 unsigned int i = 0;
2626 char c0, c1, c2, c3;
2627 const WCHAR *p = base64;
2628
2629 while (len > 4)
2630 {
2631 if ((c0 = decode_char( p[0] )) > 63) return 0;
2632 if ((c1 = decode_char( p[1] )) > 63) return 0;
2633 if ((c2 = decode_char( p[2] )) > 63) return 0;
2634 if ((c3 = decode_char( p[3] )) > 63) return 0;
2635
2636 if (buf)
2637 {
2638 buf[i + 0] = (c0 << 2) | (c1 >> 4);
2639 buf[i + 1] = (c1 << 4) | (c2 >> 2);
2640 buf[i + 2] = (c2 << 6) | c3;
2641 }
2642 len -= 4;
2643 i += 3;
2644 p += 4;
2645 }
2646 if (p[2] == '=')
2647 {
2648 if ((c0 = decode_char( p[0] )) > 63) return 0;
2649 if ((c1 = decode_char( p[1] )) > 63) return 0;
2650
2651 if (buf) buf[i] = (c0 << 2) | (c1 >> 4);
2652 i++;
2653 }
2654 else if (p[3] == '=')
2655 {
2656 if ((c0 = decode_char( p[0] )) > 63) return 0;
2657 if ((c1 = decode_char( p[1] )) > 63) return 0;
2658 if ((c2 = decode_char( p[2] )) > 63) return 0;
2659
2660 if (buf)
2661 {
2662 buf[i + 0] = (c0 << 2) | (c1 >> 4);
2663 buf[i + 1] = (c1 << 4) | (c2 >> 2);
2664 }
2665 i += 2;
2666 }
2667 else
2668 {
2669 if ((c0 = decode_char( p[0] )) > 63) return 0;
2670 if ((c1 = decode_char( p[1] )) > 63) return 0;
2671 if ((c2 = decode_char( p[2] )) > 63) return 0;
2672 if ((c3 = decode_char( p[3] )) > 63) return 0;
2673
2674 if (buf)
2675 {
2676 buf[i + 0] = (c0 << 2) | (c1 >> 4);
2677 buf[i + 1] = (c1 << 4) | (c2 >> 2);
2678 buf[i + 2] = (c2 << 6) | c3;
2679 }
2680 i += 3;
2681 }
2682 return i;
2683}
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLfloat GLfloat p
Definition: glext.h:8902
static char decode_char(WCHAR c)

Referenced by do_authorization().

◆ decode_char()

static char decode_char ( WCHAR  c)
inlinestatic

Definition at line 2613 of file rpc_transport.c.

2614{
2615 if (c >= 'A' && c <= 'Z') return c - 'A';
2616 if (c >= 'a' && c <= 'z') return c - 'a' + 26;
2617 if (c >= '0' && c <= '9') return c - '0' + 52;
2618 if (c == '+') return 62;
2619 if (c == '/') return 63;
2620 return 64;
2621}
const GLubyte * c
Definition: glext.h:8905

Referenced by decode_base64().

◆ destroy_authinfo()

static void destroy_authinfo ( struct authinfo info)
static

Definition at line 2703 of file rpc_transport.c.

2704{
2705 if (!info) return;
2706
2707 if (SecIsValidHandle(&info->ctx))
2709 if (SecIsValidHandle(&info->cred))
2711
2712 HeapFree(GetProcessHeap(), 0, info->data);
2714}
#define HeapFree(x, y, z)
Definition: compat.h:735
#define SecIsValidHandle(x)
Definition: sspi.h:63
SECURITY_STATUS WINAPI DeleteSecurityContext(PCtxtHandle phContext)
Definition: wrapper.c:450
SECURITY_STATUS WINAPI FreeCredentialsHandle(PCredHandle phCredential)
Definition: wrapper.c:151

Referenced by authorize_request(), do_authorization(), and request_destroy().

◆ do_authorization()

static RPC_STATUS do_authorization ( HINTERNET  request,
SEC_WCHAR servername,
const RPC_HTTP_TRANSPORT_CREDENTIALS_W creds,
struct authinfo **  auth_ptr 
)
static

Definition at line 2760 of file rpc_transport.c.

2762{
2763 struct authinfo *info = *auth_ptr;
2766
2767 if ((!info && !(info = alloc_authinfo()))) return RPC_S_SERVER_UNAVAILABLE;
2768
2769 switch (creds->AuthnSchemes[0])
2770 {
2772 {
2773 int userlen = WideCharToMultiByte(CP_UTF8, 0, id->User, id->UserLength, NULL, 0, NULL, NULL);
2774 int passlen = WideCharToMultiByte(CP_UTF8, 0, id->Password, id->PasswordLength, NULL, 0, NULL, NULL);
2775
2776 info->data_len = userlen + passlen + 1;
2777 if (!(info->data = HeapAlloc(GetProcessHeap(), 0, info->data_len)))
2778 {
2780 break;
2781 }
2782 WideCharToMultiByte(CP_UTF8, 0, id->User, id->UserLength, info->data, userlen, NULL, NULL);
2783 info->data[userlen] = ':';
2784 WideCharToMultiByte(CP_UTF8, 0, id->Password, id->PasswordLength, info->data + userlen + 1, passlen, NULL, NULL);
2785
2787 info->finished = TRUE;
2788 status = RPC_S_OK;
2789 break;
2790 }
2793 {
2794
2795 static SEC_WCHAR ntlmW[] = {'N','T','L','M',0}, negotiateW[] = {'N','e','g','o','t','i','a','t','e',0};
2797 SecBufferDesc out_desc, in_desc;
2798 SecBuffer out, in;
2801 int scheme_len;
2802 const WCHAR *p;
2803 WCHAR auth_value[2048];
2804 DWORD size = sizeof(auth_value);
2805 BOOL first = FALSE;
2806
2808 else scheme = negotiateW;
2809 scheme_len = lstrlenW( scheme );
2810
2811 if (!*auth_ptr)
2812 {
2813 TimeStamp exp;
2814 SecPkgInfoW *pkg_info;
2815
2817 if (ret != SEC_E_OK) break;
2818
2819 ret = QuerySecurityPackageInfoW(scheme, &pkg_info);
2820 if (ret != SEC_E_OK) break;
2821
2822 info->max_token = pkg_info->cbMaxToken;
2823 FreeContextBuffer(pkg_info);
2824 first = TRUE;
2825 }
2826 else
2827 {
2828 if (info->finished || !get_authvalue(request, creds->AuthnSchemes[0], auth_value, size)) break;
2829 if (auth_scheme_from_header(auth_value) != info->scheme)
2830 {
2831 ERR("authentication scheme changed\n");
2832 break;
2833 }
2834 }
2835 in.BufferType = SECBUFFER_TOKEN;
2836 in.cbBuffer = 0;
2837 in.pvBuffer = NULL;
2838
2839 in_desc.ulVersion = 0;
2840 in_desc.cBuffers = 1;
2841 in_desc.pBuffers = &in;
2842
2843 p = auth_value + scheme_len;
2844 if (!first && *p == ' ')
2845 {
2846 int len = lstrlenW(++p);
2847 in.cbBuffer = decode_base64(p, len, NULL);
2848 if (!(in.pvBuffer = HeapAlloc(GetProcessHeap(), 0, in.cbBuffer))) break;
2849 decode_base64(p, len, in.pvBuffer);
2850 }
2851 out.BufferType = SECBUFFER_TOKEN;
2852 out.cbBuffer = info->max_token;
2853 if (!(out.pvBuffer = HeapAlloc(GetProcessHeap(), 0, out.cbBuffer)))
2854 {
2855 HeapFree(GetProcessHeap(), 0, in.pvBuffer);
2856 break;
2857 }
2858 out_desc.ulVersion = 0;
2859 out_desc.cBuffers = 1;
2860 out_desc.pBuffers = &out;
2861
2862 ret = InitializeSecurityContextW(first ? &info->cred : NULL, first ? NULL : &info->ctx,
2863 first ? servername : NULL, flags, 0, SECURITY_NETWORK_DREP,
2864 in.pvBuffer ? &in_desc : NULL, 0, &info->ctx, &out_desc,
2865 &info->attr, &info->exp);
2866 HeapFree(GetProcessHeap(), 0, in.pvBuffer);
2867 if (ret == SEC_E_OK)
2868 {
2869 HeapFree(GetProcessHeap(), 0, info->data);
2870 info->data = out.pvBuffer;
2871 info->data_len = out.cbBuffer;
2872 info->finished = TRUE;
2873 TRACE("sending last auth packet\n");
2874 status = RPC_S_OK;
2875 }
2876 else if (ret == SEC_I_CONTINUE_NEEDED)
2877 {
2878 HeapFree(GetProcessHeap(), 0, info->data);
2879 info->data = out.pvBuffer;
2880 info->data_len = out.cbBuffer;
2881 TRACE("sending next auth packet\n");
2882 status = RPC_S_OK;
2883 }
2884 else
2885 {
2886 ERR("InitializeSecurityContextW failed with error 0x%08x\n", ret);
2887 HeapFree(GetProcessHeap(), 0, out.pvBuffer);
2888 break;
2889 }
2890 info->scheme = creds->AuthnSchemes[0];
2891 break;
2892 }
2893 default:
2894 FIXME("scheme %u not supported\n", creds->AuthnSchemes[0]);
2895 break;
2896 }
2897
2898 if (status != RPC_S_OK)
2899 {
2901 *auth_ptr = NULL;
2902 return status;
2903 }
2904 *auth_ptr = info;
2905 return RPC_S_OK;
2906}
#define FIXME(fmt,...)
Definition: debug.h:111
#define ERR(fmt,...)
Definition: debug.h:110
#define TRUE
Definition: types.h:120
#define WideCharToMultiByte
Definition: compat.h:111
#define lstrlenW
Definition: compat.h:750
unsigned long DWORD
Definition: ntddk_ex.h:95
GLsizeiptr size
Definition: glext.h:5919
GLuint in
Definition: glext.h:9616
GLbitfield flags
Definition: glext.h:7161
const GLint * first
Definition: glext.h:5794
GLuint id
Definition: glext.h:5910
DWORD exp
Definition: msg.c:16058
LONG SECURITY_STATUS
Definition: sspi.h:34
#define SECPKG_CRED_OUTBOUND
Definition: sspi.h:291
#define SECBUFFER_TOKEN
Definition: sspi.h:161
#define SECURITY_NETWORK_DREP
Definition: sspi.h:474
#define ISC_REQ_DELEGATE
Definition: sspi.h:362
#define ISC_REQ_MUTUAL_AUTH
Definition: sspi.h:363
WCHAR SEC_WCHAR
Definition: sspi.h:29
#define ISC_REQ_CONNECTION
Definition: sspi.h:373
#define ISC_REQ_USE_DCE_STYLE
Definition: sspi.h:371
static FILE * out
Definition: regtests2xml.c:44
static DWORD auth_scheme_from_header(const WCHAR *header)
static unsigned int decode_base64(const WCHAR *base64, unsigned int len, char *buf)
static const WCHAR negotiateW[]
static struct authinfo * alloc_authinfo(void)
static BOOL get_authvalue(HINTERNET request, DWORD scheme, WCHAR *buffer, DWORD buflen)
static const WCHAR ntlmW[]
DWORD scheme
#define RPC_C_HTTP_AUTHN_SCHEME_NEGOTIATE
Definition: rpcdce.h:209
#define RPC_C_HTTP_AUTHN_SCHEME_NTLM
Definition: rpcdce.h:206
#define RPC_S_OUT_OF_MEMORY
Definition: rpcnterr.h:24
#define CP_UTF8
Definition: nls.h:20
#define TRACE(s)
Definition: solgame.cpp:4
SECURITY_STATUS WINAPI FreeContextBuffer(PVOID pv)
Definition: sspi.c:699
SEC_WINNT_AUTH_IDENTITY_W * TransportCredentials
Definition: rpcdce.h:245
ULONG cBuffers
Definition: sspi.h:182
ULONG ulVersion
Definition: sspi.h:181
ULONG cbMaxToken
Definition: sspi.h:117
uint32_t ULONG
Definition: typedefs.h:59
#define SEC_E_OK
Definition: winerror.h:2356
#define SEC_I_CONTINUE_NEEDED
Definition: winerror.h:2927
#define RPC_S_SERVER_UNAVAILABLE
Definition: winerror.h:1033
SECURITY_STATUS WINAPI AcquireCredentialsHandleW(SEC_WCHAR *pszPrincipal, SEC_WCHAR *pszPackage, ULONG fCredentialsUse, PLUID pvLogonID, PVOID pAuthData, SEC_GET_KEY_FN pGetKeyFn, PVOID pvGetKeyArgument, PCredHandle phCredential, PTimeStamp ptsExpiry)
Definition: wrapper.c:105
SECURITY_STATUS WINAPI InitializeSecurityContextW(PCredHandle phCredential, PCtxtHandle phContext, SEC_WCHAR *pszTargetName, ULONG fContextReq, ULONG Reserved1, ULONG TargetDataRep, PSecBufferDesc pInput, ULONG Reserved2, PCtxtHandle phNewContext, PSecBufferDesc pOutput, ULONG *pfContextAttr, PTimeStamp ptsExpiry)
Definition: wrapper.c:301
SECURITY_STATUS WINAPI QuerySecurityPackageInfoW(SEC_WCHAR *pszPackageName, PSecPkgInfoW *ppPackageInfo)
Definition: wrapper.c:750

Referenced by authorize_request().

◆ drain_content()

static void drain_content ( HINTERNET  request,
RpcHttpAsyncData async_data,
HANDLE  cancel_event 
)
static

Definition at line 2954 of file rpc_transport.c.

2955{
2956 DWORD count, len = 0, size = sizeof(len);
2957 char buf[2048];
2958
2960 if (!len) return;
2961 for (;;)
2962 {
2963 count = min(sizeof(buf), len);
2964 if (rpcrt4_http_async_read(request, async_data, cancel_event, buf, count) <= 0) return;
2965 len -= count;
2966 }
2967}
BOOL WINAPI HttpQueryInfoW(HINTERNET hHttpRequest, DWORD dwInfoLevel, LPVOID lpBuffer, LPDWORD lpdwBufferLength, LPDWORD lpdwIndex)
Definition: http.c:3870
GLuint GLuint GLsizei count
Definition: gl.h:1545
#define min(a, b)
Definition: monoChain.cc:55
unsigned int len
static int rpcrt4_http_async_read(HINTERNET req, RpcHttpAsyncData *async_data, HANDLE cancel_event, void *buffer, unsigned int count)
#define HTTP_QUERY_FLAG_NUMBER
Definition: wininet.h:1606
#define HTTP_QUERY_CONTENT_LENGTH
Definition: wininet.h:1528

Referenced by authorize_request(), and rpcrt4_ncacn_http_open().

◆ encode_base64()

static UINT encode_base64 ( const char bin,
unsigned int  len,
WCHAR base64 
)
static

Definition at line 2573 of file rpc_transport.c.

2574{
2575 static const char enc[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
2576 UINT i = 0, x;
2577
2578 while (len > 0)
2579 {
2580 /* first 6 bits, all from bin[0] */
2581 base64[i++] = enc[(bin[0] & 0xfc) >> 2];
2582 x = (bin[0] & 3) << 4;
2583
2584 /* next 6 bits, 2 from bin[0] and 4 from bin[1] */
2585 if (len == 1)
2586 {
2587 base64[i++] = enc[x];
2588 base64[i++] = '=';
2589 base64[i++] = '=';
2590 break;
2591 }
2592 base64[i++] = enc[x | ((bin[1] & 0xf0) >> 4)];
2593 x = (bin[1] & 0x0f) << 2;
2594
2595 /* next 6 bits 4 from bin[1] and 2 from bin[2] */
2596 if (len == 2)
2597 {
2598 base64[i++] = enc[x];
2599 base64[i++] = '=';
2600 break;
2601 }
2602 base64[i++] = enc[x | ((bin[2] & 0xc0) >> 6)];
2603
2604 /* last 6 bits, all from bin [2] */
2605 base64[i++] = enc[bin[2] & 0x3f];
2606 bin += 3;
2607 len -= 3;
2608 }
2609 base64[i] = 0;
2610 return i;
2611}
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
static struct _PeImage bin
unsigned int UINT
Definition: ndis.h:50

Referenced by insert_authorization_header().

◆ get_authvalue()

static BOOL get_authvalue ( HINTERNET  request,
DWORD  scheme,
WCHAR buffer,
DWORD  buflen 
)
static

Definition at line 2748 of file rpc_transport.c.

2749{
2750 DWORD len, index = 0;
2751 for (;;)
2752 {
2753 len = buflen;
2755 if (auth_scheme_from_header(buffer) == scheme) break;
2756 }
2757 return TRUE;
2758}
GLuint buffer
Definition: glext.h:5915
GLuint index
Definition: glext.h:6031
#define HTTP_QUERY_WWW_AUTHENTICATE
Definition: wininet.h:1563

Referenced by do_authorization().

◆ get_np_event()

static HANDLE get_np_event ( RpcConnection_np connection)
static

Definition at line 97 of file rpc_transport.c.

98{
100 return event ? event : CreateEventW(NULL, TRUE, FALSE, NULL);
101}
#define InterlockedExchangePointer(Target, Value)
Definition: dshow.h:45
struct _cl_event * event
Definition: glext.h:7739
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:651

Referenced by rpcrt4_conn_np_read(), rpcrt4_conn_np_write(), and rpcrt4_protseq_np_get_wait_array().

◆ has_credentials()

static BOOL has_credentials ( RpcConnection_http httpc)
static

Definition at line 3001 of file rpc_transport.c.

3002{
3005
3007 return FALSE;
3008
3009 creds = httpc->common.QOS->qos->u.HttpCredentials;
3011 return FALSE;
3012
3013 id = creds->TransportCredentials;
3014 if (!id || !id->User || !id->Password) return FALSE;
3015
3016 return TRUE;
3017}
#define RPC_C_HTTP_AUTHN_TARGET_SERVER
Definition: rpcdce.h:202
#define RPC_C_AUTHN_INFO_TYPE_HTTP
Definition: rpcdce.h:195
ULONG AdditionalSecurityInfoType
Definition: rpcdce.h:276

Referenced by rpcrt4_ncacn_http_open().

◆ insert_authorization_header()

static RPC_STATUS insert_authorization_header ( HINTERNET  request,
ULONG  scheme,
char data,
int  data_len 
)
static

Definition at line 2908 of file rpc_transport.c.

2909{
2910 static const WCHAR authW[] = {'A','u','t','h','o','r','i','z','a','t','i','o','n',':',' '};
2911 static const WCHAR basicW[] = {'B','a','s','i','c',' '};
2912 static const WCHAR negotiateW[] = {'N','e','g','o','t','i','a','t','e',' '};
2913 static const WCHAR ntlmW[] = {'N','T','L','M',' '};
2914 int scheme_len, auth_len = ARRAY_SIZE(authW), len = ((data_len + 2) * 4) / 3;
2915 const WCHAR *scheme_str;
2916 WCHAR *header, *ptr;
2918
2919 switch (scheme)
2920 {
2922 scheme_str = basicW;
2923 scheme_len = ARRAY_SIZE(basicW);
2924 break;
2926 scheme_str = negotiateW;
2927 scheme_len = ARRAY_SIZE(negotiateW);
2928 break;
2930 scheme_str = ntlmW;
2931 scheme_len = ARRAY_SIZE(ntlmW);
2932 break;
2933 default:
2934 ERR("unknown scheme %u\n", scheme);
2936 }
2937 if ((header = HeapAlloc(GetProcessHeap(), 0, (auth_len + scheme_len + len + 2) * sizeof(WCHAR))))
2938 {
2939 memcpy(header, authW, auth_len * sizeof(WCHAR));
2940 ptr = header + auth_len;
2941 memcpy(ptr, scheme_str, scheme_len * sizeof(WCHAR));
2942 ptr += scheme_len;
2943 len = encode_base64(data, data_len, ptr);
2944 ptr[len++] = '\r';
2945 ptr[len++] = '\n';
2946 ptr[len] = 0;
2948 status = RPC_S_OK;
2950 }
2951 return status;
2952}
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
static PVOID ptr
Definition: dispmode.c:27
static const WCHAR basicW[]
static UINT encode_base64(const char *bin, unsigned int len, WCHAR *base64)

Referenced by authorize_request().

◆ insert_content_length_header()

static RPC_STATUS insert_content_length_header ( HINTERNET  request,
DWORD  len 
)
static

Definition at line 2397 of file rpc_transport.c.

2398{
2399 static const WCHAR fmtW[] =
2400 {'C','o','n','t','e','n','t','-','L','e','n','g','t','h',':',' ','%','u','\r','\n',0};
2401 WCHAR header[ARRAY_SIZE(fmtW) + 10];
2402
2403 swprintf(header, fmtW, len);
2406}
#define swprintf
Definition: precomp.h:40

Referenced by rpcrt4_http_prepare_in_pipe(), and rpcrt4_http_prepare_out_pipe().

◆ is_pipe_listening()

static RPC_STATUS is_pipe_listening ( const char pipe_name)
static

Definition at line 637 of file rpc_transport.c.

638{
639 return WaitNamedPipeA(pipe_name, 1) ? RPC_S_OK : RPC_S_NOT_LISTENING;
640}
BOOL WINAPI WaitNamedPipeA(LPCSTR lpNamedPipeName, DWORD nTimeOut)
Definition: npipe.c:433
#define RPC_S_NOT_LISTENING
Definition: winerror.h:1026

Referenced by rpcrt4_ncacn_np_is_server_listening(), and rpcrt4_ncalrpc_np_is_server_listening().

◆ is_secure()

static BOOL is_secure ( RpcConnection_http httpc)
static

Definition at line 3019 of file rpc_transport.c.

3020{
3021 return httpc->common.QOS &&
3024}
#define RPC_C_HTTP_FLAG_USE_SSL
Definition: rpcdce.h:198

Referenced by open_connection(), rpcrt4_ncacn_http_open(), and set_auth_cookie().

◆ ncacn_pipe_name()

static char * ncacn_pipe_name ( const char endpoint)
static

Definition at line 503 of file rpc_transport.c.

505{
506#ifdef __REACTOS__
507 static const char prefix[] = "\\\\";
508 static const char local[] = ".";
509 char ComputerName[MAX_COMPUTERNAME_LENGTH + 1];
510 DWORD bufLen = ARRAY_SIZE(ComputerName);
511#else
512 static const char prefix[] = "\\\\.";
513#endif
514 char *pipe_name;
515
516#ifdef __REACTOS__
517 if (server != NULL && *server != 0)
518 {
519 /* Trim any leading UNC server prefix. */
520 if (server[0] == '\\' && server[1] == '\\')
521 server += 2;
522
523 /* If the server represents the local computer, use instead
524 * the local prefix to avoid a round in UNC name resolution. */
525 if (GetComputerNameA(ComputerName, &bufLen) &&
526 (stricmp(ComputerName, server) == 0))
527 {
528 server = local;
529 }
530 }
531 else
532 {
533 server = local;
534 }
535#endif
536
537 /* protseq=ncacn_np: named pipes */
538#ifdef __REACTOS__
539 pipe_name = I_RpcAllocate(sizeof(prefix) + strlen(server) + strlen(endpoint));
540 strcpy(pipe_name, prefix);
541 strcat(pipe_name, server);
542 strcat(pipe_name, endpoint);
543#else
544 pipe_name = I_RpcAllocate(sizeof(prefix) + strlen(endpoint));
545 strcat(strcpy(pipe_name, prefix), endpoint);
546#endif
547 return pipe_name;
548}
char * strcat(char *DstString, const char *SrcString)
Definition: utclib.c:568
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
#define stricmp(_String1, _String2)
Definition: compat.h:24
#define local
Definition: zutil.h:30
void *WINAPI I_RpcAllocate(unsigned int Size)
Definition: rpcrt4_main.c:716
BOOL WINAPI SHIM_OBJ_NAME() GetComputerNameA(LPSTR lpBuffer, LPDWORD lpnSize)
Definition: shimtest.c:21
Definition: nis.h:10
static rfbScreenInfoPtr server
Definition: vnc.c:74
#define MAX_COMPUTERNAME_LENGTH
Definition: winbase.h:243

Referenced by rpcrt4_ncacn_np_is_server_listening(), rpcrt4_ncacn_np_open(), and rpcrt4_protseq_ncacn_np_open_endpoint().

◆ ncalrpc_pipe_name()

static char * ncalrpc_pipe_name ( const char endpoint)
static

Definition at line 439 of file rpc_transport.c.

440{
441 static const char prefix[] = "\\\\.\\pipe\\lrpc\\";
442 char *pipe_name;
443
444 /* protseq=ncalrpc: supposed to use NT LPC ports,
445 * but we'll implement it with named pipes for now */
446 pipe_name = I_RpcAllocate(sizeof(prefix) + strlen(endpoint));
447 strcat(strcpy(pipe_name, prefix), endpoint);
448 return pipe_name;
449}

Referenced by rpcrt4_ncalrpc_np_is_server_listening(), rpcrt4_ncalrpc_open(), and rpcrt4_protseq_ncalrpc_open_endpoint().

◆ prepare_async_request()

static void prepare_async_request ( RpcHttpAsyncData async_data)
static

Definition at line 2009 of file rpc_transport.c.

2010{
2011 ResetEvent(async_data->completion_event);
2012 RpcHttpAsyncData_AddRef(async_data);
2013}
static ULONG RpcHttpAsyncData_AddRef(RpcHttpAsyncData *data)
BOOL WINAPI DECLSPEC_HOTPATCH ResetEvent(IN HANDLE hEvent)
Definition: synch.c:714

Referenced by authorize_request(), rpcrt4_http_async_read(), rpcrt4_http_prepare_in_pipe(), rpcrt4_http_prepare_out_pipe(), rpcrt4_ncacn_http_wait_for_incoming_data(), and send_echo_request().

◆ release_np_event()

static void release_np_event ( RpcConnection_np connection,
HANDLE  event 
)
static

Definition at line 103 of file rpc_transport.c.

104{
105 event = InterlockedExchangePointer(&connection->event_cache, event);
106 if (event)
108}
#define CloseHandle
Definition: compat.h:739

Referenced by rpcrt4_conn_np_read(), rpcrt4_conn_np_write(), and rpcrt4_protseq_np_wait_for_new_connection().

◆ RpcHttpAsyncData_AddRef()

static ULONG RpcHttpAsyncData_AddRef ( RpcHttpAsyncData data)
static

Definition at line 1989 of file rpc_transport.c.

1990{
1991 return InterlockedIncrement(&data->refs);
1992}
#define InterlockedIncrement
Definition: armddk.h:53

Referenced by prepare_async_request().

◆ RpcHttpAsyncData_Release()

static ULONG RpcHttpAsyncData_Release ( RpcHttpAsyncData data)
static

Definition at line 1994 of file rpc_transport.c.

1995{
1996 ULONG refs = InterlockedDecrement(&data->refs);
1997 if (!refs)
1998 {
1999 TRACE("destroying async data %p\n", data);
2000 CloseHandle(data->completion_event);
2001 HeapFree(GetProcessHeap(), 0, data->inet_buffers.lpvBuffer);
2002 data->cs.DebugInfo->Spare[0] = 0;
2005 }
2006 return refs;
2007}
#define InterlockedDecrement
Definition: armddk.h:52
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)

Referenced by rpcrt4_http_internet_callback(), rpcrt4_ncacn_http_close(), and wait_async_request().

◆ RpcNetworkInqProtseqsA()

RPC_STATUS WINAPI RpcNetworkInqProtseqsA ( RPC_PROTSEQ_VECTORA **  protseqs)

Definition at line 3971 of file rpc_transport.c.

3972{
3973 RPC_PROTSEQ_VECTORA *pvector;
3974 unsigned int i;
3976
3977 TRACE("(%p)\n", protseqs);
3978
3979 *protseqs = HeapAlloc(GetProcessHeap(), 0, sizeof(RPC_PROTSEQ_VECTORW)+(sizeof(unsigned char*)*ARRAY_SIZE(protseq_list)));
3980 if (!*protseqs)
3981 goto end;
3982 pvector = *protseqs;
3983 pvector->Count = 0;
3984 for (i = 0; i < ARRAY_SIZE(protseq_list); i++)
3985 {
3986 pvector->Protseq[i] = HeapAlloc(GetProcessHeap(), 0, strlen(protseq_list[i].name)+1);
3987 if (pvector->Protseq[i] == NULL)
3988 goto end;
3989 strcpy((char*)pvector->Protseq[i], protseq_list[i].name);
3990 pvector->Count++;
3991 }
3992 status = RPC_S_OK;
3993
3994end:
3995 if (status != RPC_S_OK)
3997 return status;
3998}
GLuint GLuint end
Definition: gl.h:1545
static struct list protseqs
Definition: rpc_server.c:68
RPC_STATUS WINAPI RpcProtseqVectorFreeA(RPC_PROTSEQ_VECTORA **protseqs)
static const struct protseq_ops protseq_list[]
unsigned char * Protseq[1]
Definition: rpcdce.h:91
unsigned int Count
Definition: rpcdce.h:90
Definition: name.c:39

◆ RpcNetworkInqProtseqsW()

RPC_STATUS WINAPI RpcNetworkInqProtseqsW ( RPC_PROTSEQ_VECTORW **  protseqs)

Definition at line 3938 of file rpc_transport.c.

3939{
3940 RPC_PROTSEQ_VECTORW *pvector;
3941 unsigned int i;
3943
3944 TRACE("(%p)\n", protseqs);
3945
3946 *protseqs = HeapAlloc(GetProcessHeap(), 0, sizeof(RPC_PROTSEQ_VECTORW)+(sizeof(unsigned short*)*ARRAY_SIZE(protseq_list)));
3947 if (!*protseqs)
3948 goto end;
3949 pvector = *protseqs;
3950 pvector->Count = 0;
3951 for (i = 0; i < ARRAY_SIZE(protseq_list); i++)
3952 {
3953 pvector->Protseq[i] = HeapAlloc(GetProcessHeap(), 0, (strlen(protseq_list[i].name)+1)*sizeof(unsigned short));
3954 if (pvector->Protseq[i] == NULL)
3955 goto end;
3957 (WCHAR*)pvector->Protseq[i], strlen(protseq_list[i].name) + 1);
3958 pvector->Count++;
3959 }
3960 status = RPC_S_OK;
3961
3962end:
3963 if (status != RPC_S_OK)
3965 return status;
3966}
#define CP_ACP
Definition: compat.h:109
#define MultiByteToWideChar
Definition: compat.h:110
RPC_STATUS WINAPI RpcProtseqVectorFreeW(RPC_PROTSEQ_VECTORW **protseqs)
unsigned int Count
Definition: rpcdce.h:96
unsigned short * Protseq[1]
Definition: rpcdce.h:97
char CHAR
Definition: xmlstorage.h:175

◆ RpcNetworkIsProtseqValidA()

RPC_STATUS WINAPI RpcNetworkIsProtseqValidA ( RPC_CSTR  protseq)

Definition at line 3886 of file rpc_transport.c.

3887{
3888 UNICODE_STRING protseqW;
3889
3890 if (RtlCreateUnicodeStringFromAsciiz(&protseqW, (char*)protseq))
3891 {
3893 RtlFreeUnicodeString(&protseqW);
3894 return ret;
3895 }
3896 return RPC_S_OUT_OF_MEMORY;
3897}
NTSYSAPI BOOLEAN NTAPI RtlCreateUnicodeStringFromAsciiz(_Out_ PUNICODE_STRING Destination, _In_ PCSZ Source)
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
RPC_STATUS WINAPI RpcNetworkIsProtseqValidW(RPC_WSTR protseq)

Referenced by test_rpc_ncacn_ip_tcp().

◆ RpcNetworkIsProtseqValidW()

RPC_STATUS WINAPI RpcNetworkIsProtseqValidW ( RPC_WSTR  protseq)

Definition at line 3869 of file rpc_transport.c.

3870{
3871 char ps[0x10];
3872
3873 WideCharToMultiByte(CP_ACP, 0, protseq, -1,
3874 ps, sizeof ps, NULL, NULL);
3876 return RPC_S_OK;
3877
3878 FIXME("Unknown protseq %s\n", debugstr_w(protseq));
3879
3881}
#define debugstr_w
Definition: kernel32.h:32
static const struct connection_ops * rpcrt4_get_conn_protseq_ops(const char *protseq)
#define RPC_S_INVALID_RPC_PROTSEQ
Definition: winerror.h:1015

Referenced by RpcNetworkIsProtseqValidA().

◆ RpcProtseqVectorFreeA()

RPC_STATUS WINAPI RpcProtseqVectorFreeA ( RPC_PROTSEQ_VECTORA **  protseqs)

Definition at line 3902 of file rpc_transport.c.

3903{
3904 TRACE("(%p)\n", protseqs);
3905
3906 if (*protseqs)
3907 {
3908 unsigned int i;
3909 for (i = 0; i < (*protseqs)->Count; i++)
3910 HeapFree(GetProcessHeap(), 0, (*protseqs)->Protseq[i]);
3912 *protseqs = NULL;
3913 }
3914 return RPC_S_OK;
3915}

Referenced by RpcNetworkInqProtseqsA().

◆ RpcProtseqVectorFreeW()

RPC_STATUS WINAPI RpcProtseqVectorFreeW ( RPC_PROTSEQ_VECTORW **  protseqs)

Definition at line 3920 of file rpc_transport.c.

3921{
3922 TRACE("(%p)\n", protseqs);
3923
3924 if (*protseqs)
3925 {
3926 unsigned int i;
3927 for (i = 0; i < (*protseqs)->Count; i++)
3928 HeapFree(GetProcessHeap(), 0, (*protseqs)->Protseq[i]);
3930 *protseqs = NULL;
3931 }
3932 return RPC_S_OK;
3933}

Referenced by RpcNetworkInqProtseqsW().

◆ RPCRT4_CloseConnection()

RPC_STATUS RPCRT4_CloseConnection ( RpcConnection Connection)

Definition at line 3618 of file rpc_transport.c.

3619{
3620 TRACE("(Connection == ^%p)\n", Connection);
3621 if (SecIsValidHandle(&Connection->ctx))
3622 {
3623 DeleteSecurityContext(&Connection->ctx);
3624 SecInvalidateHandle(&Connection->ctx);
3625 }
3626 rpcrt4_conn_close(Connection);
3627 return RPC_S_OK;
3628}
static int rpcrt4_conn_close(RpcConnection *Connection)
Definition: rpc_binding.h:200
CtxtHandle ctx
Definition: rpc_binding.h:74

Referenced by RPCRT4_ReleaseConnection(), and RPCRT4_server_thread().

◆ rpcrt4_conn_create_pipe()

static RPC_STATUS rpcrt4_conn_create_pipe ( RpcConnection conn)
static

Definition at line 322 of file rpc_transport.c.

323{
324 RpcConnection_np *connection = (RpcConnection_np *) conn;
325#ifdef __REACTOS__
326 DWORD ErrCode;
327 SECURITY_ATTRIBUTES SecurityAttributes;
328 PSECURITY_DESCRIPTOR PipeSecDesc;
329#endif
330
331 TRACE("listening on %s\n", connection->listen_pipe);
332
333#ifdef __REACTOS__
334 ErrCode = rpcrt4_create_pipe_security(&PipeSecDesc);
335 if (ErrCode != ERROR_SUCCESS)
336 {
337 ERR("rpcrt4_conn_create_pipe(): Pipe security descriptor creation failed!\n");
339 }
340
341 SecurityAttributes.nLength = sizeof(SECURITY_ATTRIBUTES);
342 SecurityAttributes.lpSecurityDescriptor = PipeSecDesc;
343 SecurityAttributes.bInheritHandle = FALSE;
344
348 RPC_MAX_PACKET_SIZE, RPC_MAX_PACKET_SIZE, 5000, &SecurityAttributes);
349 HeapFree(GetProcessHeap(), 0, PipeSecDesc);
350#else
355#endif
356 if (connection->pipe == INVALID_HANDLE_VALUE)
357 {
358 WARN("CreateNamedPipe failed with error %d\n", GetLastError());
360 {
362 }
363 else
364 {
366 }
367 }
368
369 return RPC_S_OK;
370}
#define WARN(fmt,...)
Definition: debug.h:112
#define ERROR_SUCCESS
Definition: deptool.c:10
struct _SECURITY_ATTRIBUTES SECURITY_ATTRIBUTES
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
#define FILE_FLAG_OVERLAPPED
Definition: disk.h:46
HANDLE WINAPI CreateNamedPipeA(LPCSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances, DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES lpSecurityAttributes)
Definition: npipe.c:220
#define RPC_MAX_PACKET_SIZE
Definition: rpc_defs.h:184
LPVOID lpSecurityDescriptor
Definition: compat.h:193
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
#define PIPE_ACCESS_DUPLEX
Definition: winbase.h:164
#define PIPE_READMODE_MESSAGE
Definition: winbase.h:170
#define PIPE_TYPE_MESSAGE
Definition: winbase.h:168
#define PIPE_UNLIMITED_INSTANCES
Definition: winbase.h:175
#define RPC_S_CANT_CREATE_ENDPOINT
Definition: winerror.h:1031
#define ERROR_FILE_EXISTS
Definition: winerror.h:165
#define RPC_S_DUPLICATE_ENDPOINT
Definition: winerror.h:1048

Referenced by rpcrt4_ncacn_np_handoff(), rpcrt4_ncalrpc_handoff(), rpcrt4_protseq_ncacn_np_open_endpoint(), rpcrt4_protseq_ncalrpc_open_endpoint(), and rpcrt4_protseq_np_get_wait_array().

◆ rpcrt4_conn_np_alloc()

static RpcConnection * rpcrt4_conn_np_alloc ( void  )
static

Definition at line 91 of file rpc_transport.c.

92{
94 return &npc->common;
95}
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
RpcConnection common
Definition: rpc_transport.c:82

◆ rpcrt4_conn_np_cancel_call()

static void rpcrt4_conn_np_cancel_call ( RpcConnection conn)
static

Definition at line 782 of file rpc_transport.c.

783{
784 RpcConnection_np *connection = (RpcConnection_np *)conn;
785 CancelIoEx(connection->pipe, NULL);
786}

◆ rpcrt4_conn_np_close()

static int rpcrt4_conn_np_close ( RpcConnection conn)
static

Definition at line 747 of file rpc_transport.c.

748{
749 RpcConnection_np *connection = (RpcConnection_np *) conn;
750 if (connection->pipe)
751 {
752 FlushFileBuffers(connection->pipe);
753 CloseHandle(connection->pipe);
754 connection->pipe = 0;
755 }
756 if (connection->listen_event)
757 {
758 CloseHandle(connection->listen_event);
759 connection->listen_event = 0;
760 }
761 if (connection->event_cache)
762 {
763 CloseHandle(connection->event_cache);
764 connection->event_cache = 0;
765 }
766 return 0;
767}
BOOL WINAPI FlushFileBuffers(IN HANDLE hFile)
Definition: fileinfo.c:25

◆ rpcrt4_conn_np_close_read()

static void rpcrt4_conn_np_close_read ( RpcConnection conn)
static

Definition at line 769 of file rpc_transport.c.

770{
771 RpcConnection_np *connection = (RpcConnection_np*)conn;
773
774 connection->read_closed = TRUE;
775#ifdef __REACTOS__ /* FIXME: We should also cancel I/O for other threads */
776 NtCancelIoFile(connection->pipe, &io_status);
777#else
778 NtCancelIoFileEx(connection->pipe, &connection->io_status, &io_status);
779#endif
780}
NTSYSAPI NTSTATUS WINAPI NtCancelIoFileEx(HANDLE, PIO_STATUS_BLOCK, PIO_STATUS_BLOCK)
static HANDLE PIO_APC_ROUTINE void PIO_STATUS_BLOCK io_status
Definition: comm.c:56
NTSTATUS NTAPI NtCancelIoFile(IN HANDLE FileHandle, OUT PIO_STATUS_BLOCK IoStatusBlock)
Definition: file.c:4019
IO_STATUS_BLOCK io_status
Definition: rpc_transport.c:86

◆ rpcrt4_conn_np_handoff()

static void rpcrt4_conn_np_handoff ( RpcConnection_np old_npc,
RpcConnection_np new_npc 
)
static

Definition at line 607 of file rpc_transport.c.

608{
609 /* because of the way named pipes work, we'll transfer the connected pipe
610 * to the child, then reopen the server binding to continue listening */
611
612 new_npc->pipe = old_npc->pipe;
613 old_npc->pipe = 0;
614 assert(!old_npc->listen_event);
615}
#define assert(x)
Definition: debug.h:53

Referenced by rpcrt4_ncacn_np_handoff(), and rpcrt4_ncalrpc_handoff().

◆ rpcrt4_conn_np_impersonate_client()

static RPC_STATUS rpcrt4_conn_np_impersonate_client ( RpcConnection conn)
static

Definition at line 906 of file rpc_transport.c.

907{
908 RpcConnection_np *npc = (RpcConnection_np *)conn;
909 BOOL ret;
910
911 TRACE("(%p)\n", conn);
912
913 if (conn->AuthInfo && SecIsValidHandle(&conn->ctx))
915
917 if (!ret)
918 {
920 WARN("ImpersonateNamedPipeClient failed with error %u\n", error);
921 switch (error)
922 {
925 }
926 }
927 return RPC_S_OK;
928}
BOOL WINAPI ImpersonateNamedPipeClient(HANDLE hNamedPipe)
Definition: security.c:1024
#define error(str)
Definition: mkdosfs.c:1605
RPC_STATUS RPCRT4_default_impersonate_client(RpcConnection *conn)
Definition: rpc_message.c:1131
RpcAuthInfo * AuthInfo
Definition: rpc_binding.h:77
#define ERROR_CANNOT_IMPERSONATE
Definition: winerror.h:849
#define RPC_S_NO_CONTEXT_AVAILABLE
Definition: winerror.h:1073

◆ rpcrt4_conn_np_read()

static int rpcrt4_conn_np_read ( RpcConnection conn,
void buffer,
unsigned int  count 
)
static

Definition at line 689 of file rpc_transport.c.

690{
691 RpcConnection_np *connection = (RpcConnection_np *) conn;
694
695 event = get_np_event(connection);
696 if (!event)
697 return -1;
698
699 if (connection->read_closed)
701 else
702 status = NtReadFile(connection->pipe, event, NULL, NULL, &connection->io_status, buffer, count, NULL, NULL);
703 if (status == STATUS_PENDING)
704 {
705 /* check read_closed again before waiting to avoid a race */
706 if (connection->read_closed)
707 {
709#ifdef __REACTOS__ /* FIXME: We should also cancel I/O for other threads */
710 NtCancelIoFile(connection->pipe, &io_status);
711#else
712 NtCancelIoFileEx(connection->pipe, &connection->io_status, &io_status);
713#endif
714 }
716 status = connection->io_status.u.Status;
717 }
718 release_np_event(connection, event);
719 return status && status != STATUS_BUFFER_OVERFLOW ? -1 : connection->io_status.Information;
720}
LONG NTSTATUS
Definition: precomp.h:26
#define INFINITE
Definition: serial.h:102
#define STATUS_PENDING
Definition: ntstatus.h:82
static HANDLE get_np_event(RpcConnection_np *connection)
Definition: rpc_transport.c:97
static void release_np_event(RpcConnection_np *connection, HANDLE event)
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
NTSTATUS NTAPI NtReadFile(HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, PVOID Buffer, ULONG Length, PLARGE_INTEGER ByteOffset, PULONG Key)
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
#define STATUS_CANCELLED
Definition: udferr_usr.h:170

Referenced by rpcrt4_conn_np_wait_for_incoming_data().

◆ rpcrt4_conn_np_revert_to_self()

static RPC_STATUS rpcrt4_conn_np_revert_to_self ( RpcConnection conn)
static

Definition at line 930 of file rpc_transport.c.

931{
932 BOOL ret;
933
934 TRACE("(%p)\n", conn);
935
936 if (conn->AuthInfo && SecIsValidHandle(&conn->ctx))
938
939 ret = RevertToSelf();
940 if (!ret)
941 {
942 WARN("RevertToSelf failed with error %u\n", GetLastError());
944 }
945 return RPC_S_OK;
946}
RPC_STATUS RPCRT4_default_revert_to_self(RpcConnection *conn)
Definition: rpc_message.c:1159
BOOL WINAPI RevertToSelf(void)
Definition: security.c:1608

◆ rpcrt4_conn_np_wait_for_incoming_data()

static int rpcrt4_conn_np_wait_for_incoming_data ( RpcConnection conn)
static

Definition at line 788 of file rpc_transport.c.

789{
790 return rpcrt4_conn_np_read(conn, NULL, 0);
791}
static int rpcrt4_conn_np_read(RpcConnection *conn, void *buffer, unsigned int count)

◆ rpcrt4_conn_np_write()

static int rpcrt4_conn_np_write ( RpcConnection conn,
const void buffer,
unsigned int  count 
)
static

Definition at line 722 of file rpc_transport.c.

723{
724 RpcConnection_np *connection = (RpcConnection_np *) conn;
728
729 event = get_np_event(connection);
730 if (!event)
731 return -1;
732
734 if (status == STATUS_PENDING)
735 {
737 status = io_status.u.Status;
738 }
739 release_np_event(connection, event);
740 if (status)
741 return -1;
742
743 assert(io_status.Information == count);
744 return count;
745}
NTSYSAPI NTSTATUS NTAPI NtWriteFile(IN HANDLE hFile, IN HANDLE hEvent OPTIONAL, IN PIO_APC_ROUTINE IoApcRoutine OPTIONAL, IN PVOID IoApcContext OPTIONAL, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN PVOID WriteBuffer, IN ULONG WriteBufferLength, IN PLARGE_INTEGER FileOffset OPTIONAL, IN PULONG LockOperationKey OPTIONAL)

◆ rpcrt4_conn_open_pipe()

static RPC_STATUS rpcrt4_conn_open_pipe ( RpcConnection Connection,
LPCSTR  pname,
BOOL  wait 
)
static

Definition at line 372 of file rpc_transport.c.

373{
374 RpcConnection_np *npc = (RpcConnection_np *) Connection;
375 HANDLE pipe;
376 DWORD err, dwMode;
377
378 TRACE("connecting to %s\n", pname);
379
380 while (TRUE) {
381 DWORD dwFlags = 0;
382 if (Connection->QOS)
383 {
385 switch (Connection->QOS->qos->ImpersonationType)
386 {
388 /* FIXME: what to do here? */
389 break;
392 break;
395 break;
398 break;
401 break;
402 }
405 }
408 if (pipe != INVALID_HANDLE_VALUE) break;
409 err = GetLastError();
410 if (err == ERROR_PIPE_BUSY) {
412 TRACE("retrying busy server\n");
413 continue;
414 }
415 TRACE("connection failed, error=%x\n", err);
417#ifdef __REACTOS__
418 } else if (err == ERROR_BAD_NETPATH) {
419 TRACE("connection failed, error=%x\n", err);
421#endif
422 }
423 if (!wait || !WaitNamedPipeA(pname, NMPWAIT_WAIT_FOREVER)) {
424 err = GetLastError();
425 WARN("connection failed, error=%x\n", err);
427 }
428 }
429
430 /* success */
431 /* pipe is connected; change to message-read mode. */
432 dwMode = PIPE_READMODE_MESSAGE;
433 SetNamedPipeHandleState(pipe, &dwMode, NULL, NULL);
434 npc->pipe = pipe;
435
436 return RPC_S_OK;
437}
#define OPEN_EXISTING
Definition: compat.h:775
#define CreateFileA(a, b, c, d, e, f, g)
Definition: compat.h:740
#define GENERIC_READ
Definition: compat.h:135
GLenum pname
Definition: glext.h:5645
BOOL WINAPI SetNamedPipeHandleState(HANDLE hNamedPipe, LPDWORD lpMode, LPDWORD lpMaxCollectionCount, LPDWORD lpCollectDataTimeout)
Definition: npipe.c:774
#define GENERIC_WRITE
Definition: nt_native.h:90
#define err(...)
#define RPC_C_IMP_LEVEL_IDENTIFY
Definition: rpcdce.h:175
#define RPC_C_QOS_IDENTITY_DYNAMIC
Definition: rpcdce.h:181
#define RPC_C_IMP_LEVEL_DELEGATE
Definition: rpcdce.h:177
#define RPC_C_IMP_LEVEL_IMPERSONATE
Definition: rpcdce.h:176
#define RPC_C_IMP_LEVEL_ANONYMOUS
Definition: rpcdce.h:174
#define RPC_C_IMP_LEVEL_DEFAULT
Definition: rpcdce.h:173
#define NMPWAIT_WAIT_FOREVER
Definition: winbase.h:133
#define SECURITY_DELEGATION
Definition: winbase.h:543
#define NMPWAIT_USE_DEFAULT_WAIT
Definition: winbase.h:134
#define SECURITY_IMPERSONATION
Definition: winbase.h:542
#define SECURITY_ANONYMOUS
Definition: winbase.h:540
#define SECURITY_SQOS_PRESENT
Definition: winbase.h:546
#define SECURITY_IDENTIFICATION
Definition: winbase.h:541
#define SECURITY_CONTEXT_TRACKING
Definition: winbase.h:544
_In_ PCCERT_CONTEXT _In_ DWORD dwFlags
Definition: wincrypt.h:1176
#define RPC_S_SERVER_TOO_BUSY
Definition: winerror.h:1034
#define ERROR_BAD_NETPATH
Definition: winerror.h:145
#define ERROR_PIPE_BUSY
Definition: winerror.h:283

Referenced by rpcrt4_ncacn_np_open(), and rpcrt4_ncalrpc_open().

◆ rpcrt4_conn_release_and_wait()

void rpcrt4_conn_release_and_wait ( RpcConnection connection)

Definition at line 3694 of file rpc_transport.c.

3695{
3696 HANDLE event = NULL;
3697
3698 if (connection->ref > 1)
3699 event = connection->wait_release = CreateEventW(NULL, TRUE, FALSE, NULL);
3700
3701 RPCRT4_ReleaseConnection(connection);
3702
3703 if(event)
3704 {
3707 }
3708}
void RPCRT4_ReleaseConnection(RpcConnection *connection)
HANDLE wait_release
Definition: rpc_binding.h:66

Referenced by RPCRT4_server_thread().

◆ rpcrt4_conn_tcp_alloc()

static RpcConnection * rpcrt4_conn_tcp_alloc ( void  )
static

Definition at line 1443 of file rpc_transport.c.

1444{
1445 RpcConnection_tcp *tcpc;
1447 if (tcpc == NULL)
1448 return NULL;
1449 tcpc->sock = -1;
1450 if (!rpcrt4_sock_wait_init(tcpc))
1451 {
1452 HeapFree(GetProcessHeap(), 0, tcpc);
1453 return NULL;
1454 }
1455 return &tcpc->common;
1456}
static BOOL rpcrt4_sock_wait_init(RpcConnection_tcp *tcpc)
RpcConnection common

◆ rpcrt4_conn_tcp_cancel_call()

static void rpcrt4_conn_tcp_cancel_call ( RpcConnection conn)
static

Definition at line 1793 of file rpc_transport.c.

1794{
1795 RpcConnection_tcp *connection = (RpcConnection_tcp *) conn;
1796
1797 TRACE("%p\n", connection);
1798
1799 SetEvent(connection->cancel_event);
1800}
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
Definition: synch.c:733

◆ rpcrt4_conn_tcp_close()

static int rpcrt4_conn_tcp_close ( RpcConnection conn)
static

Definition at line 1773 of file rpc_transport.c.

1774{
1775 RpcConnection_tcp *connection = (RpcConnection_tcp *) conn;
1776
1777 TRACE("%d\n", connection->sock);
1778
1779 if (connection->sock != -1)
1780 closesocket(connection->sock);
1781 connection->sock = -1;
1782 CloseHandle(connection->sock_event);
1783 CloseHandle(connection->cancel_event);
1784 return 0;
1785}
#define closesocket
Definition: ncftp.h:477

◆ rpcrt4_conn_tcp_close_read()

static void rpcrt4_conn_tcp_close_read ( RpcConnection conn)
static

Definition at line 1787 of file rpc_transport.c.

1788{
1789 RpcConnection_tcp *connection = (RpcConnection_tcp *) conn;
1790 shutdown(connection->sock, SD_RECEIVE);
1791}
INT WSAAPI shutdown(IN SOCKET s, IN INT how)
Definition: sockctrl.c:506
#define SD_RECEIVE
Definition: winsock.h:54

◆ rpcrt4_conn_tcp_handoff()

static RPC_STATUS rpcrt4_conn_tcp_handoff ( RpcConnection old_conn,
RpcConnection new_conn 
)
static

Definition at line 1687 of file rpc_transport.c.

1688{
1689 int ret;
1690 struct sockaddr_in address;
1691 socklen_t addrsize;
1694 u_long nonblocking;
1695
1696 addrsize = sizeof(address);
1697 ret = accept(server->sock, (struct sockaddr*) &address, &addrsize);
1698 if (ret < 0)
1699 {
1700 ERR("Failed to accept a TCP connection: error %d\n", ret);
1702 }
1703
1704 nonblocking = 1;
1705 ioctlsocket(ret, FIONBIO, &nonblocking);
1706 client->sock = ret;
1707
1708 client->common.NetworkAddr = HeapAlloc(GetProcessHeap(), 0, INET6_ADDRSTRLEN);
1709 ret = getnameinfo((struct sockaddr*)&address, addrsize, client->common.NetworkAddr, INET6_ADDRSTRLEN, NULL, 0, NI_NUMERICHOST);
1710 if (ret != 0)
1711 {
1712 ERR("Failed to retrieve the IP address, error %d\n", ret);
1714 }
1715
1716 TRACE("Accepted a new TCP connection from %s\n", client->common.NetworkAddr);
1717 return RPC_S_OK;
1718}
unsigned long u_long
Definition: linux.h:269
GLuint address
Definition: glext.h:9393
int socklen_t
Definition: tcp.c:35
#define ioctlsocket
Definition: ncftp.h:481
static FILE * client
Definition: client.c:41
SOCKET WSAAPI accept(IN SOCKET s, OUT LPSOCKADDR addr, OUT INT FAR *addrlen)
Definition: socklife.c:23
#define RPC_S_OUT_OF_RESOURCES
Definition: winerror.h:1032
#define FIONBIO
Definition: winsock.h:149
#define NI_NUMERICHOST
Definition: ws2def.h:354
#define INET6_ADDRSTRLEN
Definition: ws2ipdef.h:132
#define getnameinfo
Definition: wspiapi.h:45

◆ rpcrt4_conn_tcp_is_server_listening()

static RPC_STATUS rpcrt4_conn_tcp_is_server_listening ( const char endpoint)
static

Definition at line 1802 of file rpc_transport.c.

1803{
1804 FIXME("\n");
1805 return RPC_S_ACCESS_DENIED;
1806}
#define RPC_S_ACCESS_DENIED
Definition: rpcnterr.h:29

◆ rpcrt4_conn_tcp_read()

static int rpcrt4_conn_tcp_read ( RpcConnection Connection,
void buffer,
unsigned int  count 
)
static

Definition at line 1720 of file rpc_transport.c.

1722{
1723 RpcConnection_tcp *tcpc = (RpcConnection_tcp *) Connection;
1724 int bytes_read = 0;
1725 while (bytes_read != count)
1726 {
1727 int r = recv(tcpc->sock, (char *)buffer + bytes_read, count - bytes_read, 0);
1728 if (!r)
1729 return -1;
1730 else if (r > 0)
1731 bytes_read += r;
1732 else if (WSAGetLastError() == WSAEINTR)
1733 continue;
1734 else if (WSAGetLastError() != WSAEWOULDBLOCK)
1735 {
1736 WARN("recv() failed: %u\n", WSAGetLastError());
1737 return -1;
1738 }
1739 else
1740 {
1741 if (!rpcrt4_sock_wait_for_recv(tcpc))
1742 return -1;
1743 }
1744 }
1745 TRACE("%d %p %u -> %d\n", tcpc->sock, buffer, count, bytes_read);
1746 return bytes_read;
1747}
INT WSAAPI recv(IN SOCKET s, OUT CHAR FAR *buf, IN INT len, IN INT flags)
Definition: recv.c:23
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
static BOOL rpcrt4_sock_wait_for_recv(RpcConnection_tcp *tcpc)
#define WSAEWOULDBLOCK
Definition: winerror.h:1948
#define WSAEINTR
Definition: winerror.h:1942
int PASCAL FAR WSAGetLastError(void)
Definition: dllmain.c:112

◆ rpcrt4_conn_tcp_wait_for_incoming_data()

static int rpcrt4_conn_tcp_wait_for_incoming_data ( RpcConnection Connection)
static

Definition at line 1808 of file rpc_transport.c.

1809{
1810 RpcConnection_tcp *tcpc = (RpcConnection_tcp *) Connection;
1811
1812 TRACE("%p\n", Connection);
1813
1814 if (!rpcrt4_sock_wait_for_recv(tcpc))
1815 return -1;
1816 return 0;
1817}

◆ rpcrt4_conn_tcp_write()

static int rpcrt4_conn_tcp_write ( RpcConnection Connection,
const void buffer,
unsigned int  count 
)
static

Definition at line 1749 of file rpc_transport.c.

1751{
1752 RpcConnection_tcp *tcpc = (RpcConnection_tcp *) Connection;
1753 int bytes_written = 0;
1754 while (bytes_written != count)
1755 {
1756 int r = send(tcpc->sock, (const char *)buffer + bytes_written, count - bytes_written, 0);
1757 if (r >= 0)
1758 bytes_written += r;
1759 else if (WSAGetLastError() == WSAEINTR)
1760 continue;
1761 else if (WSAGetLastError() != WSAEWOULDBLOCK)
1762 return -1;
1763 else
1764 {
1765 if (!rpcrt4_sock_wait_for_send(tcpc))
1766 return -1;
1767 }
1768 }
1769 TRACE("%d %p %u -> %d\n", tcpc->sock, buffer, count, bytes_written);
1770 return bytes_written;
1771}
INT WSAAPI send(IN SOCKET s, IN CONST CHAR FAR *buf, IN INT len, IN INT flags)
Definition: send.c:23
static BOOL rpcrt4_sock_wait_for_send(RpcConnection_tcp *tcpc)

◆ RPCRT4_CreateConnection()

RPC_STATUS RPCRT4_CreateConnection ( RpcConnection **  Connection,
BOOL  server,
LPCSTR  Protseq,
LPCSTR  NetworkAddr,
LPCSTR  Endpoint,
LPCWSTR  NetworkOptions,
RpcAuthInfo AuthInfo,
RpcQualityOfService QOS,
LPCWSTR  CookieAuth 
)

Definition at line 3630 of file rpc_transport.c.

3633{
3634 static LONG next_id;
3635 const struct connection_ops *ops;
3636 RpcConnection* NewConnection;
3637
3638 ops = rpcrt4_get_conn_protseq_ops(Protseq);
3639 if (!ops)
3640 {
3641 FIXME("not supported for protseq %s\n", Protseq);
3643 }
3644
3645 NewConnection = ops->alloc();
3646 NewConnection->ref = 1;
3647 NewConnection->server = server;
3648 NewConnection->ops = ops;
3649 NewConnection->NetworkAddr = RPCRT4_strdupA(NetworkAddr);
3650 NewConnection->Endpoint = RPCRT4_strdupA(Endpoint);
3651 NewConnection->NetworkOptions = RPCRT4_strdupW(NetworkOptions);
3652 NewConnection->CookieAuth = RPCRT4_strdupW(CookieAuth);
3654 NewConnection->NextCallId = 1;
3655
3656 SecInvalidateHandle(&NewConnection->ctx);
3657 if (AuthInfo) RpcAuthInfo_AddRef(AuthInfo);
3658 NewConnection->AuthInfo = AuthInfo;
3659 NewConnection->auth_context_id = InterlockedIncrement( &next_id );
3661 NewConnection->QOS = QOS;
3662
3663 list_init(&NewConnection->conn_pool_entry);
3664 list_init(&NewConnection->protseq_entry);
3665
3666 TRACE("connection: %p\n", NewConnection);
3667 *Connection = NewConnection;
3668
3669 return RPC_S_OK;
3670}
static void list_init(struct list_entry *head)
Definition: list.h:51
long LONG
Definition: pedump.c:60
ULONG RpcAuthInfo_AddRef(RpcAuthInfo *AuthInfo)
Definition: rpc_binding.c:1183
ULONG RpcQualityOfService_AddRef(RpcQualityOfService *qos)
Definition: rpc_binding.c:1360
#define RPCRT4_strdupA(x)
Definition: rpc_binding.h:151
#define RPCRT4_strdupW(x)
Definition: rpc_binding.h:152
LPSTR NetworkAddr
Definition: rpc_binding.h:67
struct list conn_pool_entry
Definition: rpc_binding.h:85
USHORT NextCallId
Definition: rpc_binding.h:93
LPWSTR NetworkOptions
Definition: rpc_binding.h:69
USHORT MaxTransmissionSize
Definition: rpc_binding.h:71
const struct connection_ops * ops
Definition: rpc_binding.h:70
struct list protseq_entry
Definition: rpc_binding.h:94
LPWSTR CookieAuth
Definition: rpc_binding.h:82
ULONG auth_context_id
Definition: rpc_binding.h:78
RpcConnection *(* alloc)(void)
Definition: rpc_binding.h:102
#define RPC_S_PROTSEQ_NOT_SUPPORTED
Definition: winerror.h:1014
struct _QualityOfService QOS

Referenced by RpcAssoc_GetClientConnection(), rpcrt4_protseq_ncacn_ip_tcp_open_endpoint(), rpcrt4_protseq_ncacn_np_open_endpoint(), rpcrt4_protseq_ncalrpc_open_endpoint(), and rpcrt4_spawn_connection().

◆ rpcrt4_get_conn_protseq_ops()

static const struct connection_ops * rpcrt4_get_conn_protseq_ops ( const char protseq)
static

Definition at line 3599 of file rpc_transport.c.

3600{
3601 unsigned int i;
3602 for(i = 0; i < ARRAY_SIZE(conn_protseq_list); i++)
3603 if (!strcmp(conn_protseq_list[i].name, protseq))
3604 return &conn_protseq_list[i];
3605 return NULL;
3606}
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
static const struct connection_ops conn_protseq_list[]

Referenced by RpcNetworkIsProtseqValidW(), RPCRT4_CreateConnection(), RPCRT4_IsServerListening(), and RpcTransport_GetTopOfTower().

◆ rpcrt4_get_protseq_ops()

const struct protseq_ops * rpcrt4_get_protseq_ops ( const char protseq)

Definition at line 3590 of file rpc_transport.c.

3591{
3592 unsigned int i;
3593 for(i = 0; i < ARRAY_SIZE(protseq_list); i++)
3594 if (!strcmp(protseq_list[i].name, protseq))
3595 return &protseq_list[i];
3596 return NULL;
3597}

Referenced by alloc_serverprotoseq().

◆ RPCRT4_GrabConnection()

RpcConnection * RPCRT4_GrabConnection ( RpcConnection connection)

Definition at line 3710 of file rpc_transport.c.

3711{
3712 LONG ref = InterlockedIncrement(&connection->ref);
3713 TRACE("%p ref=%u\n", connection, ref);
3714 return connection;
3715}
Definition: send.c:48

Referenced by RPCRT4_io_thread(), and RPCRT4_server_thread().

◆ rpcrt4_http_async_read()

static int rpcrt4_http_async_read ( HINTERNET  req,
RpcHttpAsyncData async_data,
HANDLE  cancel_event,
void buffer,
unsigned int  count 
)
static

Definition at line 2336 of file rpc_transport.c.

2338{
2339 char *buf = buffer;
2340 BOOL ret;
2341 unsigned int bytes_left = count;
2343
2345
2346 while (bytes_left)
2347 {
2348 async_data->inet_buffers.dwBufferLength = bytes_left;
2349 prepare_async_request(async_data);
2350 ret = InternetReadFileExW(req, &async_data->inet_buffers, IRF_ASYNC, 0);
2351 status = wait_async_request(async_data, ret, cancel_event);
2352 if (status != RPC_S_OK)
2353 {
2355 TRACE("call cancelled\n");
2356 break;
2357 }
2358
2359 if (!async_data->inet_buffers.dwBufferLength)
2360 break;
2361 memcpy(buf, async_data->inet_buffers.lpvBuffer,
2362 async_data->inet_buffers.dwBufferLength);
2363
2364 bytes_left -= async_data->inet_buffers.dwBufferLength;
2365 buf += async_data->inet_buffers.dwBufferLength;
2366 }
2367
2368 HeapFree(GetProcessHeap(), 0, async_data->inet_buffers.lpvBuffer);
2369 async_data->inet_buffers.lpvBuffer = NULL;
2370
2371 TRACE("%p %p %u -> %u\n", req, buffer, count, status);
2372 return status == RPC_S_OK ? count : -1;
2373}
BOOL WINAPI InternetReadFileExW(HINTERNET hFile, LPINTERNET_BUFFERSW lpBuffer, DWORD dwFlags, DWORD_PTR dwContext)
Definition: internet.c:2248
DWORD dwBufferLength
Definition: wininet.h:278
LPVOID lpvBuffer
Definition: wininet.h:277
INTERNET_BUFFERSW inet_buffers
#define RPC_S_CALL_CANCELLED
Definition: winerror.h:1125
#define IRF_ASYNC
Definition: wininet.h:622

Referenced by drain_content(), rpcrt4_http_prepare_out_pipe(), rpcrt4_http_read_http_packet(), rpcrt4_ncacn_http_read(), and send_echo_request().

◆ rpcrt4_http_check_response()

static RPC_STATUS rpcrt4_http_check_response ( HINTERNET  hor)
static

Definition at line 2175 of file rpc_transport.c.

2176{
2177 BOOL ret;
2179 DWORD size;
2180 DWORD index;
2181 WCHAR buf[32];
2182 WCHAR *status_text = buf;
2183 TRACE("\n");
2184
2185 index = 0;
2186 size = sizeof(status_code);
2188 if (!ret)
2189 return GetLastError();
2191 return RPC_S_OK;
2192 index = 0;
2193 size = sizeof(buf);
2194 ret = HttpQueryInfoW(hor, HTTP_QUERY_STATUS_TEXT, status_text, &size, &index);
2196 {
2197 status_text = HeapAlloc(GetProcessHeap(), 0, size);
2198 ret = HttpQueryInfoW(hor, HTTP_QUERY_STATUS_TEXT, status_text, &size, &index);
2199 }
2200
2201 ERR("server returned: %d %s\n", status_code, ret ? debugstr_w(status_text) : "<status text unavailable>");
2202 if(status_text != buf) HeapFree(GetProcessHeap(), 0, status_text);
2203
2205 return ERROR_ACCESS_DENIED;
2207}
#define index(s, c)
Definition: various.h:29
#define ERROR_INSUFFICIENT_BUFFER
Definition: dderror.h:10
#define HTTP_STATUS_OK
Definition: winhttp.h:240
#define HTTP_STATUS_DENIED
Definition: winhttp.h:256
#define HTTP_QUERY_STATUS_TEXT
Definition: wininet.h:1543
#define HTTP_QUERY_STATUS_CODE
Definition: wininet.h:1542

Referenced by authorize_request(), rpcrt4_http_prepare_out_pipe(), rpcrt4_ncacn_http_open(), and send_echo_request().

◆ rpcrt4_http_internet_callback()

static VOID WINAPI rpcrt4_http_internet_callback ( HINTERNET  hInternet,
DWORD_PTR  dwContext,
DWORD  dwInternetStatus,
LPVOID  lpvStatusInformation,
DWORD  dwStatusInformationLength 
)
static

Definition at line 2150 of file rpc_transport.c.

2156{
2157 RpcHttpAsyncData *async_data = (RpcHttpAsyncData *)dwContext;
2158
2159 switch (dwInternetStatus)
2160 {
2162 TRACE("INTERNET_STATUS_REQUEST_COMPLETED\n");
2163 if (async_data)
2164 {
2165 INTERNET_ASYNC_RESULT *async_result = lpvStatusInformation;
2166
2167 async_data->async_result = async_result->dwResult ? ERROR_SUCCESS : async_result->dwError;
2168 SetEvent(async_data->completion_event);
2169 RpcHttpAsyncData_Release(async_data);
2170 }
2171 break;
2172 }
2173}
static ULONG RpcHttpAsyncData_Release(RpcHttpAsyncData *data)
DWORD_PTR dwResult
Definition: wininet.h:155
#define INTERNET_STATUS_REQUEST_COMPLETE
Definition: wininet.h:898

Referenced by rpcrt4_http_internet_connect().

◆ rpcrt4_http_internet_connect()

static RPC_STATUS rpcrt4_http_internet_connect ( RpcConnection_http httpc)
static

Definition at line 2209 of file rpc_transport.c.

2210{
2211 static const WCHAR wszUserAgent[] = {'M','S','R','P','C',0};
2212 LPWSTR proxy = NULL;
2213 LPWSTR user = NULL;
2215 LPWSTR servername = NULL;
2216 const WCHAR *option;
2218
2219 if (httpc->common.QOS &&
2221 {
2222 const RPC_HTTP_TRANSPORT_CREDENTIALS_W *http_cred = httpc->common.QOS->qos->u.HttpCredentials;
2223 if (http_cred->TransportCredentials)
2224 {
2225 WCHAR *p;
2226 const SEC_WINNT_AUTH_IDENTITY_W *cred = http_cred->TransportCredentials;
2227 ULONG len = cred->DomainLength + 1 + cred->UserLength;
2228 user = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
2229 if (!user)
2231 p = user;
2232 if (cred->DomainLength)
2233 {
2234 memcpy(p, cred->Domain, cred->DomainLength * sizeof(WCHAR));
2235 p += cred->DomainLength;
2236 *p = '\\';
2237 p++;
2238 }
2239 memcpy(p, cred->User, cred->UserLength * sizeof(WCHAR));
2240 p[cred->UserLength] = 0;
2241
2243 }
2244 }
2245
2246 for (option = httpc->common.NetworkOptions; option;
2247 option = (wcschr(option, ',') ? wcschr(option, ',')+1 : NULL))
2248 {
2249 static const WCHAR wszRpcProxy[] = {'R','p','c','P','r','o','x','y','=',0};
2250 static const WCHAR wszHttpProxy[] = {'H','t','t','p','P','r','o','x','y','=',0};
2251
2252 if (!_wcsnicmp(option, wszRpcProxy, ARRAY_SIZE(wszRpcProxy)-1))
2253 {
2254 const WCHAR *value_start = option + ARRAY_SIZE(wszRpcProxy)-1;
2255 const WCHAR *value_end;
2256 const WCHAR *p;
2257
2258 value_end = wcschr(option, ',');
2259 if (!value_end)
2260 value_end = value_start + lstrlenW(value_start);
2261 for (p = value_start; p < value_end; p++)
2262 if (*p == ':')
2263 {
2264 port = wcstol(p+1, NULL, 10);
2265 value_end = p;
2266 break;
2267 }
2268 TRACE("RpcProxy value is %s\n", debugstr_wn(value_start, value_end-value_start));
2269 servername = RPCRT4_strndupW(value_start, value_end-value_start);
2270 }
2271 else if (!_wcsnicmp(option, wszHttpProxy, ARRAY_SIZE(wszHttpProxy)-1))
2272 {
2273 const WCHAR *value_start = option + ARRAY_SIZE(wszHttpProxy)-1;
2274 const WCHAR *value_end;
2275
2276 value_end = wcschr(option, ',');
2277 if (!value_end)
2278 value_end = value_start + lstrlenW(value_start);
2279 TRACE("HttpProxy value is %s\n", debugstr_wn(value_start, value_end-value_start));
2280 proxy = RPCRT4_strndupW(value_start, value_end-value_start);
2281 }
2282 else
2283 FIXME("unhandled option %s\n", debugstr_w(option));
2284 }
2285
2288 if (!httpc->app_info)
2289 {
2293 HeapFree(GetProcessHeap(), 0, servername);
2294 ERR("InternetOpenW failed with error %d\n", GetLastError());
2296 }
2298
2299 /* if no RpcProxy option specified, set the HTTP server address to the
2300 * RPC server address */
2301 if (!servername)
2302 {
2303 servername = HeapAlloc(GetProcessHeap(), 0, (strlen(httpc->common.NetworkAddr) + 1)*sizeof(WCHAR));
2304 if (!servername)
2305 {
2310 }
2311 MultiByteToWideChar(CP_ACP, 0, httpc->common.NetworkAddr, -1, servername, strlen(httpc->common.NetworkAddr) + 1);
2312 }
2313
2314 port = (httpc->common.QOS &&
2318
2319 httpc->session = InternetConnectW(httpc->app_info, servername, port, user, password,
2320 INTERNET_SERVICE_HTTP, 0, 0);
2321
2325
2326 if (!httpc->session)
2327 {
2328 ERR("InternetConnectW failed with error %d\n", GetLastError());
2329 HeapFree(GetProcessHeap(), 0, servername);
2331 }
2332 httpc->servername = servername;
2333 return RPC_S_OK;
2334}
void user(int argc, const char *argv[])
Definition: cmds.c:1350
#define wcschr
Definition: compat.h:17
USHORT port
Definition: uri.c:228
INTERNET_STATUS_CALLBACK WINAPI InternetSetStatusCallbackW(HINTERNET hInternet, INTERNET_STATUS_CALLBACK lpfnIntCB)
Definition: internet.c:2075
HINTERNET WINAPI InternetConnectW(HINTERNET hInternet, LPCWSTR lpszServerName, INTERNET_PORT nServerPort, LPCWSTR lpszUserName, LPCWSTR lpszPassword, DWORD dwService, DWORD dwFlags, DWORD_PTR dwContext)
Definition: internet.c:1258
HINTERNET WINAPI InternetOpenW(LPCWSTR lpszAgent, DWORD dwAccessType, LPCWSTR lpszProxy, LPCWSTR lpszProxyBypass, DWORD dwFlags)
Definition: internet.c:979
int proxy
Definition: main.c:67
_Check_return_ long __cdecl wcstol(_In_z_ const wchar_t *_Str, _Out_opt_ _Deref_post_z_ wchar_t **_EndPtr, _In_ int _Radix)
#define debugstr_wn
Definition: kernel32.h:33
static WCHAR password[]
Definition: url.c:33
LPWSTR RPCRT4_strndupW(LPCWSTR src, INT slen)
Definition: rpc_binding.c:91
static VOID WINAPI rpcrt4_http_internet_callback(HINTERNET hInternet, DWORD_PTR dwContext, DWORD dwInternetStatus, LPVOID lpvStatusInformation, DWORD dwStatusInformationLength)
unsigned short * Domain
Definition: rpcdce.h:225
unsigned short * User
Definition: rpcdce.h:223
unsigned short * Password
Definition: rpcdce.h:227
Definition: getopt.h:109
WORD INTERNET_PORT
Definition: winhttp.h:38
#define INTERNET_DEFAULT_HTTP_PORT
Definition: winhttp.h:36
#define INTERNET_DEFAULT_HTTPS_PORT
Definition: winhttp.h:37
#define INTERNET_FLAG_ASYNC
Definition: wininet.h:64
#define INTERNET_OPEN_TYPE_PROXY
Definition: wininet.h:523
#define INTERNET_OPEN_TYPE_PRECONFIG
Definition: wininet.h:521
#define INTERNET_SERVICE_HTTP
Definition: wininet.h:562
WCHAR * LPWSTR
Definition: xmlstorage.h:184

Referenced by rpcrt4_ncacn_http_open().

◆ rpcrt4_http_keep_connection_active_timer_proc()

static VOID rpcrt4_http_keep_connection_active_timer_proc ( PVOID  param,
BOOLEAN  dummy 
)
static

Definition at line 2105 of file rpc_transport.c.

2106{
2107 HINTERNET in_request = param;
2108 RpcPktHdr *idle_pkt;
2109
2111 0, 0);
2112 if (idle_pkt)
2113 {
2114 DWORD bytes_written;
2115 InternetWriteFile(in_request, idle_pkt, idle_pkt->common.frag_len, &bytes_written);
2116 RPCRT4_FreeHeader(idle_pkt);
2117 }
2118}
BOOL WINAPI InternetWriteFile(HINTERNET hFile, LPCVOID lpBuffer, DWORD dwNumOfBytesToWrite, LPDWORD lpdwNumOfBytesWritten)
Definition: internet.c:2114
GLfloat param
Definition: glext.h:5796
VOID RPCRT4_FreeHeader(RpcPktHdr *Header)
Definition: rpc_message.c:403
RpcPktHdr * RPCRT4_BuildHttpHeader(ULONG DataRepresentation, unsigned short flags, unsigned short num_data_items, unsigned int payload_size)
Definition: rpc_message.c:291
#define NDR_LOCAL_DATA_REPRESENTATION
Definition: rpcndr.h:107
unsigned short frag_len
Definition: rpc_defs.h:33
RpcPktCommonHdr common
Definition: rpc_defs.h:152

Referenced by rpcrt4_http_timer_thread().

◆ rpcrt4_http_prepare_in_pipe()

static RPC_STATUS rpcrt4_http_prepare_in_pipe ( HINTERNET  in_request,
RpcHttpAsyncData async_data,
HANDLE  cancel_event,
const UUID connection_uuid,
const UUID in_pipe_uuid,
const UUID association_uuid,
BOOL  authorized 
)
static

Definition at line 2409 of file rpc_transport.c.

2412{
2413 BOOL ret;
2415 RpcPktHdr *hdr;
2416 INTERNET_BUFFERSW buffers_in;
2417 DWORD bytes_written;
2418
2419 if (!authorized)
2420 {
2421 /* ask wininet to authorize, if necessary */
2422 status = send_echo_request(in_request, async_data, cancel_event);
2423 if (status != RPC_S_OK) return status;
2424 }
2425 memset(&buffers_in, 0, sizeof(buffers_in));
2426 buffers_in.dwStructSize = sizeof(buffers_in);
2427 /* FIXME: get this from the registry */
2428 buffers_in.dwBufferTotal = 1024 * 1024 * 1024; /* 1Gb */
2429 status = insert_content_length_header(in_request, buffers_in.dwBufferTotal);
2430 if (status != RPC_S_OK) return status;
2431
2432 prepare_async_request(async_data);
2433 ret = HttpSendRequestExW(in_request, &buffers_in, NULL, 0, 0);
2434 status = wait_async_request(async_data, ret, cancel_event);
2435 if (status != RPC_S_OK) return status;
2436
2437 TRACE("sending HTTP connect header to server\n");
2438 hdr = RPCRT4_BuildHttpConnectHeader(FALSE, connection_uuid, in_pipe_uuid, association_uuid);
2439 if (!hdr) return RPC_S_OUT_OF_RESOURCES;
2440 ret = InternetWriteFile(in_request, hdr, hdr->common.frag_len, &bytes_written);
2442 if (!ret)
2443 {
2444 ERR("InternetWriteFile failed with error %d\n", GetLastError());
2446 }
2447
2448 return RPC_S_OK;
2449}
BOOL WINAPI HttpSendRequestExW(HINTERNET hRequest, LPINTERNET_BUFFERSW lpBuffersIn, LPINTERNET_BUFFERSW lpBuffersOut, DWORD dwFlags, DWORD_PTR dwContext)
Definition: http.c:5500
char hdr[14]
Definition: iptest.cpp:33
RpcPktHdr * RPCRT4_BuildHttpConnectHeader(int out_pipe, const UUID *connection_uuid, const UUID *pipe_uuid, const UUID *association_uuid)
Definition: rpc_message.c:344
static RPC_STATUS insert_content_length_header(HINTERNET request, DWORD len)
static RPC_STATUS send_echo_request(HINTERNET req, RpcHttpAsyncData *async_data, HANDLE cancel_event)
DWORD dwBufferTotal
Definition: wininet.h:279
DWORD dwStructSize
Definition: wininet.h:272

Referenced by rpcrt4_ncacn_http_open().

◆ rpcrt4_http_prepare_out_pipe()

static RPC_STATUS rpcrt4_http_prepare_out_pipe ( HINTERNET  out_request,
RpcHttpAsyncData async_data,
HANDLE  cancel_event,
const UUID connection_uuid,
const UUID out_pipe_uuid,
ULONG flow_control_increment,
BOOL  authorized 
)
static

Definition at line 2496 of file rpc_transport.c.

2500{
2501 BOOL ret;
2503 RpcPktHdr *hdr;
2504 BYTE *data_from_server;
2505 RpcPktHdr pkt_from_server;
2506 ULONG field1, field3;
2507 BYTE buf[20];
2508
2509 if (!authorized)
2510 {
2511 /* ask wininet to authorize, if necessary */
2512 status = send_echo_request(out_request, async_data, cancel_event);
2513 if (status != RPC_S_OK) return status;
2514 }
2515 else
2516 rpcrt4_http_async_read(out_request, async_data, cancel_event, buf, sizeof(buf));
2517
2518 hdr = RPCRT4_BuildHttpConnectHeader(TRUE, connection_uuid, out_pipe_uuid, NULL);
2519 if (!hdr) return RPC_S_OUT_OF_RESOURCES;
2520
2521 status = insert_content_length_header(out_request, hdr->common.frag_len);
2522 if (status != RPC_S_OK)
2523 {
2525 return status;
2526 }
2527
2528 TRACE("sending HTTP connect header to server\n");
2529 prepare_async_request(async_data);
2530 ret = HttpSendRequestW(out_request, NULL, 0, hdr, hdr->common.frag_len);
2531 status = wait_async_request(async_data, ret, cancel_event);
2533 if (status != RPC_S_OK) return status;
2534
2535 status = rpcrt4_http_check_response(out_request);
2536 if (status != RPC_S_OK) return status;
2537
2538 status = rpcrt4_http_read_http_packet(out_request, async_data, cancel_event,
2539 &pkt_from_server, &data_from_server);
2540 if (status != RPC_S_OK) return status;
2541 status = RPCRT4_ParseHttpPrepareHeader1(&pkt_from_server, data_from_server,
2542 &field1);
2543 HeapFree(GetProcessHeap(), 0, data_from_server);
2544 if (status != RPC_S_OK) return status;
2545 TRACE("received (%d) from first prepare header\n", field1);
2546
2547 for (;;)
2548 {
2549 status = rpcrt4_http_read_http_packet(out_request, async_data, cancel_event,
2550 &pkt_from_server, &data_from_server);
2551 if (status != RPC_S_OK) return status;
2552 if (pkt_from_server.http.flags != 0x0001) break;
2553
2554 TRACE("http idle packet, waiting for real packet\n");
2555 HeapFree(GetProcessHeap(), 0, data_from_server);
2556 if (pkt_from_server.http.num_data_items != 0)
2557 {
2558 ERR("HTTP idle packet should have no data items instead of %d\n",
2559 pkt_from_server.http.num_data_items);
2560 return RPC_S_PROTOCOL_ERROR;
2561 }
2562 }
2563 status = RPCRT4_ParseHttpPrepareHeader2(&pkt_from_server, data_from_server,
2564 &field1, flow_control_increment,
2565 &field3);
2566 HeapFree(GetProcessHeap(), 0, data_from_server);
2567 if (status != RPC_S_OK) return status;
2568 TRACE("received (0x%08x 0x%08x %d) from second prepare header\n", field1, *flow_control_increment, field3);
2569
2570 return RPC_S_OK;
2571}
RPC_STATUS RPCRT4_ParseHttpPrepareHeader2(RpcPktHdr *header, unsigned char *data, ULONG *field1, ULONG *bytes_until_next_packet, ULONG *field3)
Definition: rpc_message.c:591
RPC_STATUS RPCRT4_ParseHttpPrepareHeader1(RpcPktHdr *header, unsigned char *data, ULONG *field1)
Definition: rpc_message.c:566
static RPC_STATUS rpcrt4_http_read_http_packet(HINTERNET request, RpcHttpAsyncData *async_data, HANDLE cancel_event, RpcPktHdr *hdr, BYTE **data)
unsigned short num_data_items
Definition: rpc_defs.h:139
unsigned short flags
Definition: rpc_defs.h:138
RpcPktHttpHdr http
Definition: rpc_defs.h:159
#define RPC_S_PROTOCOL_ERROR
Definition: winerror.h:1039
unsigned char BYTE
Definition: xxhash.c:193

Referenced by rpcrt4_ncacn_http_open().

◆ rpcrt4_http_read_http_packet()

static RPC_STATUS rpcrt4_http_read_http_packet ( HINTERNET  request,
RpcHttpAsyncData async_data,
HANDLE  cancel_event,
RpcPktHdr hdr,
BYTE **  data 
)
static

Definition at line 2451 of file rpc_transport.c.

2453{
2454 unsigned short data_len;
2455 unsigned int size;
2456
2457 if (rpcrt4_http_async_read(request, async_data, cancel_event, hdr, sizeof(hdr->common)) < 0)
2459 if (hdr->common.ptype != PKT_HTTP || hdr->common.frag_len < sizeof(hdr->http))
2460 {
2461 ERR("wrong packet type received %d or wrong frag_len %d\n",
2462 hdr->common.ptype, hdr->common.frag_len);
2463 return RPC_S_PROTOCOL_ERROR;
2464 }
2465
2466 size = sizeof(hdr->http) - sizeof(hdr->common);
2467 if (rpcrt4_http_async_read(request, async_data, cancel_event, &hdr->common + 1, size) < 0)
2469
2470 data_len = hdr->common.frag_len - sizeof(hdr->http);
2471 if (data_len)
2472 {
2473 *data = HeapAlloc(GetProcessHeap(), 0, data_len);
2474 if (!*data)
2476 if (rpcrt4_http_async_read(request, async_data, cancel_event, *data, data_len) < 0)
2477 {
2480 }
2481 }
2482 else
2483 *data = NULL;
2484
2485 if (!RPCRT4_IsValidHttpPacket(hdr, *data, data_len))
2486 {
2487 ERR("invalid http packet\n");
2489 return RPC_S_PROTOCOL_ERROR;
2490 }
2491
2492 return RPC_S_OK;
2493}
@ PKT_HTTP
Definition: rpc_defs.h:208
BOOL RPCRT4_IsValidHttpPacket(RpcPktHdr *hdr, unsigned char *data, unsigned short data_len)
Definition: rpc_message.c:483

Referenced by rpcrt4_http_prepare_out_pipe().

◆ rpcrt4_http_timer_calc_timeout()

static DWORD rpcrt4_http_timer_calc_timeout ( DWORD last_sent_time)
inlinestatic

Definition at line 2120 of file rpc_transport.c.

2121{
2123 DWORD cached_last_sent_time = *last_sent_time;
2124 return HTTP_IDLE_TIME - (cur_time - cached_last_sent_time > HTTP_IDLE_TIME ? 0 : cur_time - cached_last_sent_time);
2125}
time_t cur_time
DWORD WINAPI GetTickCount(VOID)
Definition: time.c:455
#define HTTP_IDLE_TIME

Referenced by rpcrt4_http_timer_thread().

◆ rpcrt4_http_timer_thread()

static DWORD CALLBACK rpcrt4_http_timer_thread ( PVOID  param)
static

Definition at line 2127 of file rpc_transport.c.

2128{
2129 HttpTimerThreadData *data_in = param;
2131 DWORD timeout;
2132
2133 data = *data_in;
2134 HeapFree(GetProcessHeap(), 0, data_in);
2135
2136 for (timeout = HTTP_IDLE_TIME;
2137 WaitForSingleObject(data.timer_cancelled, timeout) == WAIT_TIMEOUT;
2139 {
2140 /* are we too soon after last send? */
2141 if (GetTickCount() - *data.last_sent_time < HTTP_IDLE_TIME)
2142 continue;
2144 }
2145
2146 CloseHandle(data.timer_cancelled);
2147 return 0;
2148}
#define WAIT_TIMEOUT
Definition: dderror.h:14
static DWORD rpcrt4_http_timer_calc_timeout(DWORD *last_sent_time)
static VOID rpcrt4_http_keep_connection_active_timer_proc(PVOID param, BOOLEAN dummy)
Definition: dhcpd.h:245

Referenced by rpcrt4_ncacn_http_open().

◆ rpcrt4_ip_tcp_get_top_of_tower()

static size_t rpcrt4_ip_tcp_get_top_of_tower ( unsigned char tower_data,
const char networkaddr,
unsigned char  tcp_protid,
const char endpoint 
)
static

Definition at line 1220 of file rpc_transport.c.

1224{
1225 twr_tcp_floor_t *tcp_floor;
1226 twr_ipv4_floor_t *ipv4_floor;
1227 struct addrinfo *ai;
1228 struct addrinfo hints;
1229 int ret;
1230 size_t size = sizeof(*tcp_floor) + sizeof(*ipv4_floor);
1231
1232 TRACE("(%p, %s, %s)\n", tower_data, networkaddr, endpoint);
1233
1234 if (!tower_data)
1235 return size;
1236
1237 tcp_floor = (twr_tcp_floor_t *)tower_data;
1238 tower_data += sizeof(*tcp_floor);
1239
1240 ipv4_floor = (twr_ipv4_floor_t *)tower_data;
1241
1242 tcp_floor->count_lhs = sizeof(tcp_floor->protid);
1243 tcp_floor->protid = tcp_protid;
1244 tcp_floor->count_rhs = sizeof(tcp_floor->port);
1245
1246 ipv4_floor->count_lhs = sizeof(ipv4_floor->protid);
1247 ipv4_floor->protid = EPM_PROTOCOL_IP;
1248 ipv4_floor->count_rhs = sizeof(ipv4_floor->ipv4addr);
1249
1250 hints.ai_flags = AI_NUMERICHOST;
1251 /* FIXME: only support IPv4 at the moment. how is IPv6 represented by the EPM? */
1252 hints.ai_family = PF_INET;
1253 hints.ai_socktype = SOCK_STREAM;
1254 hints.ai_protocol = IPPROTO_TCP;
1255 hints.ai_addrlen = 0;
1256 hints.ai_addr = NULL;
1257 hints.ai_canonname = NULL;
1258 hints.ai_next = NULL;
1259
1260#ifdef __REACTOS__
1261 static BOOL wsa_inited;
1262 if (!wsa_inited)
1263 {
1264 WSADATA wsadata;
1265 WSAStartup(MAKEWORD(2, 2), &wsadata);
1266 /* Note: WSAStartup can be called more than once so we don't bother with
1267 * making accesses to wsa_inited thread-safe */
1268 wsa_inited = TRUE;
1269 }
1270#endif
1271
1272 ret = getaddrinfo(networkaddr, endpoint, &hints, &ai);
1273 if (ret)
1274 {
1275 ret = getaddrinfo("0.0.0.0", endpoint, &hints, &ai);
1276 if (ret)
1277 {
1278 ERR("getaddrinfo failed: %s\n", gai_strerror(ret));
1279 return 0;
1280 }
1281 }
1282
1283 if (ai->ai_family == PF_INET)
1284 {
1285 const struct sockaddr_in *sin = (const struct sockaddr_in *)ai->ai_addr;
1286 tcp_floor->port = sin->sin_port;
1287 ipv4_floor->ipv4addr = sin->sin_addr.s_addr;
1288 }
1289 else
1290 {
1291 ERR("unexpected protocol family %d\n", ai->ai_family);
1292 freeaddrinfo(ai);
1293 return 0;
1294 }
1295
1296 freeaddrinfo(ai);
1297
1298 return size;
1299}
_STLP_DECLSPEC complex< float > _STLP_CALL sin(const complex< float > &)
INT WINAPI WSAStartup(IN WORD wVersionRequested, OUT LPWSADATA lpWSAData)
Definition: startup.c:113
#define IPPROTO_TCP
Definition: ip.h:196
#define SOCK_STREAM
Definition: tcpip.h:118
#define EPM_PROTOCOL_IP
Definition: epm_towers.h:31
namespace GUID const ADDRINFOEXW * hints
Definition: sock.c:80
struct sockaddr * ai_addr
Definition: ws2def.h:671
int ai_family
Definition: ws2def.h:666
u_int16 count_lhs
Definition: epm_towers.h:75
u_int16 count_rhs
Definition: epm_towers.h:77
u_int32 ipv4addr
Definition: epm_towers.h:78
u_int16 count_lhs
Definition: epm_towers.h:67
u_int16 port
Definition: epm_towers.h:70
u_int16 count_rhs
Definition: epm_towers.h:69
#define MAKEWORD(a, b)
Definition: typedefs.h:248
#define PF_INET
Definition: winsock.h:373
#define AI_NUMERICHOST
Definition: ws2def.h:295
#define getaddrinfo
Definition: wspiapi.h:44
#define freeaddrinfo
Definition: wspiapi.h:46

Referenced by rpcrt4_ncacn_http_get_top_of_tower(), and rpcrt4_ncacn_ip_tcp_get_top_of_tower().

◆ rpcrt4_ip_tcp_parse_top_of_tower()

static RPC_STATUS rpcrt4_ip_tcp_parse_top_of_tower ( const unsigned char tower_data,
size_t  tower_size,
char **  networkaddr,
unsigned char  tcp_protid,
char **  endpoint 
)
static

Definition at line 1301 of file rpc_transport.c.

1306{
1307 const twr_tcp_floor_t *tcp_floor = (const twr_tcp_floor_t *)tower_data;
1308 const twr_ipv4_floor_t *ipv4_floor;
1309 struct in_addr in_addr;
1310
1311 TRACE("(%p, %d, %p, %p)\n", tower_data, (int)tower_size, networkaddr, endpoint);
1312
1313 if (tower_size < sizeof(*tcp_floor))
1314 return EPT_S_NOT_REGISTERED;
1315
1316 tower_data += sizeof(*tcp_floor);
1317 tower_size -= sizeof(*tcp_floor);
1318
1319 if (tower_size < sizeof(*ipv4_floor))
1320 return EPT_S_NOT_REGISTERED;
1321
1322 ipv4_floor = (const twr_ipv4_floor_t *)tower_data;
1323
1324 if ((tcp_floor->count_lhs != sizeof(tcp_floor->protid)) ||
1325 (tcp_floor->protid != tcp_protid) ||
1326 (tcp_floor->count_rhs != sizeof(tcp_floor->port)) ||
1327 (ipv4_floor->count_lhs != sizeof(ipv4_floor->protid)) ||
1328 (ipv4_floor->protid != EPM_PROTOCOL_IP) ||
1329 (ipv4_floor->count_rhs != sizeof(ipv4_floor->ipv4addr)))
1330 return EPT_S_NOT_REGISTERED;
1331
1332 if (endpoint)
1333 {
1334 *endpoint = I_RpcAllocate(6 /* sizeof("65535") + 1 */);
1335 if (!*endpoint)
1337 sprintf(*endpoint, "%u", ntohs(tcp_floor->port));
1338 }
1339
1340 if (networkaddr)
1341 {
1342 *networkaddr = I_RpcAllocate(INET_ADDRSTRLEN);
1343 if (!*networkaddr)
1344 {
1345 if (endpoint)
1346 {
1348 *endpoint = NULL;
1349 }
1351 }
1352 in_addr.s_addr = ipv4_floor->ipv4addr;
1353 if (!inet_ntop(AF_INET, &in_addr, *networkaddr, INET_ADDRSTRLEN))
1354 {
1355 ERR("inet_ntop: %u\n", WSAGetLastError());
1356 I_RpcFree(*networkaddr);
1357 *networkaddr = NULL;
1358 if (endpoint)
1359 {
1361 *endpoint = NULL;
1362 }
1363 return EPT_S_NOT_REGISTERED;
1364 }
1365 }
1366
1367 return RPC_S_OK;
1368}
#define AF_INET
Definition: tcpip.h:117
#define ntohs(x)
Definition: module.h:210
#define sprintf(buf, format,...)
Definition: sprintf.c:55
void WINAPI I_RpcFree(void *Object)
Definition: rpcrt4_main.c:724
Definition: tcpip.h:126
u32_t s_addr
Definition: inet.h:45
const char *WSAAPI inet_ntop(int af, const void *src, char *dst, size_t cnt)
Definition: unix_func.c:8
#define EPT_S_NOT_REGISTERED
Definition: winerror.h:1061
#define INET_ADDRSTRLEN
Definition: ws2ipdef.h:131

Referenced by rpcrt4_ncacn_http_parse_top_of_tower(), and rpcrt4_ncacn_ip_tcp_parse_top_of_tower().

◆ RPCRT4_IsServerListening()

RPC_STATUS RPCRT4_IsServerListening ( const char protseq,
const char endpoint 
)

Definition at line 3760 of file rpc_transport.c.

3761{
3762 const struct connection_ops *ops;
3763
3764 ops = rpcrt4_get_conn_protseq_ops(protseq);
3765 if (!ops)
3766 {
3767 FIXME("not supported for protseq %s\n", protseq);
3768 return RPC_S_INVALID_BINDING;
3769 }
3770
3771 return ops->is_server_listening(endpoint);
3772}
RPC_STATUS(* is_server_listening)(const char *endpoint)
Definition: rpc_binding.h:110
#define RPC_S_INVALID_BINDING
Definition: winerror.h:1013

Referenced by RpcMgmtIsServerListening().

◆ rpcrt4_ncacn_http_alloc()

static RpcConnection * rpcrt4_ncacn_http_alloc ( void  )
static

Definition at line 2078 of file rpc_transport.c.

2079{
2080 RpcConnection_http *httpc;
2081 httpc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*httpc));
2082 if (!httpc) return NULL;
2084 if (!httpc->async_data)
2085 {
2086 HeapFree(GetProcessHeap(), 0, httpc);
2087 return NULL;
2088 }
2089 TRACE("async data = %p\n", httpc->async_data);
2091 httpc->async_data->refs = 1;
2094 httpc->async_data->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": RpcHttpAsyncData.cs");
2095 return &httpc->common;
2096}
DWORD_PTR Spare[8/sizeof(DWORD_PTR)]
Definition: winbase.h:887
PCRITICAL_SECTION_DEBUG DebugInfo
Definition: winbase.h:894
CRITICAL_SECTION cs
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:751
#define DWORD_PTR
Definition: treelist.c:76
struct _INTERNET_BUFFERSW INTERNET_BUFFERSW

◆ rpcrt4_ncacn_http_cancel_call()

static void rpcrt4_ncacn_http_cancel_call ( RpcConnection Connection)
static

Definition at line 3423 of file rpc_transport.c.

3424{
3425 RpcConnection_http *httpc = (RpcConnection_http *) Connection;
3426
3427 SetEvent(httpc->cancel_event);
3428}

◆ rpcrt4_ncacn_http_close()

static int rpcrt4_ncacn_http_close ( RpcConnection Connection)
static

Definition at line 3390 of file rpc_transport.c.

3391{
3392 RpcConnection_http *httpc = (RpcConnection_http *) Connection;
3393
3394 TRACE("\n");
3395
3396 SetEvent(httpc->timer_cancelled);
3397 if (httpc->in_request)
3399 httpc->in_request = NULL;
3400 if (httpc->out_request)
3402 httpc->out_request = NULL;
3403 if (httpc->app_info)
3405 httpc->app_info = NULL;
3406 if (httpc->session)
3408 httpc->session = NULL;
3410 if (httpc->cancel_event)
3411 CloseHandle(httpc->cancel_event);
3412 HeapFree(GetProcessHeap(), 0, httpc->servername);
3413 httpc->servername = NULL;
3414
3415 return 0;
3416}
BOOL WINAPI InternetCloseHandle(HINTERNET hInternet)
Definition: internet.c:1414

Referenced by rpcrt4_ncacn_http_close_read().

◆ rpcrt4_ncacn_http_close_read()

static void rpcrt4_ncacn_http_close_read ( RpcConnection conn)
static

Definition at line 3418 of file rpc_transport.c.

3419{
3420 rpcrt4_ncacn_http_close(conn); /* FIXME */
3421}
static int rpcrt4_ncacn_http_close(RpcConnection *Connection)

◆ rpcrt4_ncacn_http_get_top_of_tower()

static size_t rpcrt4_ncacn_http_get_top_of_tower ( unsigned char tower_data,
const char networkaddr,
const char endpoint 
)
static

Definition at line 3449 of file rpc_transport.c.

3452{
3453 return rpcrt4_ip_tcp_get_top_of_tower(tower_data, networkaddr,
3455}
#define EPM_PROTOCOL_HTTP
Definition: epm_towers.h:49
static size_t rpcrt4_ip_tcp_get_top_of_tower(unsigned char *tower_data, const char *networkaddr, unsigned char tcp_protid, const char *endpoint)

◆ rpcrt4_ncacn_http_handoff()

static RPC_STATUS rpcrt4_ncacn_http_handoff ( RpcConnection old_conn,
RpcConnection new_conn 
)
static

Definition at line 3207 of file rpc_transport.c.

3208{
3209 assert(0);
3211}

◆ rpcrt4_ncacn_http_is_server_listening()

static RPC_STATUS rpcrt4_ncacn_http_is_server_listening ( const char endpoint)
static

Definition at line 3430 of file rpc_transport.c.

3431{
3432 FIXME("\n");
3433 return RPC_S_ACCESS_DENIED;
3434}

◆ rpcrt4_ncacn_http_open()

static RPC_STATUS rpcrt4_ncacn_http_open ( RpcConnection Connection)
static

Definition at line 3071 of file rpc_transport.c.

3072{
3073 RpcConnection_http *httpc = (RpcConnection_http *)Connection;
3074 static const WCHAR wszVerbIn[] = {'R','P','C','_','I','N','_','D','A','T','A',0};
3075 static const WCHAR wszVerbOut[] = {'R','P','C','_','O','U','T','_','D','A','T','A',0};
3076 static const WCHAR wszRpcProxyPrefix[] = {'/','r','p','c','/','r','p','c','p','r','o','x','y','.','d','l','l','?',0};
3077 static const WCHAR wszColon[] = {':',0};
3078 static const WCHAR wszAcceptType[] = {'a','p','p','l','i','c','a','t','i','o','n','/','r','p','c',0};
3079 LPCWSTR wszAcceptTypes[] = { wszAcceptType, NULL };
3080 DWORD flags;
3081 WCHAR *url;
3083 BOOL secure, credentials;
3084 HttpTimerThreadData *timer_data;
3085 HANDLE thread;
3086
3087 TRACE("(%s, %s)\n", Connection->NetworkAddr, Connection->Endpoint);
3088
3089 if (Connection->server)
3090 {
3091 ERR("ncacn_http servers not supported yet\n");
3093 }
3094
3095 if (httpc->in_request)
3096 return RPC_S_OK;
3097
3099
3100 UuidCreate(&httpc->connection_uuid);
3101 UuidCreate(&httpc->in_pipe_uuid);
3102 UuidCreate(&httpc->out_pipe_uuid);
3103
3105 if (status != RPC_S_OK)
3106 return status;
3107
3108 url = HeapAlloc(GetProcessHeap(), 0, sizeof(wszRpcProxyPrefix) + (strlen(Connection->NetworkAddr) + 1 + strlen(Connection->Endpoint))*sizeof(WCHAR));
3109 if (!url)
3110 return RPC_S_OUT_OF_MEMORY;
3111 memcpy(url, wszRpcProxyPrefix, sizeof(wszRpcProxyPrefix));
3112 MultiByteToWideChar(CP_ACP, 0, Connection->NetworkAddr, -1, url+ARRAY_SIZE(wszRpcProxyPrefix)-1,
3113 strlen(Connection->NetworkAddr)+1);
3114 lstrcatW(url, wszColon);
3115 MultiByteToWideChar(CP_ACP, 0, Connection->Endpoint, -1, url+lstrlenW(url), strlen(Connection->Endpoint)+1);
3116
3117 secure = is_secure(httpc);
3118 credentials = has_credentials(httpc);
3119
3123 if (credentials) flags |= INTERNET_FLAG_NO_AUTH;
3124
3125 status = set_auth_cookie(httpc, Connection->CookieAuth);
3126 if (status != RPC_S_OK)
3127 {
3129 return status;
3130 }
3131 httpc->in_request = HttpOpenRequestW(httpc->session, wszVerbIn, url, NULL, NULL, wszAcceptTypes,
3132 flags, (DWORD_PTR)httpc->async_data);
3133 if (!httpc->in_request)
3134 {
3135 ERR("HttpOpenRequestW failed with error %d\n", GetLastError());
3138 }
3139
3140 if (credentials)
3141 {
3142 status = authorize_request(httpc, httpc->in_request);
3143 if (status != RPC_S_OK)
3144 {
3146 return status;
3147 }
3149 if (status != RPC_S_OK)
3150 {
3152 return status;
3153 }
3154 drain_content(httpc->in_request, httpc->async_data, httpc->cancel_event);
3155 }
3156
3157 httpc->out_request = HttpOpenRequestW(httpc->session, wszVerbOut, url, NULL, NULL, wszAcceptTypes,
3158 flags, (DWORD_PTR)httpc->async_data);
3160 if (!httpc->out_request)
3161 {
3162 ERR("HttpOpenRequestW failed with error %d\n", GetLastError());
3164 }
3165
3166 if (credentials)
3167 {
3168 status = authorize_request(httpc, httpc->out_request);
3169 if (status != RPC_S_OK)
3170 return status;
3171 }
3172
3174 &httpc->connection_uuid, &httpc->in_pipe_uuid,
3175 &Connection->assoc->http_uuid, credentials);
3176 if (status != RPC_S_OK)
3177 return status;
3178
3180 &httpc->connection_uuid, &httpc->out_pipe_uuid,
3181 &httpc->flow_control_increment, credentials);
3182 if (status != RPC_S_OK)
3183 return status;
3184
3185 httpc->flow_control_mark = httpc->flow_control_increment / 2;
3186 httpc->last_sent_time = GetTickCount();
3188
3189 timer_data = HeapAlloc(GetProcessHeap(), 0, sizeof(*timer_data));
3190 if (!timer_data)
3191 return ERROR_OUTOFMEMORY;
3192 timer_data->timer_param = httpc->in_request;
3193 timer_data->last_sent_time = &httpc->last_sent_time;
3194 timer_data->timer_cancelled = httpc->timer_cancelled;
3195 /* FIXME: should use CreateTimerQueueTimer when implemented */
3196 thread = CreateThread(NULL, 0, rpcrt4_http_timer_thread, timer_data, 0, NULL);
3197 if (!thread)
3198 {
3199 HeapFree(GetProcessHeap(), 0, timer_data);
3200 return GetLastError();
3201 }
3203
3204 return RPC_S_OK;
3205}
static HANDLE thread
Definition: service.c:33
#define ERROR_OUTOFMEMORY
Definition: deptool.c:13
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:137
HINTERNET WINAPI HttpOpenRequestW(HINTERNET hHttpSession, LPCWSTR lpszVerb, LPCWSTR lpszObjectName, LPCWSTR lpszVersion, LPCWSTR lpszReferrer, LPCWSTR *lpszAcceptTypes, DWORD dwFlags, DWORD_PTR dwContext)
Definition: http.c:3469
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274
static const WCHAR url[]
Definition: encode.c:1432
static int secure
Definition: server.c:138
static RPC_STATUS rpcrt4_http_internet_connect(RpcConnection_http *httpc)
static RPC_STATUS rpcrt4_http_prepare_out_pipe(HINTERNET out_request, RpcHttpAsyncData *async_data, HANDLE cancel_event, const UUID *connection_uuid, const UUID *out_pipe_uuid, ULONG *flow_control_increment, BOOL authorized)
static BOOL is_secure(RpcConnection_http *httpc)
static RPC_STATUS rpcrt4_http_prepare_in_pipe(HINTERNET in_request, RpcHttpAsyncData *async_data, HANDLE cancel_event, const UUID *connection_uuid, const UUID *in_pipe_uuid, const UUID *association_uuid, BOOL authorized)
static RPC_STATUS authorize_request(RpcConnection_http *httpc, HINTERNET request)
static DWORD CALLBACK rpcrt4_http_timer_thread(PVOID param)
static BOOL has_credentials(RpcConnection_http *httpc)
static RPC_STATUS set_auth_cookie(RpcConnection_http *httpc, const WCHAR *value)
RPC_STATUS WINAPI UuidCreate(UUID *Uuid)
Definition: rpcrt4_main.c:305
struct _RpcAssoc * assoc
Definition: rpc_binding.h:88
uint32_t DWORD_PTR
Definition: typedefs.h:65
#define INTERNET_FLAG_PRAGMA_NOCACHE
Definition: wininet.h:85
#define INTERNET_FLAG_NO_AUTO_REDIRECT
Definition: wininet.h:73
#define INTERNET_FLAG_KEEP_CONNECTION
Definition: wininet.h:72
#define INTERNET_FLAG_NO_CACHE_WRITE
Definition: wininet.h:66
#define INTERNET_FLAG_SECURE
Definition: wininet.h:71
#define INTERNET_FLAG_NO_AUTH
Definition: wininet.h:76
const WCHAR * LPCWSTR
Definition: xmlstorage.h:185

◆ rpcrt4_ncacn_http_parse_top_of_tower()

static RPC_STATUS rpcrt4_ncacn_http_parse_top_of_tower ( const unsigned char tower_data,
size_t  tower_size,
char **  networkaddr,
char **  endpoint 
)
static

Definition at line 3457 of file rpc_transport.c.

3461{
3462 return rpcrt4_ip_tcp_parse_top_of_tower(tower_data, tower_size,
3463 networkaddr, EPM_PROTOCOL_HTTP,
3464 endpoint);
3465}
static RPC_STATUS rpcrt4_ip_tcp_parse_top_of_tower(const unsigned char *tower_data, size_t tower_size, char **networkaddr, unsigned char tcp_protid, char **endpoint)

◆ rpcrt4_ncacn_http_read()

static int rpcrt4_ncacn_http_read ( RpcConnection Connection,
void buffer,
unsigned int  count 
)
static

Definition at line 3213 of file rpc_transport.c.

3215{
3216 RpcConnection_http *httpc = (RpcConnection_http *) Connection;
3217 return rpcrt4_http_async_read(httpc->out_request, httpc->async_data, httpc->cancel_event, buffer, count);
3218}

Referenced by rpcrt4_ncacn_http_receive_fragment().

◆ rpcrt4_ncacn_http_receive_fragment()

static RPC_STATUS rpcrt4_ncacn_http_receive_fragment ( RpcConnection Connection,
RpcPktHdr **  Header,
void **  Payload 
)
static

Definition at line 3220 of file rpc_transport.c.

3221{
3222 RpcConnection_http *httpc = (RpcConnection_http *) Connection;
3224 DWORD hdr_length;
3225 LONG dwRead;
3226 RpcPktCommonHdr common_hdr;
3227
3228 *Header = NULL;
3229
3230 TRACE("(%p, %p, %p)\n", Connection, Header, Payload);
3231
3232again:
3233 /* read packet common header */
3234 dwRead = rpcrt4_ncacn_http_read(Connection, &common_hdr, sizeof(common_hdr));
3235 if (dwRead != sizeof(common_hdr)) {
3236 WARN("Short read of header, %d bytes\n", dwRead);
3238 goto fail;
3239 }
3240 if (!memcmp(&common_hdr, "HTTP/1.1", sizeof("HTTP/1.1")) ||
3241 !memcmp(&common_hdr, "HTTP/1.0", sizeof("HTTP/1.0")))
3242 {
3243 FIXME("server returned %s\n", debugstr_a((const char *)&common_hdr));
3245 goto fail;
3246 }
3247
3248 status = RPCRT4_ValidateCommonHeader(&common_hdr);
3249 if (status != RPC_S_OK) goto fail;
3250
3251 hdr_length = RPCRT4_GetHeaderSize((RpcPktHdr*)&common_hdr);
3252 if (hdr_length == 0) {
3253 WARN("header length == 0\n");
3255 goto fail;
3256 }
3257
3258 *Header = HeapAlloc(GetProcessHeap(), 0, hdr_length);
3259 if (!*Header)
3260 {
3262 goto fail;
3263 }
3264 memcpy(*Header, &common_hdr, sizeof(common_hdr));
3265
3266 /* read the rest of packet header */
3267 dwRead = rpcrt4_ncacn_http_read(Connection, &(*Header)->common + 1, hdr_length - sizeof(common_hdr));
3268 if (dwRead != hdr_length - sizeof(common_hdr)) {
3269 WARN("bad header length, %d bytes, hdr_length %d\n", dwRead, hdr_length);
3271 goto fail;
3272 }
3273
3274 if (common_hdr.frag_len - hdr_length)
3275 {
3276 *Payload = HeapAlloc(GetProcessHeap(), 0, common_hdr.frag_len - hdr_length);
3277 if (!*Payload)
3278 {
3280 goto fail;
3281 }
3282
3283 dwRead = rpcrt4_ncacn_http_read(Connection, *Payload, common_hdr.frag_len - hdr_length);
3284 if (dwRead != common_hdr.frag_len - hdr_length)
3285 {
3286 WARN("bad data length, %d/%d\n", dwRead, common_hdr.frag_len - hdr_length);
3288 goto fail;
3289 }
3290 }
3291 else
3292 *Payload = NULL;
3293
3294 if ((*Header)->common.ptype == PKT_HTTP)
3295 {
3296 if (!RPCRT4_IsValidHttpPacket(*Header, *Payload, common_hdr.frag_len - hdr_length))
3297 {
3298 ERR("invalid http packet of length %d bytes\n", (*Header)->common.frag_len);
3300 goto fail;
3301 }
3302 if ((*Header)->http.flags == 0x0001)
3303 {
3304 TRACE("http idle packet, waiting for real packet\n");
3305 if ((*Header)->http.num_data_items != 0)
3306 {
3307 ERR("HTTP idle packet should have no data items instead of %d\n", (*Header)->http.num_data_items);
3309 goto fail;
3310 }
3311 }
3312 else if ((*Header)->http.flags == 0x0002)
3313 {
3314 ULONG bytes_transmitted;
3315 ULONG flow_control_increment;
3316 UUID pipe_uuid;
3318 Connection->server,
3319 &bytes_transmitted,
3320 &flow_control_increment,
3321 &pipe_uuid);
3322 if (status != RPC_S_OK)
3323 goto fail;
3324 TRACE("received http flow control header (0x%x, 0x%x, %s)\n",
3325 bytes_transmitted, flow_control_increment, debugstr_guid(&pipe_uuid));
3326 /* FIXME: do something with parsed data */
3327 }
3328 else
3329 {
3330 FIXME("unrecognised http packet with flags 0x%04x\n", (*Header)->http.flags);
3332 goto fail;
3333 }
3335 *Header = NULL;
3336 HeapFree(GetProcessHeap(), 0, *Payload);
3337 *Payload = NULL;
3338 goto again;
3339 }
3340
3341 /* success */
3342 status = RPC_S_OK;
3343
3344 httpc->bytes_received += common_hdr.frag_len;
3345
3346 TRACE("httpc->bytes_received = 0x%x\n", httpc->bytes_received);
3347
3348 if (httpc->bytes_received > httpc->flow_control_mark)
3349 {
3351 httpc->bytes_received,
3353 &httpc->out_pipe_uuid);
3354 if (hdr)
3355 {
3356 DWORD bytes_written;
3357 BOOL ret2;
3358 TRACE("sending flow control packet at 0x%x\n", httpc->bytes_received);
3359 ret2 = InternetWriteFile(httpc->in_request, hdr, hdr->common.frag_len, &bytes_written);
3361 if (ret2)
3362 httpc->flow_control_mark = httpc->bytes_received + httpc->flow_control_increment / 2;
3363 }
3364 }
3365
3366fail:
3367 if (status != RPC_S_OK) {
3369 *Header = NULL;
3370 HeapFree(GetProcessHeap(), 0, *Payload);
3371 *Payload = NULL;
3372 }
3373 return status;
3374}
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
Definition: Header.h:9
#define debugstr_guid
Definition: kernel32.h:35
#define debugstr_a
Definition: kernel32.h:31
RPC_STATUS RPCRT4_ValidateCommonHeader(const RpcPktCommonHdr *hdr)
Definition: rpc_message.c:1255
RPC_STATUS RPCRT4_ParseHttpFlowControlHeader(RpcPktHdr *header, unsigned char *data, BOOL server, ULONG *bytes_transmitted, ULONG *flow_control_increment, UUID *pipe_uuid)
Definition: rpc_message.c:637
DWORD RPCRT4_GetHeaderSize(const RpcPktHdr *Header)
Definition: rpc_message.c:57
RpcPktHdr * RPCRT4_BuildHttpFlowControlHeader(BOOL server, ULONG bytes_transmitted, ULONG flow_control_increment, const UUID *pipe_uuid)
Definition: rpc_message.c:384
static int rpcrt4_ncacn_http_read(RpcConnection *Connection, void *buffer, unsigned int count)

◆ rpcrt4_ncacn_http_wait_for_incoming_data()

static int rpcrt4_ncacn_http_wait_for_incoming_data ( RpcConnection Connection)
static

Definition at line 3436 of file rpc_transport.c.

3437{
3438 RpcConnection_http *httpc = (RpcConnection_http *) Connection;
3439 BOOL ret;
3441
3446 return status == RPC_S_OK ? 0 : -1;
3447}
BOOL WINAPI InternetQueryDataAvailable(HINTERNET hFile, LPDWORD lpdwNumberOfBytesAvailable, DWORD dwFlags, DWORD_PTR dwContext)
Definition: internet.c:3959

◆ rpcrt4_ncacn_http_write()

static int rpcrt4_ncacn_http_write ( RpcConnection Connection,
const void buffer,
unsigned int  count 
)
static

Definition at line 3376 of file rpc_transport.c.

3378{
3379 RpcConnection_http *httpc = (RpcConnection_http *) Connection;
3380 DWORD bytes_written;
3381 BOOL ret;
3382
3383 httpc->last_sent_time = ~0U; /* disable idle packet sending */
3384 ret = InternetWriteFile(httpc->in_request, buffer, count, &bytes_written);
3385 httpc->last_sent_time = GetTickCount();
3386 TRACE("%p %p %u -> %s\n", httpc->in_request, buffer, count, ret ? "TRUE" : "FALSE");
3387 return ret ? bytes_written : -1;
3388}
#define U(x)
Definition: wordpad.c:45

◆ rpcrt4_ncacn_ip_tcp_get_top_of_tower()

static size_t rpcrt4_ncacn_ip_tcp_get_top_of_tower ( unsigned char tower_data,
const char networkaddr,
const char endpoint 
)
static

Definition at line 1819 of file rpc_transport.c.

1822{
1823 return rpcrt4_ip_tcp_get_top_of_tower(tower_data, networkaddr,
1825}
#define EPM_PROTOCOL_TCP
Definition: epm_towers.h:29

◆ rpcrt4_ncacn_ip_tcp_open()

static RPC_STATUS rpcrt4_ncacn_ip_tcp_open ( RpcConnection Connection)
static

Definition at line 1458 of file rpc_transport.c.

1459{
1460 RpcConnection_tcp *tcpc = (RpcConnection_tcp *) Connection;
1461 int sock;
1462 int ret;
1463 struct addrinfo *ai;
1464 struct addrinfo *ai_cur;
1465 struct addrinfo hints;
1466
1467 TRACE("(%s, %s)\n", Connection->NetworkAddr, Connection->Endpoint);
1468
1469 if (tcpc->sock != -1)
1470 return RPC_S_OK;
1471
1472 hints.ai_flags = 0;
1473 hints.ai_family = PF_UNSPEC;
1474 hints.ai_socktype = SOCK_STREAM;
1475 hints.ai_protocol = IPPROTO_TCP;
1476 hints.ai_addrlen = 0;
1477 hints.ai_addr = NULL;
1478 hints.ai_canonname = NULL;
1479 hints.ai_next = NULL;
1480
1481 ret = getaddrinfo(Connection->NetworkAddr, Connection->Endpoint, &hints, &ai);
1482 if (ret)
1483 {
1484 ERR("getaddrinfo for %s:%s failed: %s\n", Connection->NetworkAddr,
1485 Connection->Endpoint, gai_strerror(ret));
1487 }
1488
1489 for (ai_cur = ai; ai_cur; ai_cur = ai_cur->ai_next)
1490 {
1491 int val;
1492 u_long nonblocking;
1493
1494 if (ai_cur->ai_family != AF_INET && ai_cur->ai_family != AF_INET6)
1495 {
1496 TRACE("skipping non-IP/IPv6 address family\n");
1497 continue;
1498 }
1499
1500 if (TRACE_ON(rpc))
1501 {
1502 char host[256];
1503 char service[256];
1504 getnameinfo(ai_cur->ai_addr, ai_cur->ai_addrlen,
1505 host, sizeof(host), service, sizeof(service),
1507 TRACE("trying %s:%s\n", host, service);
1508 }
1509
1510 sock = socket(ai_cur->ai_family, ai_cur->ai_socktype, ai_cur->ai_protocol);
1511 if (sock == -1)
1512 {
1513 WARN("socket() failed: %u\n", WSAGetLastError());
1514 continue;
1515 }
1516
1517 if (0>connect(sock, ai_cur->ai_addr, ai_cur->ai_addrlen))
1518 {
1519 WARN("connect() failed: %u\n", WSAGetLastError());
1521 continue;
1522 }
1523
1524 /* RPC depends on having minimal latency so disable the Nagle algorithm */
1525 val = 1;
1526 setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val));
1527 nonblocking = 1;
1528 ioctlsocket(sock, FIONBIO, &nonblocking);
1529
1530 tcpc->sock = sock;
1531
1532 freeaddrinfo(ai);
1533 TRACE("connected\n");
1534 return RPC_S_OK;
1535 }
1536
1537 freeaddrinfo(ai);
1538 ERR("couldn't connect to %s:%s\n", Connection->NetworkAddr, Connection->Endpoint);
1540}
#define TRACE_ON(x)
Definition: compat.h:75
GLuint GLfloat * val
Definition: glext.h:7180
INT WSAAPI setsockopt(IN SOCKET s, IN INT level, IN INT optname, IN CONST CHAR FAR *optval, IN INT optlen)
Definition: sockctrl.c:421
SOCKET WSAAPI socket(IN INT af, IN INT type, IN INT protocol)
Definition: socklife.c:143
size_t ai_addrlen
Definition: ws2def.h:669
int ai_socktype
Definition: ws2def.h:667
int ai_protocol
Definition: ws2def.h:668
struct addrinfo * ai_next
Definition: ws2def.h:672
Definition: tcpcore.h:1455
#define TCP_NODELAY
Definition: tcpdef.h:117
char * host
Definition: whois.c:55
#define PF_UNSPEC
Definition: winsock.h:371
#define AF_INET6
Definition: winsock.h:369
#define NI_NUMERICSERV
Definition: ws2def.h:356

◆ rpcrt4_ncacn_ip_tcp_parse_top_of_tower()

static RPC_STATUS rpcrt4_ncacn_ip_tcp_parse_top_of_tower ( const unsigned char tower_data,
size_t  tower_size,
char **  networkaddr,
char **  endpoint 
)
static

Definition at line 1962 of file rpc_transport.c.

1966{
1967 return rpcrt4_ip_tcp_parse_top_of_tower(tower_data, tower_size,
1968 networkaddr, EPM_PROTOCOL_TCP,
1969 endpoint);
1970}

◆ rpcrt4_ncacn_np_get_top_of_tower()

static size_t rpcrt4_ncacn_np_get_top_of_tower ( unsigned char tower_data,
const char networkaddr,
const char endpoint 
)
static

Definition at line 793 of file rpc_transport.c.

796{
797 twr_empty_floor_t *smb_floor;
798 twr_empty_floor_t *nb_floor;
799 size_t size;
800 size_t networkaddr_size;
801 size_t endpoint_size;
802
803 TRACE("(%p, %s, %s)\n", tower_data, networkaddr, endpoint);
804
805 networkaddr_size = networkaddr ? strlen(networkaddr) + 1 : 1;
806 endpoint_size = endpoint ? strlen(endpoint) + 1 : 1;
807 size = sizeof(*smb_floor) + endpoint_size + sizeof(*nb_floor) + networkaddr_size;
808
809 if (!tower_data)
810 return size;
811
812 smb_floor = (twr_empty_floor_t *)tower_data;
813
814 tower_data += sizeof(*smb_floor);
815
816 smb_floor->count_lhs = sizeof(smb_floor->protid);
817 smb_floor->protid = EPM_PROTOCOL_SMB;
818 smb_floor->count_rhs = endpoint_size;
819
820 if (endpoint)
821 memcpy(tower_data, endpoint, endpoint_size);
822 else
823 tower_data[0] = 0;
824 tower_data += endpoint_size;
825
826 nb_floor = (twr_empty_floor_t *)tower_data;
827
828 tower_data += sizeof(*nb_floor);
829
830 nb_floor->count_lhs = sizeof(nb_floor->protid);
831 nb_floor->protid = EPM_PROTOCOL_NETBIOS;
832 nb_floor->count_rhs = networkaddr_size;
833
834 if (networkaddr)
835 memcpy(tower_data, networkaddr, networkaddr_size);
836 else
837 tower_data[0] = 0;
838
839 return size;
840}
#define EPM_PROTOCOL_NETBIOS
Definition: epm_towers.h:39
#define EPM_PROTOCOL_SMB
Definition: epm_towers.h:37
u_int16 count_lhs
Definition: epm_towers.h:83
u_int16 count_rhs
Definition: epm_towers.h:85

◆ rpcrt4_ncacn_np_handoff()

static RPC_STATUS rpcrt4_ncacn_np_handoff ( RpcConnection old_conn,
RpcConnection new_conn 
)
static

Definition at line 617 of file rpc_transport.c.

618{
621
624
625 /* Store the local computer name as the NetworkAddr for ncacn_np as long as
626 * we don't support named pipes over the network. */
627 new_conn->NetworkAddr = HeapAlloc(GetProcessHeap(), 0, len);
628 if (!GetComputerNameA(new_conn->NetworkAddr, &len))
629 {
630 ERR("Failed to retrieve the computer name, error %u\n", GetLastError());
632 }
633
634 return status;
635}
static RPC_STATUS rpcrt4_conn_create_pipe(RpcConnection *conn)
static void rpcrt4_conn_np_handoff(RpcConnection_np *old_npc, RpcConnection_np *new_npc)

◆ rpcrt4_ncacn_np_is_server_listening()

static RPC_STATUS rpcrt4_ncacn_np_is_server_listening ( const char endpoint)
static

Definition at line 642 of file rpc_transport.c.

643{
644 char *pipe_name;
646
647#ifdef __REACTOS__
648 pipe_name = ncacn_pipe_name(NULL, endpoint);
649#else
650 pipe_name = ncacn_pipe_name(endpoint);
651#endif
652 status = is_pipe_listening(pipe_name);
653 I_RpcFree(pipe_name);
654 return status;
655}
static RPC_STATUS is_pipe_listening(const char *pipe_name)
static char * ncacn_pipe_name(const char *endpoint)

◆ rpcrt4_ncacn_np_open()

static RPC_STATUS rpcrt4_ncacn_np_open ( RpcConnection Connection)
static

Definition at line 550 of file rpc_transport.c.

551{
552 RpcConnection_np *npc = (RpcConnection_np *) Connection;
554 LPSTR pname;
555
556 /* already connected? */
557 if (npc->pipe)
558 return RPC_S_OK;
559
560#ifdef __REACTOS__
561 pname = ncacn_pipe_name(Connection->NetworkAddr, Connection->Endpoint);
562#else
563 pname = ncacn_pipe_name(Connection->Endpoint);
564#endif
565 r = rpcrt4_conn_open_pipe(Connection, pname, FALSE);
567
568 return r;
569}
static RPC_STATUS rpcrt4_conn_open_pipe(RpcConnection *Connection, LPCSTR pname, BOOL wait)
char * LPSTR
Definition: xmlstorage.h:182

◆ rpcrt4_ncacn_np_parse_top_of_tower()

static RPC_STATUS rpcrt4_ncacn_np_parse_top_of_tower ( const unsigned char tower_data,
size_t  tower_size,
char **  networkaddr,
char **  endpoint 
)
static

Definition at line 842 of file rpc_transport.c.

846{
847 const twr_empty_floor_t *smb_floor = (const twr_empty_floor_t *)tower_data;
848 const twr_empty_floor_t *nb_floor;
849
850 TRACE("(%p, %d, %p, %p)\n", tower_data, (int)tower_size, networkaddr, endpoint);
851
852 if (tower_size < sizeof(*smb_floor))
854
855 tower_data += sizeof(*smb_floor);
856 tower_size -= sizeof(*smb_floor);
857
858 if ((smb_floor->count_lhs != sizeof(smb_floor->protid)) ||
859 (smb_floor->protid != EPM_PROTOCOL_SMB) ||
860 (smb_floor->count_rhs > tower_size) ||
861 (tower_data[smb_floor->count_rhs - 1] != '\0'))
863
864 if (endpoint)
865 {
866 *endpoint = I_RpcAllocate(smb_floor->count_rhs);
867 if (!*endpoint)
869 memcpy(*endpoint, tower_data, smb_floor->count_rhs);
870 }
871 tower_data += smb_floor->count_rhs;
872 tower_size -= smb_floor->count_rhs;
873
874 if (tower_size < sizeof(*nb_floor))
876
877 nb_floor = (const twr_empty_floor_t *)tower_data;
878
879 tower_data += sizeof(*nb_floor);
880 tower_size -= sizeof(*nb_floor);
881
882 if ((nb_floor->count_lhs != sizeof(nb_floor->protid)) ||
883 (nb_floor->protid != EPM_PROTOCOL_NETBIOS) ||
884 (nb_floor->count_rhs > tower_size) ||
885 (tower_data[nb_floor->count_rhs - 1] != '\0'))
887
888 if (networkaddr)
889 {
890 *networkaddr = I_RpcAllocate(nb_floor->