27 #define WIN32_NO_STATUS 29 #define NONAMELESSUNION 43 #include "wine/winternl.h" 57 #define DEFAULT_NCACN_HTTP_TIMEOUT (60 * 1000) 172 TRACE(
"retrying busy server\n");
175 TRACE(
"connection failed, error=%x\n",
err);
179 TRACE(
"connection failed, error=%x\n",
err);
185 WARN(
"connection failed, error=%x\n",
err);
201 static const char prefix[] =
"\\\\.\\pipe\\lrpc\\";
232 char generated_endpoint[22];
236 static LONG lrpc_nameless_id;
239 snprintf(generated_endpoint,
sizeof(generated_endpoint),
240 "LRPC%08x.%08x", process_id,
id);
267 static const char prefix[] =
"\\\\";
268 static const char local[] =
".";
272 static const char prefix[] =
"\\\\.";
300 strcpy(pipe_name, prefix);
335 char generated_endpoint[26];
339 static LONG np_nameless_id;
342 snprintf(generated_endpoint,
sizeof(generated_endpoint),
343 "\\\\pipe\\\\%08x.%03x", process_id,
id);
390 ERR(
"Failed to retrieve the computer name, error %u\n",
GetLastError());
442 ERR(
"Failed to retrieve the computer name, error %u\n",
GetLastError());
510 if (connection->
pipe)
514 connection->
pipe = 0;
554 const char *networkaddr,
560 size_t networkaddr_size;
561 size_t endpoint_size;
565 networkaddr_size = networkaddr ?
strlen(networkaddr) + 1 : 1;
567 size =
sizeof(*smb_floor) + endpoint_size +
sizeof(*nb_floor) + networkaddr_size;
574 tower_data +=
sizeof(*smb_floor);
584 tower_data += endpoint_size;
588 tower_data +=
sizeof(*nb_floor);
595 memcpy(tower_data, networkaddr, networkaddr_size);
610 TRACE(
"(%p, %d, %p, %p)\n", tower_data, (
int)tower_size, networkaddr,
endpoint);
612 if (tower_size <
sizeof(*smb_floor))
615 tower_data +=
sizeof(*smb_floor);
616 tower_size -=
sizeof(*smb_floor);
621 (tower_data[smb_floor->
count_rhs - 1] !=
'\0'))
634 if (tower_size <
sizeof(*nb_floor))
639 tower_data +=
sizeof(*nb_floor);
640 tower_size -=
sizeof(*nb_floor);
645 (tower_data[nb_floor->
count_rhs - 1] !=
'\0'))
671 TRACE(
"(%p)\n", conn);
680 WARN(
"ImpersonateNamedPipeClient failed with error %u\n",
error);
694 TRACE(
"(%p)\n", conn);
730 HANDLE *objs = prev_array;
778 ERR(
"couldn't allocate objs\n");
802 HANDLE *objs = wait_array;
847 ERR(
"failed to locate connection for handle %p\n", b_handle);
856 const char *networkaddr,
861 size_t endpoint_size;
866 size =
sizeof(*pipe_floor) + endpoint_size;
873 tower_data +=
sizeof(*pipe_floor);
891 TRACE(
"(%p, %d, %p, %p)\n", tower_data, (
int)tower_size, networkaddr,
endpoint);
893 if (tower_size <
sizeof(*pipe_floor))
896 tower_data +=
sizeof(*pipe_floor);
897 tower_size -=
sizeof(*pipe_floor);
902 (tower_data[pipe_floor->
count_rhs - 1] !=
'\0'))
939 unsigned char *stub_data,
unsigned int stub_data_size,
941 unsigned char *auth_value,
unsigned int auth_value_size)
952 TRACE(
"(%p, %p, %p, %p, %p, %p, 0x%x)\n", conn, privs,
953 server_princ_name, authn_level, authn_svc, authz_svc,
flags);
957 FIXME(
"privs not implemented\n");
960 if (server_princ_name)
962 FIXME(
"server_princ_name not implemented\n");
963 *server_princ_name =
NULL;
969 FIXME(
"authorization service not implemented\n");
981 const char *networkaddr,
982 unsigned char tcp_protid,
990 size_t size =
sizeof(*tcp_floor) +
sizeof(*ipv4_floor);
998 tower_data +=
sizeof(*tcp_floor);
1003 tcp_floor->
protid = tcp_protid;
1006 ipv4_floor->count_lhs =
sizeof(ipv4_floor->protid);
1008 ipv4_floor->count_rhs =
sizeof(ipv4_floor->ipv4addr);
1015 hints.ai_addrlen = 0;
1034 tcp_floor->
port =
sin->sin_port;
1035 ipv4_floor->ipv4addr =
sin->sin_addr.s_addr;
1052 unsigned char tcp_protid,
1059 TRACE(
"(%p, %d, %p, %p)\n", tower_data, (
int)tower_size, networkaddr,
endpoint);
1061 if (tower_size <
sizeof(*tcp_floor))
1064 tower_data +=
sizeof(*tcp_floor);
1065 tower_size -=
sizeof(*tcp_floor);
1067 if (tower_size <
sizeof(*ipv4_floor))
1073 (tcp_floor->
protid != tcp_protid) ||
1105 *networkaddr =
NULL;
1128 static BOOL wsa_inited;
1141 ERR(
"event creation failed\n");
1167 ERR(
"WaitForMultipleObjects() failed with error %d\n",
GetLastError());
1186 ERR(
"WaitForMultipleObjects() failed with error %d\n",
GetLastError());
1217 if (tcpc->
sock != -1)
1224 hints.ai_addrlen = 0;
1232 ERR(
"getaddrinfo for %s:%s failed: %s\n", Connection->
NetworkAddr,
1237 for (ai_cur = ai; ai_cur; ai_cur = ai_cur->
ai_next)
1244 TRACE(
"skipping non-IP/IPv6 address family\n");
1253 host,
sizeof(
host), service,
sizeof(service),
1281 TRACE(
"connected\n");
1305 hints.ai_addrlen = 0;
1313 ERR(
"getaddrinfo for port %s failed: %s\n",
endpoint,
1320 for (ai_cur = ai; ai_cur; ai_cur = ai_cur->
ai_next)
1331 TRACE(
"skipping non-IP/IPv6 address family\n");
1339 host,
sizeof(
host), service,
sizeof(service),
1364 sa_len =
sizeof(
sa);
1374 NULL, 0, service,
sizeof(service),
1411 WARN(
"couldn't make socket non-blocking, error %d\n",
ret);
1419 tcpc->common.
protseq = protseq;
1448 ERR(
"Failed to accept a TCP connection: error %d\n",
ret);
1460 ERR(
"Failed to retrieve the IP address, error %d\n",
ret);
1464 TRACE(
"Accepted a new TCP connection from %s\n",
client->common.NetworkAddr);
1473 while (bytes_read !=
count)
1501 int bytes_written = 0;
1502 while (bytes_written !=
count)
1518 return bytes_written;
1527 if (connection->
sock != -1)
1529 connection->
sock = -1;
1545 TRACE(
"%p\n", connection);
1560 TRACE(
"%p\n", Connection);
1568 const char *networkaddr,
1586 static BOOL wsa_inited;
1608 HANDLE *objs = prev_array;
1618 if (conn->
sock != -1)
1629 ERR(
"couldn't allocate objs\n");
1638 if (conn->
sock != -1)
1662 HANDLE *objs = wait_array;
1702 ERR(
"failed to locate connection for handle %p\n", b_handle);
1723 #define HTTP_IDLE_TIME 60000 1747 TRACE(
"destroying async data %p\n",
data);
1750 data->cs.DebugInfo->Spare[0] = 0;
1781 TRACE(
"Cancelled\n");
1786 ERR(
"Async request failed with error %d\n", async_data->
async_result);
1830 if (!httpc)
return NULL;
1862 DWORD bytes_written;
1871 DWORD cached_last_sent_time = *last_sent_time;
1901 DWORD dwInternetStatus,
1902 LPVOID lpvStatusInformation,
1903 DWORD dwStatusInformationLength)
1907 switch (dwInternetStatus)
1910 TRACE(
"INTERNET_STATUS_REQUEST_COMPLETED\n");
1959 static const WCHAR wszUserAgent[] = {
'M',
'S',
'R',
'P',
'C',0};
1997 static const WCHAR wszRpcProxy[] = {
'R',
'p',
'c',
'P',
'r',
'o',
'x',
'y',
'=',0};
1998 static const WCHAR wszHttpProxy[] = {
'H',
't',
't',
'p',
'P',
'r',
'o',
'x',
'y',
'=',0};
2003 const WCHAR *value_end;
2008 value_end = value_start +
lstrlenW(value_start);
2009 for (
p = value_start;
p < value_end;
p++)
2016 TRACE(
"RpcProxy value is %s\n",
debugstr_wn(value_start, value_end-value_start));
2022 const WCHAR *value_end;
2026 value_end = value_start +
lstrlenW(value_start);
2027 TRACE(
"HttpProxy value is %s\n",
debugstr_wn(value_start, value_end-value_start));
2089 unsigned int bytes_left =
count;
2103 TRACE(
"call cancelled\n");
2129 TRACE(
"sending echo request to server\n");
2147 static const WCHAR fmtW[] =
2148 {
'C',
'o',
'n',
't',
'e',
'n',
't',
'-',
'L',
'e',
'n',
'g',
't',
'h',
':',
' ',
'%',
'u',
'\r',
'\n',0};
2158 const UUID *connection_uuid,
const UUID *in_pipe_uuid,
2159 const UUID *association_uuid,
BOOL authorized)
2165 DWORD bytes_written;
2173 memset(&buffers_in, 0,
sizeof(buffers_in));
2185 TRACE(
"sending HTTP connect header to server\n");
2202 unsigned short data_len;
2209 ERR(
"wrong packet type received %d or wrong frag_len %d\n",
2210 hdr->common.ptype,
hdr->common.frag_len);
2214 size =
sizeof(
hdr->http) -
sizeof(
hdr->common);
2218 data_len =
hdr->common.frag_len -
sizeof(
hdr->http);
2235 ERR(
"invalid http packet\n");
2245 HANDLE cancel_event,
const UUID *connection_uuid,
2246 const UUID *out_pipe_uuid,
ULONG *flow_control_increment,
2252 BYTE *data_from_server;
2254 ULONG field1, field3;
2276 TRACE(
"sending HTTP connect header to server\n");
2287 &pkt_from_server, &data_from_server);
2293 TRACE(
"received (%d) from first prepare header\n", field1);
2298 &pkt_from_server, &data_from_server);
2300 if (pkt_from_server.
http.
flags != 0x0001)
break;
2302 TRACE(
"http idle packet, waiting for real packet\n");
2306 ERR(
"HTTP idle packet should have no data items instead of %d\n",
2312 &field1, flow_control_increment,
2316 TRACE(
"received (0x%08x 0x%08x %d) from second prepare header\n", field1, *flow_control_increment, field3);
2323 static const char enc[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
2329 base64[
i++] = enc[(
bin[0] & 0xfc) >> 2];
2330 x = (
bin[0] & 3) << 4;
2335 base64[
i++] = enc[
x];
2340 base64[
i++] = enc[
x | ((
bin[1] & 0xf0) >> 4)];
2341 x = (
bin[1] & 0x0f) << 2;
2346 base64[
i++] = enc[
x];
2350 base64[
i++] = enc[
x | ((
bin[2] & 0xc0) >> 6)];
2353 base64[
i++] = enc[
bin[2] & 0x3f];
2363 if (
c >=
'A' &&
c <=
'Z')
return c -
'A';
2364 if (
c >=
'a' &&
c <=
'z')
return c -
'a' + 26;
2365 if (
c >=
'0' &&
c <=
'9')
return c -
'0' + 52;
2366 if (
c ==
'+')
return 62;
2367 if (
c ==
'/')
return 63;
2374 char c0, c1, c2, c3;
2386 buf[
i + 0] = (c0 << 2) | (c1 >> 4);
2387 buf[
i + 1] = (c1 << 4) | (c2 >> 2);
2388 buf[
i + 2] = (c2 << 6) | c3;
2399 if (
buf)
buf[
i] = (c0 << 2) | (c1 >> 4);
2402 else if (
p[3] ==
'=')
2410 buf[
i + 0] = (c0 << 2) | (c1 >> 4);
2411 buf[
i + 1] = (c1 << 4) | (c2 >> 2);
2424 buf[
i + 0] = (c0 << 2) | (c1 >> 4);
2425 buf[
i + 1] = (c1 << 4) | (c2 >> 2);
2426 buf[
i + 2] = (c2 << 6) | c3;
2524 info->data_len = userlen + passlen + 1;
2531 info->data[userlen] =
':';
2543 static SEC_WCHAR ntlmW[] = {
'N',
'T',
'L',
'M',0},
negotiateW[] = {
'N',
'e',
'g',
'o',
't',
'i',
'a',
't',
'e',0};
2551 WCHAR auth_value[2048];
2579 ERR(
"authentication scheme changed\n");
2589 in_desc.pBuffers = &
in;
2591 p = auth_value + scheme_len;
2600 out.cbBuffer =
info->max_token;
2608 out_desc.pBuffers = &
out;
2612 in.pvBuffer ? &in_desc :
NULL, 0, &
info->ctx, &out_desc,
2619 info->data_len =
out.cbBuffer;
2621 TRACE(
"sending last auth packet\n");
2628 info->data_len =
out.cbBuffer;
2629 TRACE(
"sending next auth packet\n");
2634 ERR(
"InitializeSecurityContextW failed with error 0x%08x\n",
ret);
2658 static const WCHAR authW[] = {
'A',
'u',
't',
'h',
'o',
'r',
'i',
'z',
'a',
't',
'i',
'o',
'n',
':',
' '};
2659 static const WCHAR basicW[] = {
'B',
'a',
's',
'i',
'c',
' '};
2660 static const WCHAR negotiateW[] = {
'N',
'e',
'g',
'o',
't',
'i',
'a',
't',
'e',
' '};
2661 static const WCHAR ntlmW[] = {
'N',
'T',
'L',
'M',
' '};
2663 const WCHAR *scheme_str;
2719 static const WCHAR authW[] = {
'A',
'u',
't',
'h',
'o',
'r',
'i',
'z',
'a',
't',
'i',
'o',
'n',
':',
'\r',
'\n',0};
2762 if (!
id || !
id->User || !
id->Password)
return FALSE;
2777 static WCHAR httpsW[] = {
'h',
't',
't',
'p',
's',0};
2822 static const WCHAR wszVerbIn[] = {
'R',
'P',
'C',
'_',
'I',
'N',
'_',
'D',
'A',
'T',
'A',0};
2823 static const WCHAR wszVerbOut[] = {
'R',
'P',
'C',
'_',
'O',
'U',
'T',
'_',
'D',
'A',
'T',
'A',0};
2824 static const WCHAR wszRpcProxyPrefix[] = {
'/',
'r',
'p',
'c',
'/',
'r',
'p',
'c',
'p',
'r',
'o',
'x',
'y',
'.',
'd',
'l',
'l',
'?',0};
2825 static const WCHAR wszColon[] = {
':',0};
2826 static const WCHAR wszAcceptType[] = {
'a',
'p',
'p',
'l',
'i',
'c',
'a',
't',
'i',
'o',
'n',
'/',
'r',
'p',
'c',0};
2827 LPCWSTR wszAcceptTypes[] = { wszAcceptType,
NULL };
2839 ERR(
"ncacn_http servers not supported yet\n");
2859 memcpy(
url, wszRpcProxyPrefix,
sizeof(wszRpcProxyPrefix));
2923 &Connection->
assoc->http_uuid, credentials);
2978 TRACE(
"(%p, %p, %p)\n", Connection,
Header, Payload);
2983 if (dwRead !=
sizeof(common_hdr)) {
2984 WARN(
"Short read of header, %d bytes\n", dwRead);
2988 if (!
memcmp(&common_hdr,
"HTTP/1.1",
sizeof(
"HTTP/1.1")) ||
2989 !
memcmp(&common_hdr,
"HTTP/1.0",
sizeof(
"HTTP/1.0")))
3000 if (hdr_length == 0) {
3001 WARN(
"header length == 0\n");
3016 if (dwRead != hdr_length -
sizeof(common_hdr)) {
3017 WARN(
"bad header length, %d bytes, hdr_length %d\n", dwRead, hdr_length);
3022 if (common_hdr.frag_len - hdr_length)
3032 if (dwRead != common_hdr.frag_len - hdr_length)
3034 WARN(
"bad data length, %d/%d\n", dwRead, common_hdr.frag_len - hdr_length);
3042 if ((*Header)->common.ptype ==
PKT_HTTP)
3046 ERR(
"invalid http packet of length %d bytes\n", (*Header)->common.frag_len);
3050 if ((*Header)->http.flags == 0x0001)
3052 TRACE(
"http idle packet, waiting for real packet\n");
3053 if ((*Header)->http.num_data_items != 0)
3055 ERR(
"HTTP idle packet should have no data items instead of %d\n", (*Header)->http.num_data_items);
3060 else if ((*Header)->http.flags == 0x0002)
3062 ULONG bytes_transmitted;
3063 ULONG flow_control_increment;
3068 &flow_control_increment,
3072 TRACE(
"received http flow control header (0x%x, 0x%x, %s)\n",
3073 bytes_transmitted, flow_control_increment,
debugstr_guid(&pipe_uuid));
3078 FIXME(
"unrecognised http packet with flags 0x%04x\n", (*Header)->http.flags);
3104 DWORD bytes_written;
3128 DWORD bytes_written;
3135 return ret ? bytes_written : -1;
3198 const char *networkaddr,
3360 TRACE(
"(Connection == ^%p)\n", Connection);
3363 return Connection->
ops->open_connection_client(Connection);
3368 TRACE(
"(Connection == ^%p)\n", Connection);
3382 static LONG next_id;
3389 FIXME(
"not supported for protseq %s\n", Protseq);
3393 NewConnection = ops->
alloc();
3394 NewConnection->
ref = 1;
3396 NewConnection->
ops = ops;
3406 NewConnection->
AuthInfo = AuthInfo;
3409 NewConnection->
QOS =
QOS;
3414 TRACE(
"connection: %p\n", NewConnection);
3415 *Connection = NewConnection;
3446 if (connection->
ref > 1)
3461 TRACE(
"%p ref=%u\n", connection,
ref);
3486 TRACE(
"%p ref=%u\n", connection,
ref);
3515 FIXME(
"not supported for protseq %s\n", protseq);
3524 const char *protseq,
3525 const char *networkaddr,
3538 *tower_size =
sizeof(*protocol_floor);
3548 tower_data +=
sizeof(*protocol_floor);
3554 *tower_size +=
sizeof(*protocol_floor);
3571 if (tower_size <
sizeof(*protocol_floor))
3575 tower_data +=
sizeof(*protocol_floor);
3576 tower_size -=
sizeof(*protocol_floor);
3578 (protocol_floor->
count_rhs > tower_size))
3580 tower_data += protocol_floor->
count_rhs;
3581 tower_size -= protocol_floor->
count_rhs;
3584 if ((tower_size <
sizeof(*floor4)) ||
3657 for (
i = 0;
i < (*protseqs)->Count;
i++)
3675 for (
i = 0;
i < (*protseqs)->Count;
i++)
static RPC_STATUS rpcrt4_ncacn_http_parse_top_of_tower(const unsigned char *tower_data, size_t tower_size, char **networkaddr, char **endpoint)
#define HTTP_QUERY_CONTENT_LENGTH
static RPC_STATUS rpcrt4_ncacn_np_is_server_listening(const char *endpoint)
BOOL WINAPI SHIM_OBJ_NAME() GetComputerNameA(LPSTR lpBuffer, LPDWORD lpnSize)
USHORT MaxTransmissionSize
static const WCHAR basicW[]
namespace GUID const ADDRINFOEXW * hints
static void rpcrt4_conn_np_cancel_call(RpcConnection *conn)
static void drain_content(HINTERNET request, RpcHttpAsyncData *async_data, HANDLE cancel_event)
static size_t rpcrt4_ncacn_http_get_top_of_tower(unsigned char *tower_data, const char *networkaddr, const char *endpoint)
struct list protseq_entry
#define INTERNET_FLAG_NO_CACHE_WRITE
static RPC_STATUS send_echo_request(HINTERNET req, RpcHttpAsyncData *async_data, HANDLE cancel_event)
static RPC_STATUS rpcrt4_ncacn_http_is_server_listening(const char *endpoint)
#define PIPE_UNLIMITED_INSTANCES
RPC_STATUS WINAPI RpcNetworkInqProtseqsW(RPC_PROTSEQ_VECTORW **protseqs)
static int rpcrt4_ncacn_http_write(RpcConnection *Connection, const void *buffer, unsigned int count)
static size_t rpcrt4_ncalrpc_get_top_of_tower(unsigned char *tower_data, const char *networkaddr, const char *endpoint)
#define RPC_C_AUTHN_WINNT
#define ERROR_FILE_EXISTS
static int rpcrt4_protseq_sock_wait_for_new_connection(RpcServerProtseq *protseq, unsigned int count, void *wait_array)
static struct authinfo * alloc_authinfo(void)
static int rpcrt4_http_async_read(HINTERNET req, RpcHttpAsyncData *async_data, HANDLE cancel_event, void *buffer, unsigned int count)
static int rpcrt4_conn_close(RpcConnection *Connection)
BOOL WINAPI ImpersonateNamedPipeClient(HANDLE hNamedPipe)
static struct list protseqs
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 HANDLE PIO_APC_ROUTINE PVOID PIO_STATUS_BLOCK ULONG PVOID ULONG PVOID ULONG out_size
static RPC_STATUS rpcrt4_conn_tcp_handoff(RpcConnection *old_conn, RpcConnection *new_conn)
static VOID WINAPI rpcrt4_http_internet_callback(HINTERNET hInternet, DWORD_PTR dwContext, DWORD dwInternetStatus, LPVOID lpvStatusInformation, DWORD dwStatusInformationLength)
static void rpcrt4_protseq_np_signal_state_changed(RpcServerProtseq *protseq)
#define HTTP_QUERY_STATUS_TEXT
static RPC_STATUS rpcrt4_protseq_ncalrpc_open_endpoint(RpcServerProtseq *protseq, const char *endpoint)
#define SECPKG_CRED_OUTBOUND
static const char * rpcrt4_conn_get_name(const RpcConnection *Connection)
static RPC_STATUS rpcrt4_ncalrpc_parse_top_of_tower(const unsigned char *tower_data, size_t tower_size, char **networkaddr, char **endpoint)
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)
void RpcAssoc_ConnectionReleased(RpcAssoc *assoc)
unsigned char * Protseq[1]
static int rpcrt4_conn_np_close(RpcConnection *conn)
static rfbScreenInfoPtr server
SOCKET WSAAPI socket(IN INT af, IN INT type, IN INT protocol)
SEC_WINNT_AUTH_IDENTITY_W * TransportCredentials
static RPC_STATUS rpcrt4_ncacn_http_handoff(RpcConnection *old_conn, RpcConnection *new_conn)
ULONG RpcAuthInfo_Release(RpcAuthInfo *AuthInfo)
static HANDLE get_np_event(RpcConnection_np *connection)
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
static struct object_header ** handles
static RPC_STATUS rpcrt4_conn_np_impersonate_client(RpcConnection *conn)
static DWORD auth_scheme_from_header(const WCHAR *header)
#define WideCharToMultiByte
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)
char * strcat(char *DstString, const char *SrcString)
RPC_STATUS RPCRT4_default_revert_to_self(RpcConnection *conn)
void WINAPI I_RpcFree(void *Object)
static int rpcrt4_conn_tcp_close(RpcConnection *conn)
#define PIPE_TYPE_MESSAGE
static RPC_STATUS rpcrt4_ncacn_np_open(RpcConnection *Connection)
#define RPC_C_HTTP_AUTHN_TARGET_SERVER
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)
RPC_STATUS RPCRT4_ParseHttpPrepareHeader1(RpcPktHdr *header, unsigned char *data, ULONG *field1)
#define RPC_S_NO_CONTEXT_AVAILABLE
ACPI_SIZE strlen(const char *String)
SECURITY_STATUS WINAPI FreeContextBuffer(PVOID pv)
INT WSAAPI bind(IN SOCKET s, IN CONST struct sockaddr *name, IN INT namelen)
unsigned short * Password
BOOL WINAPI RevertToSelf(VOID)
#define SECURITY_IDENTIFICATION
GLdouble GLdouble GLdouble r
static int rpcrt4_conn_np_read(RpcConnection *conn, void *buffer, unsigned int count)
struct _RpcServerProtseq_np RpcServerProtseq_np
RPC_STATUS RpcTransport_ParseTopOfTower(const unsigned char *tower_data, size_t tower_size, char **protseq, char **networkaddr, char **endpoint)
HANDLE WINAPI CreateNamedPipeA(LPCSTR lpName, DWORD dwOpenMode, DWORD dwPipeMode, DWORD nMaxInstances, DWORD nOutBufferSize, DWORD nInBufferSize, DWORD nDefaultTimeOut, LPSECURITY_ATTRIBUTES lpSecurityAttributes)
#define SecIsValidHandle(x)
GLuint GLuint GLsizei count
static RPC_STATUS is_pipe_listening(const char *pipe_name)
#define INTERNET_FLAG_SECURE
VOID RPCRT4_FreeHeader(RpcPktHdr *Header)
static ULONG RpcHttpAsyncData_Release(RpcHttpAsyncData *data)
static int rpcrt4_conn_np_write(RpcConnection *conn, const void *buffer, unsigned int count)
__WINE_SERVER_LIST_INLINE void list_add_head(struct list *list, struct list *elem)
static HANDLE PIO_APC_ROUTINE void PIO_STATUS_BLOCK io_status
_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)
DWORD WINAPI GetTickCount(VOID)
static RPC_STATUS rpcrt4_ncalrpc_np_is_server_listening(const char *endpoint)
void RPCRT4_new_client(RpcConnection *conn)
static RPC_STATUS rpcrt4_ncacn_http_receive_fragment(RpcConnection *Connection, RpcPktHdr **Header, void **Payload)
#define RPC_C_HTTP_AUTHN_SCHEME_BASIC
#define INTERNET_OPEN_TYPE_PROXY
RPC_STATUS RPCRT4_IsServerListening(const char *protseq, const char *endpoint)
#define INVALID_HANDLE_VALUE
void RPCRT4_ReleaseConnection(RpcConnection *connection)
#define RPC_S_SERVER_UNAVAILABLE
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
DWORD WINAPI GetLastError(VOID)
static RPC_STATUS wait_async_request(RpcHttpAsyncData *async_data, BOOL call_ret, HANDLE cancel_event)
GLint GLint GLint GLint GLint x
RPC_STATUS RPCRT4_CloseConnection(RpcConnection *Connection)
BOOL WINAPI InternetCloseHandle(HINTERNET hInternet)
SECURITY_STATUS WINAPI FreeCredentialsHandle(PCredHandle phCredential)
#define RPC_C_IMP_LEVEL_ANONYMOUS
NTSYSCALLAPI NTSTATUS NTAPI NtFsControlFile(HANDLE FileHandle, HANDLE Event, PIO_APC_ROUTINE ApcRoutine, PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG FsControlCode, PVOID InputBuffer, ULONG InputBufferLength, PVOID OutputBuffer, ULONG OutputBufferLength)
struct _RpcServerProtseq_sock RpcServerProtseq_sock
static RpcConnection * rpcrt4_conn_tcp_alloc(void)
RPC_HTTP_TRANSPORT_CREDENTIALS_W * HttpCredentials
#define RPC_C_IMP_LEVEL_IDENTIFY
_Check_return_ long __cdecl wcstol(_In_z_ const wchar_t *_Str, _Out_opt_ _Deref_post_z_ wchar_t **_EndPtr, _In_ int _Radix)
#define NMPWAIT_USE_DEFAULT_WAIT
unsigned short * RPC_WSTR
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
#define RPC_C_IMP_LEVEL_IMPERSONATE
INTERNET_BUFFERSW inet_buffers
#define HTTP_QUERY_WWW_AUTHENTICATE
DWORD WINAPI WaitForMultipleObjects(IN DWORD nCount, IN CONST HANDLE *lpHandles, IN BOOL bWaitAll, IN DWORD dwMilliseconds)
static const struct connection_ops * rpcrt4_get_conn_protseq_ops(const char *protseq)
INT WSAAPI connect(IN SOCKET s, IN CONST struct sockaddr *name, IN INT namelen)
#define ERROR_CANNOT_IMPERSONATE
#define EPM_PROTOCOL_NETBIOS
#define EPM_PROTOCOL_NCACN
const struct connection_ops * ops
RPC_STATUS RPCRT4_OpenClientConnection(RpcConnection *Connection)
GLbitfield GLuint64 timeout
#define ERROR_BAD_NETPATH
DWORD RPCRT4_GetHeaderSize(const RpcPktHdr *Header)
static BOOL rpcrt4_sock_wait_init(RpcConnection_tcp *tcpc)
static HANDLE PIO_APC_ROUTINE PVOID PIO_STATUS_BLOCK ULONG PVOID ULONG PVOID out_buffer
#define RPC_S_INVALID_ENDPOINT_FORMAT
#define INTERNET_DEFAULT_HTTP_PORT
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
static RPC_STATUS rpcrt4_ncalrpc_handoff(RpcConnection *old_conn, RpcConnection *new_conn)
static int rpcrt4_conn_tcp_write(RpcConnection *Connection, const void *buffer, unsigned int count)
struct list conn_pool_entry
static const WCHAR negotiateW[]
#define HTTP_ADDREQ_FLAG_REPLACE
#define RPC_S_ACCESS_DENIED
ULONG AuthenticationTarget
BOOL WINAPI WaitNamedPipeA(LPCSTR lpNamedPipeName, DWORD nTimeOut)
static int rpcrt4_conn_np_wait_for_incoming_data(RpcConnection *conn)
#define EPM_PROTOCOL_PIPE
static void rpcrt4_ncacn_http_cancel_call(RpcConnection *Connection)
struct status_code status_code
#define sprintf(buf, format,...)
static unsigned char * in_buffer
#define SecInvalidateHandle(x)
__WINE_SERVER_LIST_INLINE void list_add_tail(struct list *list, struct list *elem)
GLenum GLuint GLenum GLsizei const GLchar * buf
static const struct protseq_ops protseq_list[]
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
ULONG RpcQualityOfService_Release(RpcQualityOfService *qos)
#define LIST_FOR_EACH_ENTRY(elem, list, type, field)
ULONG flow_control_increment
static void rpcrt4_ncacn_http_close_read(RpcConnection *conn)
void rpcrt4_conn_release_and_wait(RpcConnection *connection)
static size_t rpcrt4_ncacn_np_get_top_of_tower(unsigned char *tower_data, const char *networkaddr, const char *endpoint)
NTSYSAPI ULONG WINAPI RtlNtStatusToDosError(NTSTATUS)
void RPCRT4_strfree(LPSTR src)