}
return E_NOTIMPL;
}
-
-HRESULT WINAPI
-CreateStubFromTypeInfo(ITypeInfo *pTypeInfo, REFIID riid, IUnknown *pUnkServer,
- IRpcStubBuffer **ppStub )
-{
- typedef INT (WINAPI *MessageBoxA)(HWND,LPCSTR,LPCSTR,UINT);
- HMODULE hUser32 = LoadLibraryA("user32");
- MessageBoxA pMessageBoxA = (void *)GetProcAddress(hUser32, "MessageBoxA");
-
- FIXME("%p %s %p %p\n", pTypeInfo, debugstr_guid(riid), pUnkServer, ppStub);
- if (pMessageBoxA)
- {
- pMessageBoxA(NULL,
- "The native implementation of OLEAUT32.DLL cannot be used "
- "with Wine's RPCRT4.DLL. Remove OLEAUT32.DLL and try again.\n",
- "Wine: Unimplemented CreateProxyFromTypeInfo",
- 0x10);
- ExitProcess(1);
- }
- return E_NOTIMPL;
-}
return 1;
}
+#if defined(__i386__)
+
/* The idea here is to replace the first param on the stack
ie. This (which will point to cstdstubbuffer_delegating_t)
with This->stub_buffer.pvServerObject and then jump to the
relevant offset in This->stub_buffer.pvServerObject's vtbl.
*/
-#ifdef __i386__
-
#include "pshpack1.h"
typedef struct {
- BYTE mov1[4]; /* mov 0x4(%esp),%eax 8b 44 24 04 */
- BYTE mov2[3]; /* mov 0x10(%eax),%eax 8b 40 10 */
- BYTE mov3[4]; /* mov %eax,0x4(%esp) 89 44 24 04 */
- BYTE mov4[2]; /* mov (%eax),%eax 8b 00 */
- BYTE mov5[2]; /* jmp *offset(%eax) ff a0 offset */
- DWORD offset;
- BYTE pad[1]; /* nop 90 */
+ DWORD mov1; /* mov 0x4(%esp), %eax 8b 44 24 04 */
+ WORD mov2; /* mov 0x10(%eax), %eax 8b 40 */
+ BYTE sixteen; /* 10 */
+ DWORD mov3; /* mov %eax, 0x4(%esp) 89 44 24 04 */
+ WORD mov4; /* mov (%eax), %eax 8b 00 */
+ WORD mov5; /* mov offset(%eax), %eax 8b 80 */
+ DWORD offset; /* xx xx xx xx */
+ WORD jmp; /* jmp *%eax ff e0 */
+ BYTE pad[3]; /* lea 0x0(%esi), %esi 8d 76 00 */
} vtbl_method_t;
#include "poppack.h"
-static const BYTE opcodes[20] = { 0x8b, 0x44, 0x24, 0x04, 0x8b, 0x40, 0x10, 0x89, 0x44, 0x24, 0x04,
- 0x8b, 0x00, 0xff, 0xa0, 0, 0, 0, 0, 0x90 };
-
-#elif defined(__x86_64__)
-
-#include "pshpack1.h"
-typedef struct
-{
- BYTE mov1[4]; /* movq 0x20(%rcx),%rcx 48 8b 49 20 */
- BYTE mov2[3]; /* movq (%rcx),%rax 48 8b 01 */
- BYTE jmp[2]; /* jmp *offset(%rax) ff a0 offset */
- DWORD offset;
- BYTE pad[3]; /* lea 0x0(%rsi),%rsi 48 8d 36 */
-} vtbl_method_t;
-#include "poppack.h"
-
-static const BYTE opcodes[16] = { 0x48, 0x8b, 0x49, 0x20, 0x48, 0x8b, 0x01,
- 0xff, 0xa0, 0, 0, 0, 0, 0x48, 0x8d, 0x36 };
-#else
-
-#warning You must implement delegated proxies/stubs for your CPU
-typedef struct
-{
- DWORD offset;
-} vtbl_method_t;
-static const BYTE opcodes[1];
-
-#endif
-
#define BLOCK_SIZE 1024
#define MAX_BLOCKS 64 /* 64k methods should be enough for anybody */
for (i = 0; i < BLOCK_SIZE; i++)
{
- memcpy( &block[i], opcodes, sizeof(opcodes) );
- block[i].offset = (BLOCK_SIZE * num + i + 3) * sizeof(void *);
+ block[i].mov1 = 0x0424448b;
+ block[i].mov2 = 0x408b;
+ block[i].sixteen = 0x10;
+ block[i].mov3 = 0x04244489;
+ block[i].mov4 = 0x008b;
+ block[i].mov5 = 0x808b;
+ block[i].offset = (BLOCK_SIZE * num + i + 3) << 2;
+ block[i].jmp = 0xe0ff;
+ block[i].pad[0] = 0x8d;
+ block[i].pad[1] = 0x76;
+ block[i].pad[2] = 0x00;
}
VirtualProtect( block, BLOCK_SIZE * sizeof(*block), PAGE_EXECUTE_READ, NULL );
prev = InterlockedCompareExchangePointer( (void **)&method_blocks[num], block, NULL );
return TRUE;
}
+#else /* __i386__ */
+
+static BOOL fill_delegated_stub_table(IUnknownVtbl *vtbl, DWORD num)
+{
+ ERR("delegated stubs are not supported on this architecture\n");
+ return FALSE;
+}
+
+BOOL fill_delegated_proxy_table(IUnknownVtbl *vtbl, DWORD num)
+{
+ ERR("delegated proxies are not supported on this architecture\n");
+ return FALSE;
+}
+
+#endif /* __i386__ */
+
static IUnknownVtbl *get_delegating_vtbl(DWORD num_methods)
{
IUnknownVtbl *ret;
* - Checks for integer addition overflow in user marshall functions
*/
-#include <assert.h>
#include <stdarg.h>
#include <stdio.h>
#include <string.h>
LITTLE_ENDIAN_UINT32_READ(pchar)
#endif
-static inline void align_length( ULONG *len, unsigned int align )
-{
- *len = (*len + align - 1) & ~(align - 1);
-}
-
-static inline void align_pointer( unsigned char **ptr, unsigned int align )
-{
- ULONG_PTR mask = align - 1;
- *ptr = (unsigned char *)(((ULONG_PTR)*ptr + mask) & ~mask);
-}
-
-static inline void align_pointer_clear( unsigned char **ptr, unsigned int align )
-{
- ULONG_PTR mask = align - 1;
- memset( *ptr, 0, (align - (ULONG_PTR)*ptr) & mask );
- *ptr = (unsigned char *)(((ULONG_PTR)*ptr + mask) & ~mask);
-}
+/* _Align must be the desired alignment,
+ * e.g. ALIGN_LENGTH(len, 4) to align on a dword boundary. */
+#define ALIGNED_LENGTH(_Len, _Align) (((_Len)+(_Align)-1)&~((_Align)-1))
+#define ALIGNED_POINTER(_Ptr, _Align) ((LPVOID)ALIGNED_LENGTH((ULONG_PTR)(_Ptr), _Align))
+#define ALIGN_LENGTH(_Len, _Align) _Len = ALIGNED_LENGTH(_Len, _Align)
+#define ALIGN_POINTER(_Ptr, _Align) _Ptr = ALIGNED_POINTER(_Ptr, _Align)
+#define ALIGN_POINTER_CLEAR(_Ptr, _Align) \
+ do { \
+ memset((_Ptr), 0, ((_Align) - (ULONG_PTR)(_Ptr)) & ((_Align) - 1)); \
+ ALIGN_POINTER(_Ptr, _Align); \
+ } while(0)
#define STD_OVERFLOW_CHECK(_Msg) do { \
TRACE("buffer=%d/%d\n", (ULONG)(_Msg->Buffer - (unsigned char *)_Msg->RpcMsg->Buffer), _Msg->BufferLength); \
static ULONG WINAPI NdrByteCountPointerMemorySize(PMIDL_STUB_MESSAGE, PFORMAT_STRING);
-static unsigned char * ComplexBufferSize(PMIDL_STUB_MESSAGE pStubMsg,
- unsigned char *pMemory,
- PFORMAT_STRING pFormat,
- PFORMAT_STRING pPointer);
-static unsigned char * ComplexMarshall(PMIDL_STUB_MESSAGE pStubMsg,
- unsigned char *pMemory,
- PFORMAT_STRING pFormat,
- PFORMAT_STRING pPointer);
-static unsigned char * ComplexUnmarshall(PMIDL_STUB_MESSAGE pStubMsg,
- unsigned char *pMemory,
- PFORMAT_STRING pFormat,
- PFORMAT_STRING pPointer,
- unsigned char fMustAlloc);
-static ULONG ComplexStructMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
- PFORMAT_STRING pFormat,
- PFORMAT_STRING pPointer);
-static unsigned char * ComplexFree(PMIDL_STUB_MESSAGE pStubMsg,
- unsigned char *pMemory,
- PFORMAT_STRING pFormat,
- PFORMAT_STRING pPointer);
-
const NDR_MARSHALL NdrMarshaller[NDR_TABLE_SIZE] = {
0,
NdrBaseTypeMarshall, NdrBaseTypeMarshall, NdrBaseTypeMarshall,
void *p;
NDR_MEMORY_LIST *mem_list;
- aligned_len = (len + 7) & ~7;
+ aligned_len = ALIGNED_LENGTH(len, 8);
adjusted_len = aligned_len + sizeof(NDR_MEMORY_LIST);
/* check for overflow */
if (adjusted_len < len)
static PFORMAT_STRING ReadConformance(MIDL_STUB_MESSAGE *pStubMsg, PFORMAT_STRING pFormat)
{
- align_pointer(&pStubMsg->Buffer, 4);
+ ALIGN_POINTER(pStubMsg->Buffer, 4);
if (pStubMsg->Buffer + 4 > pStubMsg->BufferEnd)
RpcRaiseException(RPC_X_BAD_STUB_DATA);
pStubMsg->MaxCount = NDR_LOCAL_UINT32_READ(pStubMsg->Buffer);
goto done;
}
- align_pointer(&pStubMsg->Buffer, 4);
+ ALIGN_POINTER(pStubMsg->Buffer, 4);
if (pStubMsg->Buffer + 8 > pStubMsg->BufferEnd)
RpcRaiseException(RPC_X_BAD_STUB_DATA);
pStubMsg->Offset = NDR_LOCAL_UINT32_READ(pStubMsg->Buffer);
/* writes the conformance value to the buffer */
static inline void WriteConformance(MIDL_STUB_MESSAGE *pStubMsg)
{
- align_pointer_clear(&pStubMsg->Buffer, 4);
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, 4);
if (pStubMsg->Buffer + 4 > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
RpcRaiseException(RPC_X_BAD_STUB_DATA);
NDR_LOCAL_UINT32_WRITE(pStubMsg->Buffer, pStubMsg->MaxCount);
/* writes the variance values to the buffer */
static inline void WriteVariance(MIDL_STUB_MESSAGE *pStubMsg)
{
- align_pointer_clear(&pStubMsg->Buffer, 4);
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, 4);
if (pStubMsg->Buffer + 8 > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
RpcRaiseException(RPC_X_BAD_STUB_DATA);
NDR_LOCAL_UINT32_WRITE(pStubMsg->Buffer, pStubMsg->Offset);
/* requests buffer space for the conformance value */
static inline void SizeConformance(MIDL_STUB_MESSAGE *pStubMsg)
{
- align_length(&pStubMsg->BufferLength, 4);
+ ALIGN_LENGTH(pStubMsg->BufferLength, 4);
if (pStubMsg->BufferLength + 4 < pStubMsg->BufferLength)
RpcRaiseException(RPC_X_BAD_STUB_DATA);
pStubMsg->BufferLength += 4;
/* requests buffer space for the variance values */
static inline void SizeVariance(MIDL_STUB_MESSAGE *pStubMsg)
{
- align_length(&pStubMsg->BufferLength, 4);
+ ALIGN_LENGTH(pStubMsg->BufferLength, 4);
if (pStubMsg->BufferLength + 8 < pStubMsg->BufferLength)
RpcRaiseException(RPC_X_BAD_STUB_DATA);
pStubMsg->BufferLength += 8;
static inline PFORMAT_STRING SkipConformance(PMIDL_STUB_MESSAGE pStubMsg,
PFORMAT_STRING pFormat)
{
+ if (IsConformanceOrVariancePresent(pFormat))
+ {
if (pStubMsg->fHasNewCorrDesc)
pFormat += 6;
else
pFormat += 4;
- return pFormat;
-}
-
-static inline PFORMAT_STRING SkipVariance(PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
-{
- return SkipConformance( pStubMsg, pFormat );
+ }
+ return pFormat;
}
/* multiply two numbers together, raising an RPC_S_INVALID_BOUND exception if
}
if (attr & RPC_FC_P_DEREF) {
- align_length(&pStubMsg->MemorySize, sizeof(void*));
+ ALIGN_LENGTH(pStubMsg->MemorySize, sizeof(void*));
pStubMsg->MemorySize += sizeof(void*);
TRACE("deref\n");
}
* the buffer, and shouldn't write any additional pointer data to the wire */
if (*pFormat != RPC_FC_RP)
{
- align_pointer_clear(&pStubMsg->Buffer, 4);
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, 4);
Buffer = pStubMsg->Buffer;
safe_buffer_increment(pStubMsg, 4);
}
* as that is used by embedded pointers which already handle the incrementing
* the buffer, and shouldn't read any additional pointer data from the
* buffer */
- align_pointer(&pStubMsg->Buffer, 4);
+ ALIGN_POINTER(pStubMsg->Buffer, 4);
Buffer = pStubMsg->Buffer;
safe_buffer_increment(pStubMsg, 4);
}
* length, and shouldn't write anything more to the wire */
if (*pFormat != RPC_FC_RP)
{
- align_length(&pStubMsg->BufferLength, 4);
+ ALIGN_LENGTH(pStubMsg->BufferLength, 4);
safe_buffer_length_increment(pStubMsg, 4);
}
unsigned char *Buffer = pStubMsg->Buffer;
if (*pFormat != RPC_FC_RP)
{
- align_pointer(&pStubMsg->Buffer, 4);
+ ALIGN_POINTER(pStubMsg->Buffer, 4);
safe_buffer_increment(pStubMsg, 4);
}
- align_length(&pStubMsg->MemorySize, sizeof(void *));
+ ALIGN_LENGTH(pStubMsg->MemorySize, sizeof(void *));
return PointerMemorySize(pStubMsg, Buffer, pFormat);
}
unsigned char FormatChar )
{
#define BASE_TYPE_UNMARSHALL(type) \
- align_pointer(&pStubMsg->Buffer, sizeof(type)); \
+ ALIGN_POINTER(pStubMsg->Buffer, sizeof(type)); \
TRACE("pMemory: %p\n", pMemory); \
*(type *)pMemory = *(type *)pStubMsg->Buffer; \
pStubMsg->Buffer += sizeof(type);
TRACE("value: %s\n", wine_dbgstr_longlong(*(ULONGLONG *)pMemory));
break;
case RPC_FC_ENUM16:
- align_pointer(&pStubMsg->Buffer, sizeof(USHORT));
+ ALIGN_POINTER(pStubMsg->Buffer, sizeof(USHORT));
TRACE("pMemory: %p\n", pMemory);
/* 16-bits on the wire, but int in memory */
*(UINT *)pMemory = *(USHORT *)pStubMsg->Buffer;
pStubMsg->Buffer += sizeof(USHORT);
TRACE("value: 0x%08x\n", *(UINT *)pMemory);
break;
- case RPC_FC_INT3264:
- align_pointer(&pStubMsg->Buffer, sizeof(INT));
- /* 32-bits on the wire, but int_ptr in memory */
- *(INT_PTR *)pMemory = *(INT *)pStubMsg->Buffer;
- pStubMsg->Buffer += sizeof(INT);
- TRACE("value: 0x%08lx\n", *(INT_PTR *)pMemory);
- break;
- case RPC_FC_UINT3264:
- align_pointer(&pStubMsg->Buffer, sizeof(UINT));
- /* 32-bits on the wire, but int_ptr in memory */
- *(UINT_PTR *)pMemory = *(UINT *)pStubMsg->Buffer;
- pStubMsg->Buffer += sizeof(UINT);
- TRACE("value: 0x%08lx\n", *(UINT_PTR *)pMemory);
- break;
case RPC_FC_IGNORE:
break;
default:
unsigned size = *(const WORD*)(pFormat+2);
TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
- align_pointer_clear(&pStubMsg->Buffer, pFormat[1] + 1);
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, pFormat[1] + 1);
pStubMsg->BufferMark = pStubMsg->Buffer;
safe_copy_to_buffer(pStubMsg, pMemory, size);
unsigned char *saved_buffer;
TRACE("(%p,%p,%p,%d)\n", pStubMsg, ppMemory, pFormat, fMustAlloc);
- align_pointer(&pStubMsg->Buffer, pFormat[1] + 1);
+ ALIGN_POINTER(pStubMsg->Buffer, pFormat[1] + 1);
if (fMustAlloc)
*ppMemory = NdrAllocate(pStubMsg, size);
unsigned size = *(const WORD*)(pFormat+2);
TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
- align_length(&pStubMsg->BufferLength, pFormat[1] + 1);
+ ALIGN_LENGTH(pStubMsg->BufferLength, pFormat[1] + 1);
safe_buffer_length_increment(pStubMsg, size);
if (pFormat[0] != RPC_FC_STRUCT)
TRACE("(%p,%p)\n", pStubMsg, pFormat);
- align_pointer(&pStubMsg->Buffer, pFormat[1] + 1);
+ ALIGN_POINTER(pStubMsg->Buffer, pFormat[1] + 1);
pStubMsg->MemorySize += size;
safe_buffer_increment(pStubMsg, size);
unsigned char fc, PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory,
PFORMAT_STRING pFormat)
{
- DWORD count;
-
switch (fc)
{
case RPC_FC_CARRAY:
SizeConformance(pStubMsg);
break;
- case RPC_FC_BOGUS_ARRAY:
- count = *(const WORD *)(pFormat + 2);
- pFormat += 4;
- if (IsConformanceOrVariancePresent(pFormat)) SizeConformance(pStubMsg);
- pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, count);
- pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, pStubMsg->MaxCount);
- break;
default:
ERR("unknown array format 0x%x\n", fc);
RpcRaiseException(RPC_X_BAD_STUB_DATA);
unsigned char fc, PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory,
PFORMAT_STRING pFormat, unsigned char fHasPointers)
{
- DWORD i, size;
+ DWORD size;
DWORD esize;
unsigned char alignment;
pFormat = SkipConformance(pStubMsg, pFormat + 4);
- align_length(&pStubMsg->BufferLength, alignment);
+ ALIGN_LENGTH(pStubMsg->BufferLength, alignment);
size = safe_multiply(esize, pStubMsg->MaxCount);
/* conformance value plus array */
alignment = pFormat[1] + 1;
pFormat = SkipConformance(pStubMsg, pFormat + 4);
- pFormat = SkipVariance(pStubMsg, pFormat);
+ pFormat = SkipConformance(pStubMsg, pFormat);
SizeVariance(pStubMsg);
- align_length(&pStubMsg->BufferLength, alignment);
+ ALIGN_LENGTH(pStubMsg->BufferLength, alignment);
size = safe_multiply(esize, pStubMsg->ActualCount);
safe_buffer_length_increment(pStubMsg, size);
size = safe_multiply(esize, pStubMsg->ActualCount);
safe_buffer_length_increment(pStubMsg, size);
break;
- case RPC_FC_BOGUS_ARRAY:
- alignment = pFormat[1] + 1;
- pFormat = SkipConformance(pStubMsg, pFormat + 4);
- if (IsConformanceOrVariancePresent(pFormat)) SizeVariance(pStubMsg);
- pFormat = SkipVariance(pStubMsg, pFormat);
-
- align_length(&pStubMsg->BufferLength, alignment);
-
- size = pStubMsg->ActualCount;
- for (i = 0; i < size; i++)
- pMemory = ComplexBufferSize(pStubMsg, pMemory, pFormat, NULL);
- break;
default:
ERR("unknown array format 0x%x\n", fc);
RpcRaiseException(RPC_X_BAD_STUB_DATA);
unsigned char fc, PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory,
PFORMAT_STRING pFormat)
{
- ULONG def;
- BOOL conformance_present;
-
switch (fc)
{
case RPC_FC_CARRAY:
pStubMsg->Offset = 0;
WriteConformance(pStubMsg);
break;
- case RPC_FC_BOGUS_ARRAY:
- def = *(const WORD *)(pFormat + 2);
- pFormat += 4;
- conformance_present = IsConformanceOrVariancePresent(pFormat);
- pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, def);
- pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, pStubMsg->MaxCount);
- if (conformance_present) WriteConformance(pStubMsg);
- break;
default:
ERR("unknown array format 0x%x\n", fc);
RpcRaiseException(RPC_X_BAD_STUB_DATA);
unsigned char fc, PMIDL_STUB_MESSAGE pStubMsg, unsigned char *pMemory,
PFORMAT_STRING pFormat, unsigned char fHasPointers)
{
- DWORD i, size;
+ DWORD size;
DWORD esize;
unsigned char alignment;
pFormat = SkipConformance(pStubMsg, pFormat + 4);
- align_pointer_clear(&pStubMsg->Buffer, alignment);
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, alignment);
size = safe_multiply(esize, pStubMsg->MaxCount);
if (fHasPointers)
esize = *(const WORD*)(pFormat+2);
alignment = pFormat[1] + 1;
+ /* conformance */
pFormat = SkipConformance(pStubMsg, pFormat + 4);
- pFormat = SkipVariance(pStubMsg, pFormat);
+ /* variance */
+ pFormat = SkipConformance(pStubMsg, pFormat);
WriteVariance(pStubMsg);
- align_pointer_clear(&pStubMsg->Buffer, alignment);
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, alignment);
size = safe_multiply(esize, pStubMsg->ActualCount);
size = safe_multiply(esize, pStubMsg->ActualCount);
safe_copy_to_buffer(pStubMsg, pMemory, size); /* the string itself */
break;
- case RPC_FC_BOGUS_ARRAY:
- alignment = pFormat[1] + 1;
- pFormat = SkipConformance(pStubMsg, pFormat + 4);
- if (IsConformanceOrVariancePresent(pFormat)) WriteVariance(pStubMsg);
- pFormat = SkipVariance(pStubMsg, pFormat);
-
- align_pointer_clear(&pStubMsg->Buffer, alignment);
-
- size = pStubMsg->ActualCount;
- for (i = 0; i < size; i++)
- pMemory = ComplexMarshall(pStubMsg, pMemory, pFormat, NULL);
- break;
default:
ERR("unknown array format 0x%x\n", fc);
RpcRaiseException(RPC_X_BAD_STUB_DATA);
static inline ULONG array_read_conformance(
unsigned char fc, PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat)
{
- DWORD def, esize;
- unsigned char alignment;
+ DWORD esize;
switch (fc)
{
else
ReadConformance(pStubMsg, NULL);
return safe_multiply(esize, pStubMsg->MaxCount);
- case RPC_FC_BOGUS_ARRAY:
- alignment = pFormat[1] + 1;
- def = *(const WORD *)(pFormat + 2);
- pFormat += 4;
- if (IsConformanceOrVariancePresent(pFormat)) pFormat = ReadConformance(pStubMsg, pFormat);
- else
- {
- pStubMsg->MaxCount = def;
- pFormat = SkipConformance( pStubMsg, pFormat );
- }
- pFormat = SkipVariance( pStubMsg, pFormat );
-
- align_pointer(&pStubMsg->Buffer, alignment);
- esize = ComplexStructSize(pStubMsg, pFormat);
- return safe_multiply(pStubMsg->MaxCount, esize);
default:
ERR("unknown array format 0x%x\n", fc);
RpcRaiseException(RPC_X_BAD_STUB_DATA);
ULONG bufsize, memsize;
WORD esize;
unsigned char alignment;
- unsigned char *saved_buffer, *pMemory;
- ULONG i, offset, count;
+ unsigned char *saved_buffer;
+ ULONG offset;
switch (fc)
{
pFormat = SkipConformance(pStubMsg, pFormat + 4);
- align_pointer(&pStubMsg->Buffer, alignment);
+ ALIGN_POINTER(pStubMsg->Buffer, alignment);
if (fUnmarshall)
{
pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount);
- align_pointer(&pStubMsg->Buffer, alignment);
+ ALIGN_POINTER(pStubMsg->Buffer, alignment);
bufsize = safe_multiply(esize, pStubMsg->ActualCount);
memsize = safe_multiply(esize, pStubMsg->MaxCount);
TRACE("string=%s\n", debugstr_w((LPWSTR)*ppMemory));
}
return bufsize;
-
- case RPC_FC_BOGUS_ARRAY:
- alignment = pFormat[1] + 1;
- pFormat = SkipConformance(pStubMsg, pFormat + 4);
- pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount);
-
- esize = ComplexStructSize(pStubMsg, pFormat);
- memsize = safe_multiply(esize, pStubMsg->MaxCount);
-
- assert( fUnmarshall );
-
- if (!fMustAlloc && !*ppMemory)
- fMustAlloc = TRUE;
- if (fMustAlloc)
- *ppMemory = NdrAllocate(pStubMsg, memsize);
-
- align_pointer(&pStubMsg->Buffer, alignment);
- saved_buffer = pStubMsg->Buffer;
-
- pMemory = *ppMemory;
- count = pStubMsg->ActualCount;
- for (i = 0; i < count; i++)
- pMemory = ComplexUnmarshall(pStubMsg, pMemory, pFormat, NULL, fMustAlloc);
- return pStubMsg->Buffer - saved_buffer;
-
default:
ERR("unknown array format 0x%x\n", fc);
RpcRaiseException(RPC_X_BAD_STUB_DATA);
unsigned char fc, PMIDL_STUB_MESSAGE pStubMsg, PFORMAT_STRING pFormat,
unsigned char fHasPointers)
{
- ULONG i, count, SavedMemorySize;
ULONG bufsize, memsize;
DWORD esize;
unsigned char alignment;
bufsize = memsize = safe_multiply(esize, pStubMsg->MaxCount);
pStubMsg->MemorySize += memsize;
- align_pointer(&pStubMsg->Buffer, alignment);
+ ALIGN_POINTER(pStubMsg->Buffer, alignment);
if (fHasPointers)
pStubMsg->BufferMark = pStubMsg->Buffer;
safe_buffer_increment(pStubMsg, bufsize);
memsize = safe_multiply(esize, pStubMsg->MaxCount);
pStubMsg->MemorySize += memsize;
- align_pointer(&pStubMsg->Buffer, alignment);
+ ALIGN_POINTER(pStubMsg->Buffer, alignment);
if (fHasPointers)
pStubMsg->BufferMark = pStubMsg->Buffer;
safe_buffer_increment(pStubMsg, bufsize);
safe_buffer_increment(pStubMsg, bufsize);
pStubMsg->MemorySize += memsize;
break;
- case RPC_FC_BOGUS_ARRAY:
- alignment = pFormat[1] + 1;
- pFormat = SkipConformance(pStubMsg, pFormat + 4);
- pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount);
-
- align_pointer(&pStubMsg->Buffer, alignment);
-
- SavedMemorySize = pStubMsg->MemorySize;
-
- esize = ComplexStructSize(pStubMsg, pFormat);
- memsize = safe_multiply(pStubMsg->MaxCount, esize);
-
- count = pStubMsg->ActualCount;
- for (i = 0; i < count; i++)
- ComplexStructMemorySize(pStubMsg, pFormat, NULL);
-
- pStubMsg->MemorySize = SavedMemorySize + memsize;
- break;
default:
ERR("unknown array format 0x%x\n", fc);
RpcRaiseException(RPC_X_BAD_STUB_DATA);
unsigned char fc, PMIDL_STUB_MESSAGE pStubMsg,
unsigned char *pMemory, PFORMAT_STRING pFormat, unsigned char fHasPointers)
{
- DWORD i, count;
-
switch (fc)
{
case RPC_FC_CARRAY:
case RPC_FC_C_WSTRING:
/* No embedded pointers so nothing to do */
break;
- case RPC_FC_BOGUS_ARRAY:
- count = *(const WORD *)(pFormat + 2);
- pFormat = ComputeConformance(pStubMsg, pMemory, pFormat + 4, count);
- pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, pStubMsg->MaxCount);
-
- count = pStubMsg->ActualCount;
- for (i = 0; i < count; i++)
- pMemory = ComplexFree(pStubMsg, pMemory, pFormat, NULL);
- break;
default:
ERR("unknown array format 0x%x\n", fc);
RpcRaiseException(RPC_X_BAD_STUB_DATA);
TRACE("(pStubMsg == ^%p, pMemory == ^%p, pFormat == ^%p)\n", pStubMsg, pMemory, pFormat);
- maxsize = *(const USHORT *)&pFormat[2];
+ maxsize = *(USHORT *)&pFormat[2];
if (*pFormat == RPC_FC_CSTRING)
{
- ULONG i = 0;
+ ULONG i;
const char *str = (const char *)pMemory;
- while (i < maxsize && str[i]) i++;
+ for (i = 0; i < maxsize && *str; i++, str++)
+ ;
TRACE("string=%s\n", debugstr_an(str, i));
pStubMsg->ActualCount = i + 1;
esize = 1;
}
else if (*pFormat == RPC_FC_WSTRING)
{
- ULONG i = 0;
+ ULONG i;
const WCHAR *str = (const WCHAR *)pMemory;
- while (i < maxsize && str[i]) i++;
+ for (i = 0; i < maxsize && *str; i++, str++)
+ ;
TRACE("string=%s\n", debugstr_wn(str, i));
pStubMsg->ActualCount = i + 1;
esize = 2;
TRACE("(pStubMsg == ^%p, *pMemory == ^%p, pFormat == ^%p, fMustAlloc == %u)\n",
pStubMsg, *ppMemory, pFormat, fMustAlloc);
- maxsize = *(const USHORT *)&pFormat[2];
+ maxsize = *(USHORT *)&pFormat[2];
ReadVariance(pStubMsg, NULL, maxsize);
if (pStubMsg->Offset)
TRACE("(pStubMsg == ^%p, pMemory == ^%p, pFormat == ^%p)\n", pStubMsg, pMemory, pFormat);
- maxsize = *(const USHORT *)&pFormat[2];
+ maxsize = *(USHORT *)&pFormat[2];
SizeVariance(pStubMsg);
if (*pFormat == RPC_FC_CSTRING)
{
- ULONG i = 0;
+ ULONG i;
const char *str = (const char *)pMemory;
- while (i < maxsize && str[i]) i++;
+ for (i = 0; i < maxsize && *str; i++, str++)
+ ;
TRACE("string=%s\n", debugstr_an(str, i));
pStubMsg->ActualCount = i + 1;
esize = 1;
}
else if (*pFormat == RPC_FC_WSTRING)
{
- ULONG i = 0;
+ ULONG i;
const WCHAR *str = (const WCHAR *)pMemory;
- while (i < maxsize && str[i]) i++;
+ for (i = 0; i < maxsize && *str; i++, str++)
+ ;
TRACE("string=%s\n", debugstr_wn(str, i));
pStubMsg->ActualCount = i + 1;
esize = 2;
TRACE("(pStubMsg == ^%p, pFormat == ^%p)\n", pStubMsg, pFormat);
- maxsize = *(const USHORT *)&pFormat[2];
+ maxsize = *(USHORT *)&pFormat[2];
ReadVariance(pStubMsg, NULL, maxsize);
case RPC_FC_LONG:
case RPC_FC_ULONG:
case RPC_FC_ENUM32:
- case RPC_FC_INT3264:
- case RPC_FC_UINT3264:
return sizeof(ULONG);
case RPC_FC_FLOAT:
return sizeof(float);
pMemory += 2;
break;
case RPC_FC_ENUM16:
- {
- USHORT val = *(DWORD *)pMemory;
TRACE("enum16=%d <= %p\n", *(DWORD*)pMemory, pMemory);
if (32767 < *(DWORD*)pMemory)
RpcRaiseException(RPC_X_ENUM_VALUE_OUT_OF_RANGE);
- safe_copy_to_buffer(pStubMsg, &val, 2);
+ safe_copy_to_buffer(pStubMsg, pMemory, 2);
pMemory += 4;
break;
- }
case RPC_FC_LONG:
case RPC_FC_ULONG:
case RPC_FC_ENUM32:
safe_copy_to_buffer(pStubMsg, pMemory, 4);
pMemory += 4;
break;
- case RPC_FC_INT3264:
- case RPC_FC_UINT3264:
- {
- UINT val = *(UINT_PTR *)pMemory;
- TRACE("int3264=%ld <= %p\n", *(UINT_PTR *)pMemory, pMemory);
- safe_copy_to_buffer(pStubMsg, &val, sizeof(UINT));
- pMemory += sizeof(UINT_PTR);
- break;
- }
case RPC_FC_FLOAT:
TRACE("float=%f <= %p\n", *(float*)pMemory, pMemory);
safe_copy_to_buffer(pStubMsg, pMemory, sizeof(float));
if (*pFormat != RPC_FC_POINTER)
pPointer = pFormat;
if (*pPointer != RPC_FC_RP)
- align_pointer_clear(&pStubMsg->Buffer, 4);
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, 4);
saved_buffer = pStubMsg->Buffer;
if (pStubMsg->PointerBufferMark)
{
break;
}
case RPC_FC_ALIGNM2:
- align_pointer(&pMemory, 2);
+ ALIGN_POINTER(pMemory, 2);
break;
case RPC_FC_ALIGNM4:
- align_pointer(&pMemory, 4);
+ ALIGN_POINTER(pMemory, 4);
break;
case RPC_FC_ALIGNM8:
- align_pointer(&pMemory, 8);
+ ALIGN_POINTER(pMemory, 8);
break;
case RPC_FC_STRUCTPAD1:
case RPC_FC_STRUCTPAD2:
pMemory += 2;
break;
case RPC_FC_ENUM16:
- {
- WORD val;
- safe_copy_from_buffer(pStubMsg, &val, 2);
- *(DWORD*)pMemory = val;
+ safe_copy_from_buffer(pStubMsg, pMemory, 2);
+ *(DWORD*)pMemory &= 0xffff;
TRACE("enum16=%d => %p\n", *(DWORD*)pMemory, pMemory);
if (32767 < *(DWORD*)pMemory)
RpcRaiseException(RPC_X_ENUM_VALUE_OUT_OF_RANGE);
pMemory += 4;
break;
- }
case RPC_FC_LONG:
case RPC_FC_ULONG:
case RPC_FC_ENUM32:
TRACE("long=%d => %p\n", *(DWORD*)pMemory, pMemory);
pMemory += 4;
break;
- case RPC_FC_INT3264:
- {
- INT val;
- safe_copy_from_buffer(pStubMsg, &val, 4);
- *(INT_PTR *)pMemory = val;
- TRACE("int3264=%ld => %p\n", *(INT_PTR*)pMemory, pMemory);
- pMemory += sizeof(INT_PTR);
- break;
- }
- case RPC_FC_UINT3264:
- {
- UINT val;
- safe_copy_from_buffer(pStubMsg, &val, 4);
- *(UINT_PTR *)pMemory = val;
- TRACE("uint3264=%ld => %p\n", *(UINT_PTR*)pMemory, pMemory);
- pMemory += sizeof(UINT_PTR);
- break;
- }
case RPC_FC_FLOAT:
safe_copy_from_buffer(pStubMsg, pMemory, sizeof(float));
TRACE("float=%f => %p\n", *(float*)pMemory, pMemory);
if (*pFormat != RPC_FC_POINTER)
pPointer = pFormat;
if (*pPointer != RPC_FC_RP)
- align_pointer(&pStubMsg->Buffer, 4);
+ ALIGN_POINTER(pStubMsg->Buffer, 4);
saved_buffer = pStubMsg->Buffer;
if (pStubMsg->PointerBufferMark)
{
break;
}
case RPC_FC_ALIGNM2:
- align_pointer_clear(&pMemory, 2);
+ ALIGN_POINTER_CLEAR(pMemory, 2);
break;
case RPC_FC_ALIGNM4:
- align_pointer_clear(&pMemory, 4);
+ ALIGN_POINTER_CLEAR(pMemory, 4);
break;
case RPC_FC_ALIGNM8:
- align_pointer_clear(&pMemory, 8);
+ ALIGN_POINTER_CLEAR(pMemory, 8);
break;
case RPC_FC_STRUCTPAD1:
case RPC_FC_STRUCTPAD2:
safe_buffer_length_increment(pStubMsg, 4);
pMemory += 4;
break;
- case RPC_FC_INT3264:
- case RPC_FC_UINT3264:
- safe_buffer_length_increment(pStubMsg, 4);
- pMemory += sizeof(INT_PTR);
- break;
case RPC_FC_HYPER:
case RPC_FC_DOUBLE:
safe_buffer_length_increment(pStubMsg, 8);
}
if (*pPointer != RPC_FC_RP)
{
- align_length(&pStubMsg->BufferLength, 4);
+ ALIGN_LENGTH(pStubMsg->BufferLength, 4);
safe_buffer_length_increment(pStubMsg, 4);
}
if (*pFormat == RPC_FC_POINTER)
pMemory += sizeof(void*);
break;
case RPC_FC_ALIGNM2:
- align_pointer(&pMemory, 2);
+ ALIGN_POINTER(pMemory, 2);
break;
case RPC_FC_ALIGNM4:
- align_pointer(&pMemory, 4);
+ ALIGN_POINTER(pMemory, 4);
break;
case RPC_FC_ALIGNM8:
- align_pointer(&pMemory, 8);
+ ALIGN_POINTER(pMemory, 8);
break;
case RPC_FC_STRUCTPAD1:
case RPC_FC_STRUCTPAD2:
case RPC_FC_FLOAT:
pMemory += 4;
break;
- case RPC_FC_INT3264:
- case RPC_FC_UINT3264:
- pMemory += sizeof(INT_PTR);
- break;
case RPC_FC_HYPER:
case RPC_FC_DOUBLE:
pMemory += 8;
pMemory += sizeof(void *);
break;
case RPC_FC_ALIGNM2:
- align_pointer(&pMemory, 2);
+ ALIGN_POINTER(pMemory, 2);
break;
case RPC_FC_ALIGNM4:
- align_pointer(&pMemory, 4);
+ ALIGN_POINTER(pMemory, 4);
break;
case RPC_FC_ALIGNM8:
- align_pointer(&pMemory, 8);
+ ALIGN_POINTER(pMemory, 8);
break;
case RPC_FC_STRUCTPAD1:
case RPC_FC_STRUCTPAD2:
size += 4;
safe_buffer_increment(pStubMsg, 4);
break;
- case RPC_FC_INT3264:
- case RPC_FC_UINT3264:
- size += sizeof(INT_PTR);
- safe_buffer_increment(pStubMsg, 4);
- break;
case RPC_FC_HYPER:
case RPC_FC_DOUBLE:
size += 8;
if (*pFormat != RPC_FC_POINTER)
pPointer = pFormat;
if (*pPointer != RPC_FC_RP)
- align_pointer(&pStubMsg->Buffer, 4);
+ ALIGN_POINTER(pStubMsg->Buffer, 4);
saved_buffer = pStubMsg->Buffer;
if (pStubMsg->PointerBufferMark)
{
break;
}
case RPC_FC_ALIGNM2:
- align_length(&size, 2);
+ ALIGN_LENGTH(size, 2);
break;
case RPC_FC_ALIGNM4:
- align_length(&size, 4);
+ ALIGN_LENGTH(size, 4);
break;
case RPC_FC_ALIGNM8:
- align_length(&size, 8);
+ ALIGN_LENGTH(size, 8);
break;
case RPC_FC_STRUCTPAD1:
case RPC_FC_STRUCTPAD2:
case RPC_FC_FLOAT:
size += 4;
break;
- case RPC_FC_INT3264:
- case RPC_FC_UINT3264:
- size += sizeof(INT_PTR);
- break;
case RPC_FC_HYPER:
case RPC_FC_DOUBLE:
size += 8;
pFormat += 4;
break;
case RPC_FC_ALIGNM2:
- align_length(&size, 2);
+ ALIGN_LENGTH(size, 2);
break;
case RPC_FC_ALIGNM4:
- align_length(&size, 4);
+ ALIGN_LENGTH(size, 4);
break;
case RPC_FC_ALIGNM8:
- align_length(&size, 8);
+ ALIGN_LENGTH(size, 8);
break;
case RPC_FC_STRUCTPAD1:
case RPC_FC_STRUCTPAD2:
pStubMsg->BufferLength = saved_buffer_length;
}
- align_pointer_clear(&pStubMsg->Buffer, pFormat[1] + 1);
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, pFormat[1] + 1);
pFormat += 4;
if (*(const SHORT*)pFormat) conf_array = pFormat + *(const SHORT*)pFormat;
pStubMsg->Buffer = saved_buffer;
}
- align_pointer(&pStubMsg->Buffer, pFormat[1] + 1);
+ ALIGN_POINTER(pStubMsg->Buffer, pFormat[1] + 1);
pFormat += 4;
if (*(const SHORT*)pFormat) conf_array = pFormat + *(const SHORT*)pFormat;
TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
- align_length(&pStubMsg->BufferLength, pFormat[1] + 1);
+ ALIGN_LENGTH(pStubMsg->BufferLength, pFormat[1] + 1);
if(!pStubMsg->IgnoreEmbeddedPointers && !pStubMsg->PointerLength)
{
TRACE("(%p,%p)\n", pStubMsg, pFormat);
- align_pointer(&pStubMsg->Buffer, pFormat[1] + 1);
+ ALIGN_POINTER(pStubMsg->Buffer, pFormat[1] + 1);
pFormat += 4;
if (*(const SHORT*)pFormat) conf_array = pFormat + *(const SHORT*)pFormat;
unsigned char *pMemory,
PFORMAT_STRING pFormat)
{
+ ULONG i, count, def;
+ BOOL variance_present;
+ unsigned char alignment;
int pointer_buffer_mark_set = 0;
TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
return NULL;
}
+ alignment = pFormat[1] + 1;
+
if (!pStubMsg->PointerBufferMark)
{
/* save buffer fields that may be changed by buffer sizer functions
pStubMsg->BufferLength = saved_buffer_length;
}
- array_compute_and_write_conformance(RPC_FC_BOGUS_ARRAY, pStubMsg, pMemory, pFormat);
- array_write_variance_and_marshall(RPC_FC_BOGUS_ARRAY, pStubMsg,
- pMemory, pFormat, TRUE /* fHasPointers */);
+ def = *(const WORD*)&pFormat[2];
+ pFormat += 4;
+
+ pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, def);
+ TRACE("conformance = %ld\n", pStubMsg->MaxCount);
+
+ variance_present = IsConformanceOrVariancePresent(pFormat);
+ pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, pStubMsg->MaxCount);
+ TRACE("variance = %d\n", pStubMsg->ActualCount);
+
+ WriteConformance(pStubMsg);
+ if (variance_present)
+ WriteVariance(pStubMsg);
+
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, alignment);
+
+ count = pStubMsg->ActualCount;
+ for (i = 0; i < count; i++)
+ pMemory = ComplexMarshall(pStubMsg, pMemory, pFormat, NULL);
STD_OVERFLOW_CHECK(pStubMsg);
PFORMAT_STRING pFormat,
unsigned char fMustAlloc)
{
+ ULONG i, count, size;
+ unsigned char alignment;
+ unsigned char *pMemory;
unsigned char *saved_buffer;
int pointer_buffer_mark_set = 0;
int saved_ignore_embedded;
return NULL;
}
+ alignment = pFormat[1] + 1;
+
saved_ignore_embedded = pStubMsg->IgnoreEmbeddedPointers;
/* save buffer pointer */
saved_buffer = pStubMsg->Buffer;
pStubMsg->IgnoreEmbeddedPointers = 1;
pStubMsg->MemorySize = 0;
NdrComplexArrayMemorySize(pStubMsg, pFormat);
+ size = pStubMsg->MemorySize;
pStubMsg->IgnoreEmbeddedPointers = saved_ignore_embedded;
TRACE("difference = 0x%x\n", (ULONG)(pStubMsg->Buffer - saved_buffer));
/* restore the original buffer */
pStubMsg->Buffer = saved_buffer;
- array_read_conformance(RPC_FC_BOGUS_ARRAY, pStubMsg, pFormat);
- array_read_variance_and_unmarshall(RPC_FC_BOGUS_ARRAY, pStubMsg, ppMemory, pFormat, fMustAlloc,
- TRUE /* fUseBufferMemoryServer */, TRUE /* fUnmarshall */);
+ pFormat += 4;
+
+ pFormat = ReadConformance(pStubMsg, pFormat);
+ pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount);
+
+ if (!fMustAlloc && !*ppMemory)
+ fMustAlloc = TRUE;
+ if (fMustAlloc)
+ *ppMemory = NdrAllocate(pStubMsg, size);
+
+ ALIGN_POINTER(pStubMsg->Buffer, alignment);
+
+ pMemory = *ppMemory;
+ count = pStubMsg->ActualCount;
+ for (i = 0; i < count; i++)
+ pMemory = ComplexUnmarshall(pStubMsg, pMemory, pFormat, NULL, fMustAlloc);
if (pointer_buffer_mark_set)
{
unsigned char *pMemory,
PFORMAT_STRING pFormat)
{
+ ULONG i, count, def;
+ unsigned char alignment;
+ BOOL variance_present;
int pointer_length_set = 0;
TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
return;
}
+ alignment = pFormat[1] + 1;
+
if (!pStubMsg->IgnoreEmbeddedPointers && !pStubMsg->PointerLength)
{
/* save buffer fields that may be changed by buffer sizer functions
pStubMsg->MaxCount = saved_max_count;
pStubMsg->BufferLength = saved_buffer_length;
}
+ def = *(const WORD*)&pFormat[2];
+ pFormat += 4;
- array_compute_and_size_conformance(RPC_FC_BOGUS_ARRAY, pStubMsg, pMemory, pFormat);
- array_buffer_size(RPC_FC_BOGUS_ARRAY, pStubMsg, pMemory, pFormat, TRUE /* fHasPointers */);
+ pFormat = ComputeConformance(pStubMsg, pMemory, pFormat, def);
+ TRACE("conformance = %ld\n", pStubMsg->MaxCount);
+ SizeConformance(pStubMsg);
+
+ variance_present = IsConformanceOrVariancePresent(pFormat);
+ pFormat = ComputeVariance(pStubMsg, pMemory, pFormat, pStubMsg->MaxCount);
+ TRACE("variance = %d\n", pStubMsg->ActualCount);
+
+ if (variance_present)
+ SizeVariance(pStubMsg);
+
+ ALIGN_LENGTH(pStubMsg->BufferLength, alignment);
+
+ count = pStubMsg->ActualCount;
+ for (i = 0; i < count; i++)
+ pMemory = ComplexBufferSize(pStubMsg, pMemory, pFormat, NULL);
if(pointer_length_set)
{
ULONG WINAPI NdrComplexArrayMemorySize(PMIDL_STUB_MESSAGE pStubMsg,
PFORMAT_STRING pFormat)
{
+ ULONG i, count, esize, SavedMemorySize, MemorySize;
+ unsigned char alignment;
+
TRACE("(%p,%p)\n", pStubMsg, pFormat);
if (pFormat[0] != RPC_FC_BOGUS_ARRAY)
return 0;
}
- array_read_conformance(RPC_FC_BOGUS_ARRAY, pStubMsg, pFormat);
- array_memory_size(RPC_FC_BOGUS_ARRAY, pStubMsg, pFormat, TRUE /* fHasPointers */);
- return pStubMsg->MemorySize;
+ alignment = pFormat[1] + 1;
+
+ pFormat += 4;
+
+ pFormat = ReadConformance(pStubMsg, pFormat);
+ pFormat = ReadVariance(pStubMsg, pFormat, pStubMsg->MaxCount);
+
+ ALIGN_POINTER(pStubMsg->Buffer, alignment);
+
+ SavedMemorySize = pStubMsg->MemorySize;
+
+ esize = ComplexStructSize(pStubMsg, pFormat);
+
+ MemorySize = safe_multiply(pStubMsg->MaxCount, esize);
+
+ count = pStubMsg->ActualCount;
+ for (i = 0; i < count; i++)
+ ComplexStructMemorySize(pStubMsg, pFormat, NULL);
+
+ pStubMsg->MemorySize = SavedMemorySize;
+
+ pStubMsg->MemorySize += MemorySize;
+ return MemorySize;
}
/***********************************************************************
if (flags & USER_MARSHAL_POINTER)
{
- align_pointer_clear(&pStubMsg->Buffer, 4);
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, 4);
NDR_LOCAL_UINT32_WRITE(pStubMsg->Buffer, USER_MARSHAL_PTR_PREFIX);
pStubMsg->Buffer += 4;
if (pStubMsg->PointerBufferMark)
pStubMsg->Buffer = pStubMsg->PointerBufferMark;
pStubMsg->PointerBufferMark = NULL;
}
- align_pointer_clear(&pStubMsg->Buffer, 8);
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, 8);
}
else
- align_pointer_clear(&pStubMsg->Buffer, (flags & 0xf) + 1);
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, (flags & 0xf) + 1);
pStubMsg->Buffer =
pStubMsg->StubDesc->aUserMarshalQuadruple[index].pfnMarshall(
if (flags & USER_MARSHAL_POINTER)
{
- align_pointer(&pStubMsg->Buffer, 4);
+ ALIGN_POINTER(pStubMsg->Buffer, 4);
/* skip pointer prefix */
pStubMsg->Buffer += 4;
if (pStubMsg->PointerBufferMark)
pStubMsg->Buffer = pStubMsg->PointerBufferMark;
pStubMsg->PointerBufferMark = NULL;
}
- align_pointer(&pStubMsg->Buffer, 8);
+ ALIGN_POINTER(pStubMsg->Buffer, 8);
}
else
- align_pointer(&pStubMsg->Buffer, (flags & 0xf) + 1);
+ ALIGN_POINTER(pStubMsg->Buffer, (flags & 0xf) + 1);
if (!fMustAlloc && !*ppMemory)
fMustAlloc = TRUE;
if (flags & USER_MARSHAL_POINTER)
{
- align_length(&pStubMsg->BufferLength, 4);
+ ALIGN_LENGTH(pStubMsg->BufferLength, 4);
/* skip pointer prefix */
safe_buffer_length_increment(pStubMsg, 4);
if (pStubMsg->IgnoreEmbeddedPointers)
pStubMsg->BufferLength = pStubMsg->PointerLength;
pStubMsg->PointerLength = 0;
}
- align_length(&pStubMsg->BufferLength, 8);
+ ALIGN_LENGTH(pStubMsg->BufferLength, 8);
}
else
- align_length(&pStubMsg->BufferLength, (flags & 0xf) + 1);
+ ALIGN_LENGTH(pStubMsg->BufferLength, (flags & 0xf) + 1);
if (bufsize) {
TRACE("size=%d\n", bufsize);
if (flags & USER_MARSHAL_POINTER)
{
- align_pointer(&pStubMsg->Buffer, 4);
+ ALIGN_POINTER(pStubMsg->Buffer, 4);
/* skip pointer prefix */
pStubMsg->Buffer += 4;
if (pStubMsg->IgnoreEmbeddedPointers)
return pStubMsg->MemorySize;
- align_pointer(&pStubMsg->Buffer, 8);
+ ALIGN_POINTER(pStubMsg->Buffer, 8);
}
else
- align_pointer(&pStubMsg->Buffer, (flags & 0xf) + 1);
+ ALIGN_POINTER(pStubMsg->Buffer, (flags & 0xf) + 1);
if (!bufsize)
FIXME("not implemented for varying buffer size\n");
WriteConformance(pStubMsg);
- align_pointer_clear(&pStubMsg->Buffer, pCStructFormat->alignment + 1);
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, pCStructFormat->alignment + 1);
TRACE("memory_size = %d\n", pCStructFormat->memory_size);
pCArrayFormat = ReadConformance(pStubMsg, pCArrayFormat + 4);
- align_pointer(&pStubMsg->Buffer, pCStructFormat->alignment + 1);
+ ALIGN_POINTER(pStubMsg->Buffer, pCStructFormat->alignment + 1);
TRACE("memory_size = %d\n", pCStructFormat->memory_size);
pCArrayFormat = ComputeConformance(pStubMsg, pMemory + pCStructFormat->memory_size, pCArrayFormat+4, 0);
SizeConformance(pStubMsg);
- align_length(&pStubMsg->BufferLength, pCStructFormat->alignment + 1);
+ ALIGN_LENGTH(pStubMsg->BufferLength, pCStructFormat->alignment + 1);
TRACE("memory_size = %d\n", pCStructFormat->memory_size);
pMemory + pCVStructFormat->memory_size,
pCVArrayFormat);
- align_pointer_clear(&pStubMsg->Buffer, pCVStructFormat->alignment + 1);
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, pCVStructFormat->alignment + 1);
TRACE("memory_size = %d\n", pCVStructFormat->memory_size);
memsize = array_read_conformance(*pCVArrayFormat, pStubMsg,
pCVArrayFormat);
- align_pointer(&pStubMsg->Buffer, pCVStructFormat->alignment + 1);
+ ALIGN_POINTER(pStubMsg->Buffer, pCVStructFormat->alignment + 1);
TRACE("memory_size = %d\n", pCVStructFormat->memory_size);
pMemory + pCVStructFormat->memory_size,
pCVArrayFormat);
- align_length(&pStubMsg->BufferLength, pCVStructFormat->alignment + 1);
+ ALIGN_LENGTH(pStubMsg->BufferLength, pCVStructFormat->alignment + 1);
TRACE("memory_size = %d\n", pCVStructFormat->memory_size);
pCVStructFormat->offset_to_array_description;
array_read_conformance(*pCVArrayFormat, pStubMsg, pCVArrayFormat);
- align_pointer(&pStubMsg->Buffer, pCVStructFormat->alignment + 1);
+ ALIGN_POINTER(pStubMsg->Buffer, pCVStructFormat->alignment + 1);
TRACE("memory_size = %d\n", pCVStructFormat->memory_size);
return NULL;
}
- align_pointer_clear(&pStubMsg->Buffer, pSmFArrayFormat->alignment + 1);
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, pSmFArrayFormat->alignment + 1);
if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
{
return NULL;
}
- align_pointer(&pStubMsg->Buffer, pSmFArrayFormat->alignment + 1);
+ ALIGN_POINTER(pStubMsg->Buffer, pSmFArrayFormat->alignment + 1);
if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
{
return;
}
- align_length(&pStubMsg->BufferLength, pSmFArrayFormat->alignment + 1);
+ ALIGN_LENGTH(pStubMsg->BufferLength, pSmFArrayFormat->alignment + 1);
if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
{
return 0;
}
- align_pointer(&pStubMsg->Buffer, pSmFArrayFormat->alignment + 1);
+ ALIGN_POINTER(pStubMsg->Buffer, pSmFArrayFormat->alignment + 1);
if (pSmFArrayFormat->type == RPC_FC_SMFARRAY)
{
WriteVariance(pStubMsg);
- align_pointer_clear(&pStubMsg->Buffer, alignment);
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, alignment);
bufsize = safe_multiply(esize, pStubMsg->ActualCount);
pStubMsg->BufferMark = pStubMsg->Buffer;
pFormat = ReadVariance(pStubMsg, pFormat, elements);
- align_pointer(&pStubMsg->Buffer, alignment);
+ ALIGN_POINTER(pStubMsg->Buffer, alignment);
bufsize = safe_multiply(esize, pStubMsg->ActualCount);
offset = pStubMsg->Offset;
SizeVariance(pStubMsg);
- align_length(&pStubMsg->BufferLength, alignment);
+ ALIGN_LENGTH(pStubMsg->BufferLength, alignment);
safe_buffer_length_increment(pStubMsg, safe_multiply(esize, pStubMsg->ActualCount));
pFormat = ReadVariance(pStubMsg, pFormat, elements);
- align_pointer(&pStubMsg->Buffer, alignment);
+ ALIGN_POINTER(pStubMsg->Buffer, alignment);
safe_buffer_increment(pStubMsg, safe_multiply(esize, pStubMsg->ActualCount));
pStubMsg->MemorySize += size;
case RPC_FC_ULONG:
case RPC_FC_ENUM32:
return *(const ULONG *)pMemory;
- case RPC_FC_INT3264:
- case RPC_FC_UINT3264:
- return *(const ULONG_PTR *)pMemory;
default:
FIXME("Unhandled base type: 0x%02x\n", fc);
return 0;
case RPC_FC_UP:
case RPC_FC_OP:
case RPC_FC_FP:
- align_pointer_clear(&pStubMsg->Buffer, 4);
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, 4);
saved_buffer = pStubMsg->Buffer;
if (pStubMsg->PointerBufferMark)
{
case RPC_FC_UP:
case RPC_FC_OP:
case RPC_FC_FP:
- align_pointer(&pStubMsg->Buffer, 4);
+ ALIGN_POINTER(pStubMsg->Buffer, 4);
saved_buffer = pStubMsg->Buffer;
if (pStubMsg->PointerBufferMark)
{
case RPC_FC_UP:
case RPC_FC_OP:
case RPC_FC_FP:
- align_length(&pStubMsg->BufferLength, 4);
+ ALIGN_LENGTH(pStubMsg->BufferLength, 4);
safe_buffer_length_increment(pStubMsg, 4); /* for pointer ID */
if (!pStubMsg->IgnoreEmbeddedPointers)
{
case RPC_FC_UP:
case RPC_FC_OP:
case RPC_FC_FP:
- align_pointer(&pStubMsg->Buffer, 4);
+ ALIGN_POINTER(pStubMsg->Buffer, 4);
saved_buffer = pStubMsg->Buffer;
safe_buffer_increment(pStubMsg, 4);
- align_length(&pStubMsg->MemorySize, sizeof(void *));
+ ALIGN_LENGTH(pStubMsg->MemorySize, sizeof(void *));
pStubMsg->MemorySize += sizeof(void *);
if (!pStubMsg->IgnoreEmbeddedPointers)
PointerMemorySize(pStubMsg, saved_buffer, pFormat);
increment = (*pFormat & 0xf0) >> 4;
pFormat++;
- align_pointer_clear(&pStubMsg->Buffer, increment);
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, increment);
switch_value = get_discriminant(switch_type, pMemory);
TRACE("got switch value 0x%x\n", switch_value);
increment = (*pFormat & 0xf0) >> 4;
pFormat++;
- align_pointer(&pStubMsg->Buffer, increment);
+ ALIGN_POINTER(pStubMsg->Buffer, increment);
switch_value = get_discriminant(switch_type, pStubMsg->Buffer);
TRACE("got switch value 0x%x\n", switch_value);
increment = (*pFormat & 0xf0) >> 4;
pFormat++;
- align_length(&pStubMsg->BufferLength, increment);
+ ALIGN_LENGTH(pStubMsg->BufferLength, increment);
switch_value = get_discriminant(switch_type, pMemory);
TRACE("got switch value 0x%x\n", switch_value);
increment = (*pFormat & 0xf0) >> 4;
pFormat++;
- align_pointer(&pStubMsg->Buffer, increment);
+ ALIGN_POINTER(pStubMsg->Buffer, increment);
switch_value = get_discriminant(switch_type, pStubMsg->Buffer);
TRACE("got switch value 0x%x\n", switch_value);
case RPC_FC_USHORT:
{
USHORT d;
- align_pointer(&pStubMsg->Buffer, sizeof(USHORT));
+ ALIGN_POINTER(pStubMsg->Buffer, sizeof(USHORT));
safe_copy_from_buffer(pStubMsg, &d, sizeof(d));
discriminant = d;
break;
case RPC_FC_ULONG:
{
ULONG d;
- align_pointer(&pStubMsg->Buffer, sizeof(ULONG));
+ ALIGN_POINTER(pStubMsg->Buffer, sizeof(ULONG));
safe_copy_from_buffer(pStubMsg, &d, sizeof(d));
discriminant = d;
break;
unsigned char *pMemory,
PFORMAT_STRING pFormat)
{
- const NDR_RANGE *pRange = (const NDR_RANGE *)pFormat;
+ NDR_RANGE *pRange = (NDR_RANGE *)pFormat;
unsigned char base_type;
TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
PFORMAT_STRING pFormat,
unsigned char fMustAlloc)
{
- const NDR_RANGE *pRange = (const NDR_RANGE *)pFormat;
+ NDR_RANGE *pRange = (NDR_RANGE *)pFormat;
unsigned char base_type;
TRACE("pStubMsg: %p, ppMemory: %p, type: 0x%02x, fMustAlloc: %s\n", pStubMsg, ppMemory, *pFormat, fMustAlloc ? "true" : "false");
#define RANGE_UNMARSHALL(mem_type, wire_type, format_spec) \
do \
{ \
- align_pointer(&pStubMsg->Buffer, sizeof(wire_type)); \
+ ALIGN_POINTER(pStubMsg->Buffer, sizeof(wire_type)); \
if (!fMustAlloc && !*ppMemory) \
fMustAlloc = TRUE; \
if (fMustAlloc) \
unsigned char *pMemory,
PFORMAT_STRING pFormat)
{
- const NDR_RANGE *pRange = (const NDR_RANGE *)pFormat;
+ NDR_RANGE *pRange = (NDR_RANGE *)pFormat;
unsigned char base_type;
TRACE("pStubMsg %p, pMemory %p, type 0x%02x\n", pStubMsg, pMemory, *pFormat);
PMIDL_STUB_MESSAGE pStubMsg,
PFORMAT_STRING pFormat)
{
- const NDR_RANGE *pRange = (const NDR_RANGE *)pFormat;
+ NDR_RANGE *pRange = (NDR_RANGE *)pFormat;
unsigned char base_type;
if (pRange->type != RPC_FC_RANGE)
case RPC_FC_WCHAR:
case RPC_FC_SHORT:
case RPC_FC_USHORT:
- align_pointer_clear(&pStubMsg->Buffer, sizeof(USHORT));
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, sizeof(USHORT));
safe_copy_to_buffer(pStubMsg, pMemory, sizeof(USHORT));
TRACE("value: 0x%04x\n", *(USHORT *)pMemory);
break;
case RPC_FC_ULONG:
case RPC_FC_ERROR_STATUS_T:
case RPC_FC_ENUM32:
- align_pointer_clear(&pStubMsg->Buffer, sizeof(ULONG));
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, sizeof(ULONG));
safe_copy_to_buffer(pStubMsg, pMemory, sizeof(ULONG));
TRACE("value: 0x%08x\n", *(ULONG *)pMemory);
break;
case RPC_FC_FLOAT:
- align_pointer_clear(&pStubMsg->Buffer, sizeof(float));
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, sizeof(float));
safe_copy_to_buffer(pStubMsg, pMemory, sizeof(float));
break;
case RPC_FC_DOUBLE:
- align_pointer_clear(&pStubMsg->Buffer, sizeof(double));
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, sizeof(double));
safe_copy_to_buffer(pStubMsg, pMemory, sizeof(double));
break;
case RPC_FC_HYPER:
- align_pointer_clear(&pStubMsg->Buffer, sizeof(ULONGLONG));
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, sizeof(ULONGLONG));
safe_copy_to_buffer(pStubMsg, pMemory, sizeof(ULONGLONG));
TRACE("value: %s\n", wine_dbgstr_longlong(*(ULONGLONG*)pMemory));
break;
case RPC_FC_ENUM16:
- {
- USHORT val = *(UINT *)pMemory;
/* only 16-bits on the wire, so do a sanity check */
if (*(UINT *)pMemory > SHRT_MAX)
RpcRaiseException(RPC_X_ENUM_VALUE_OUT_OF_RANGE);
- align_pointer_clear(&pStubMsg->Buffer, sizeof(USHORT));
- safe_copy_to_buffer(pStubMsg, &val, sizeof(val));
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, sizeof(USHORT));
+ if (pStubMsg->Buffer + sizeof(USHORT) > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
+ RpcRaiseException(RPC_X_BAD_STUB_DATA);
+ *(USHORT *)pStubMsg->Buffer = *(UINT *)pMemory;
+ pStubMsg->Buffer += sizeof(USHORT);
TRACE("value: 0x%04x\n", *(UINT *)pMemory);
break;
- }
- case RPC_FC_INT3264:
- case RPC_FC_UINT3264:
- {
- UINT val = *(UINT_PTR *)pMemory;
- align_pointer_clear(&pStubMsg->Buffer, sizeof(UINT));
- safe_copy_to_buffer(pStubMsg, &val, sizeof(val));
- break;
- }
case RPC_FC_IGNORE:
break;
default:
{
TRACE("pStubMsg: %p, ppMemory: %p, type: 0x%02x, fMustAlloc: %s\n", pStubMsg, ppMemory, *pFormat, fMustAlloc ? "true" : "false");
-#define BASE_TYPE_UNMARSHALL(type) do { \
- align_pointer(&pStubMsg->Buffer, sizeof(type)); \
+#define BASE_TYPE_UNMARSHALL(type) \
+ ALIGN_POINTER(pStubMsg->Buffer, sizeof(type)); \
if (!fMustAlloc && !pStubMsg->IsClient && !*ppMemory) \
{ \
*ppMemory = pStubMsg->Buffer; \
*ppMemory = NdrAllocate(pStubMsg, sizeof(type)); \
TRACE("*ppMemory: %p\n", *ppMemory); \
safe_copy_from_buffer(pStubMsg, *ppMemory, sizeof(type)); \
- } \
- } while (0)
+ }
switch(*pFormat)
{
TRACE("value: %s\n", wine_dbgstr_longlong(**(ULONGLONG **)ppMemory));
break;
case RPC_FC_ENUM16:
- {
- USHORT val;
- align_pointer(&pStubMsg->Buffer, sizeof(USHORT));
+ ALIGN_POINTER(pStubMsg->Buffer, sizeof(USHORT));
if (!fMustAlloc && !*ppMemory)
fMustAlloc = TRUE;
if (fMustAlloc)
*ppMemory = NdrAllocate(pStubMsg, sizeof(UINT));
- safe_copy_from_buffer(pStubMsg, &val, sizeof(USHORT));
+ if (pStubMsg->Buffer + sizeof(USHORT) > pStubMsg->BufferEnd)
+ RpcRaiseException(RPC_X_BAD_STUB_DATA);
+ TRACE("*ppMemory: %p\n", *ppMemory);
/* 16-bits on the wire, but int in memory */
- **(UINT **)ppMemory = val;
+ **(UINT **)ppMemory = *(USHORT *)pStubMsg->Buffer;
+ pStubMsg->Buffer += sizeof(USHORT);
TRACE("value: 0x%08x\n", **(UINT **)ppMemory);
break;
- }
- case RPC_FC_INT3264:
- if (sizeof(INT_PTR) == sizeof(INT)) BASE_TYPE_UNMARSHALL(INT);
- else
- {
- INT val;
- align_pointer(&pStubMsg->Buffer, sizeof(INT));
- if (!fMustAlloc && !*ppMemory)
- fMustAlloc = TRUE;
- if (fMustAlloc)
- *ppMemory = NdrAllocate(pStubMsg, sizeof(INT_PTR));
- safe_copy_from_buffer(pStubMsg, &val, sizeof(INT));
- **(INT_PTR **)ppMemory = val;
- TRACE("value: 0x%08lx\n", **(INT_PTR **)ppMemory);
- }
- break;
- case RPC_FC_UINT3264:
- if (sizeof(UINT_PTR) == sizeof(UINT)) BASE_TYPE_UNMARSHALL(UINT);
- else
- {
- UINT val;
- align_pointer(&pStubMsg->Buffer, sizeof(UINT));
- if (!fMustAlloc && !*ppMemory)
- fMustAlloc = TRUE;
- if (fMustAlloc)
- *ppMemory = NdrAllocate(pStubMsg, sizeof(UINT_PTR));
- safe_copy_from_buffer(pStubMsg, &val, sizeof(UINT));
- **(UINT_PTR **)ppMemory = val;
- TRACE("value: 0x%08lx\n", **(UINT_PTR **)ppMemory);
- }
- break;
case RPC_FC_IGNORE:
break;
default:
case RPC_FC_SHORT:
case RPC_FC_USHORT:
case RPC_FC_ENUM16:
- align_length(&pStubMsg->BufferLength, sizeof(USHORT));
+ ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(USHORT));
safe_buffer_length_increment(pStubMsg, sizeof(USHORT));
break;
case RPC_FC_LONG:
case RPC_FC_ULONG:
case RPC_FC_ENUM32:
- case RPC_FC_INT3264:
- case RPC_FC_UINT3264:
- align_length(&pStubMsg->BufferLength, sizeof(ULONG));
+ ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(ULONG));
safe_buffer_length_increment(pStubMsg, sizeof(ULONG));
break;
case RPC_FC_FLOAT:
- align_length(&pStubMsg->BufferLength, sizeof(float));
+ ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(float));
safe_buffer_length_increment(pStubMsg, sizeof(float));
break;
case RPC_FC_DOUBLE:
- align_length(&pStubMsg->BufferLength, sizeof(double));
+ ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(double));
safe_buffer_length_increment(pStubMsg, sizeof(double));
break;
case RPC_FC_HYPER:
- align_length(&pStubMsg->BufferLength, sizeof(ULONGLONG));
+ ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(ULONGLONG));
safe_buffer_length_increment(pStubMsg, sizeof(ULONGLONG));
break;
case RPC_FC_ERROR_STATUS_T:
- align_length(&pStubMsg->BufferLength, sizeof(error_status_t));
+ ALIGN_LENGTH(pStubMsg->BufferLength, sizeof(error_status_t));
safe_buffer_length_increment(pStubMsg, sizeof(error_status_t));
break;
case RPC_FC_IGNORE:
case RPC_FC_WCHAR:
case RPC_FC_SHORT:
case RPC_FC_USHORT:
- align_pointer(&pStubMsg->Buffer, sizeof(USHORT));
+ ALIGN_POINTER(pStubMsg->Buffer, sizeof(USHORT));
safe_buffer_increment(pStubMsg, sizeof(USHORT));
- align_length(&pStubMsg->MemorySize, sizeof(USHORT));
+ ALIGN_LENGTH(pStubMsg->MemorySize, sizeof(USHORT));
pStubMsg->MemorySize += sizeof(USHORT);
return sizeof(USHORT);
case RPC_FC_LONG:
case RPC_FC_ULONG:
case RPC_FC_ENUM32:
- align_pointer(&pStubMsg->Buffer, sizeof(ULONG));
+ ALIGN_POINTER(pStubMsg->Buffer, sizeof(ULONG));
safe_buffer_increment(pStubMsg, sizeof(ULONG));
- align_length(&pStubMsg->MemorySize, sizeof(ULONG));
+ ALIGN_LENGTH(pStubMsg->MemorySize, sizeof(ULONG));
pStubMsg->MemorySize += sizeof(ULONG);
return sizeof(ULONG);
case RPC_FC_FLOAT:
- align_pointer(&pStubMsg->Buffer, sizeof(float));
+ ALIGN_POINTER(pStubMsg->Buffer, sizeof(float));
safe_buffer_increment(pStubMsg, sizeof(float));
- align_length(&pStubMsg->MemorySize, sizeof(float));
+ ALIGN_LENGTH(pStubMsg->MemorySize, sizeof(float));
pStubMsg->MemorySize += sizeof(float);
return sizeof(float);
case RPC_FC_DOUBLE:
- align_pointer(&pStubMsg->Buffer, sizeof(double));
+ ALIGN_POINTER(pStubMsg->Buffer, sizeof(double));
safe_buffer_increment(pStubMsg, sizeof(double));
- align_length(&pStubMsg->MemorySize, sizeof(double));
+ ALIGN_LENGTH(pStubMsg->MemorySize, sizeof(double));
pStubMsg->MemorySize += sizeof(double);
return sizeof(double);
case RPC_FC_HYPER:
- align_pointer(&pStubMsg->Buffer, sizeof(ULONGLONG));
+ ALIGN_POINTER(pStubMsg->Buffer, sizeof(ULONGLONG));
safe_buffer_increment(pStubMsg, sizeof(ULONGLONG));
- align_length(&pStubMsg->MemorySize, sizeof(ULONGLONG));
+ ALIGN_LENGTH(pStubMsg->MemorySize, sizeof(ULONGLONG));
pStubMsg->MemorySize += sizeof(ULONGLONG);
return sizeof(ULONGLONG);
case RPC_FC_ERROR_STATUS_T:
- align_pointer(&pStubMsg->Buffer, sizeof(error_status_t));
+ ALIGN_POINTER(pStubMsg->Buffer, sizeof(error_status_t));
safe_buffer_increment(pStubMsg, sizeof(error_status_t));
- align_length(&pStubMsg->MemorySize, sizeof(error_status_t));
+ ALIGN_LENGTH(pStubMsg->MemorySize, sizeof(error_status_t));
pStubMsg->MemorySize += sizeof(error_status_t);
return sizeof(error_status_t);
case RPC_FC_ENUM16:
- align_pointer(&pStubMsg->Buffer, sizeof(USHORT));
+ ALIGN_POINTER(pStubMsg->Buffer, sizeof(USHORT));
safe_buffer_increment(pStubMsg, sizeof(USHORT));
- align_length(&pStubMsg->MemorySize, sizeof(UINT));
+ ALIGN_LENGTH(pStubMsg->MemorySize, sizeof(UINT));
pStubMsg->MemorySize += sizeof(UINT);
return sizeof(UINT);
- case RPC_FC_INT3264:
- case RPC_FC_UINT3264:
- align_pointer(&pStubMsg->Buffer, sizeof(UINT));
- safe_buffer_increment(pStubMsg, sizeof(UINT));
- align_length(&pStubMsg->MemorySize, sizeof(UINT_PTR));
- pStubMsg->MemorySize += sizeof(UINT_PTR);
- return sizeof(UINT_PTR);
case RPC_FC_IGNORE:
- align_length(&pStubMsg->MemorySize, sizeof(void *));
+ ALIGN_LENGTH(pStubMsg->MemorySize, sizeof(void *));
pStubMsg->MemorySize += sizeof(void *);
return sizeof(void *);
default:
ERR("invalid format type %x\n", *pFormat);
RpcRaiseException(RPC_S_INTERNAL_ERROR);
}
- align_length(&pStubMsg->BufferLength, 4);
+ ALIGN_LENGTH(pStubMsg->BufferLength, 4);
safe_buffer_length_increment(pStubMsg, cbNDRContext);
}
{
TRACE("(%p, %p, %d)\n", pStubMsg, ContextHandle, fCheck);
- align_pointer_clear(&pStubMsg->Buffer, 4);
+ ALIGN_POINTER_CLEAR(pStubMsg->Buffer, 4);
if (pStubMsg->Buffer + cbNDRContext > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
{
{
TRACE("(%p, %p, %p)\n", pStubMsg, pContextHandle, BindHandle);
- align_pointer(&pStubMsg->Buffer, 4);
+ ALIGN_POINTER(pStubMsg->Buffer, 4);
if (pStubMsg->Buffer + cbNDRContext > pStubMsg->BufferEnd)
RpcRaiseException(RPC_X_BAD_STUB_DATA);
{
TRACE("(%p, %p, %p)\n", pStubMsg, ContextHandle, RundownRoutine);
- align_pointer(&pStubMsg->Buffer, 4);
+ ALIGN_POINTER(pStubMsg->Buffer, 4);
if (pStubMsg->Buffer + cbNDRContext > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
{
TRACE("(%p)\n", pStubMsg);
- align_pointer(&pStubMsg->Buffer, 4);
+ ALIGN_POINTER(pStubMsg->Buffer, 4);
if (pStubMsg->Buffer + cbNDRContext > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
{
TRACE("(%p, %p, %p, %p)\n", pStubMsg, ContextHandle, RundownRoutine, pFormat);
- align_pointer(&pStubMsg->Buffer, 4);
+ ALIGN_POINTER(pStubMsg->Buffer, 4);
if (pStubMsg->Buffer + cbNDRContext > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
{
TRACE("(%p, %p)\n", pStubMsg, pFormat);
- align_pointer(&pStubMsg->Buffer, 4);
+ ALIGN_POINTER(pStubMsg->Buffer, 4);
if (pStubMsg->Buffer + cbNDRContext > (unsigned char *)pStubMsg->RpcMsg->Buffer + pStubMsg->BufferLength)
{
{
const IID *riid = get_ip_iid(pStubMsg, pMemory, pFormat);
ULONG size = 0;
+ HRESULT hr;
TRACE("(%p,%p,%p)\n", pStubMsg, pMemory, pFormat);
if (!LoadCOM()) return;
- COM_GetMarshalSizeMax(&size, riid, (LPUNKNOWN)pMemory,
- pStubMsg->dwDestContext, pStubMsg->pvDestContext,
- MSHLFLAGS_NORMAL);
+ hr = COM_GetMarshalSizeMax(&size, riid, (LPUNKNOWN)pMemory,
+ pStubMsg->dwDestContext, pStubMsg->pvDestContext,
+ MSHLFLAGS_NORMAL);
TRACE("size=%d\n", size);
pStubMsg->BufferLength += sizeof(DWORD) + size;
}
if (pDesc->flag_and_size & HANDLE_PARAM_IS_VIA_PTR)
pArg = *(void **)ARG_FROM_OFFSET(pStubMsg->StackTop, pDesc->offset);
else
- pArg = ARG_FROM_OFFSET(pStubMsg->StackTop, pDesc->offset);
+ pArg = (void *)ARG_FROM_OFFSET(pStubMsg->StackTop, pDesc->offset);
memcpy(&pObject, pArg, pDesc->flag_and_size & 0xf);
pGenPair = &pStubMsg->StubDesc->aGenericBindingRoutinePairs[pDesc->binding_routine_pair_index];
*phBinding = pGenPair->pfnBind(pObject);
if (pDesc->flag_and_size & HANDLE_PARAM_IS_VIA_PTR)
pArg = *(void **)ARG_FROM_OFFSET(pStubMsg->StackTop, pDesc->offset);
else
- pArg = ARG_FROM_OFFSET(pStubMsg->StackTop, pDesc->offset);
+ pArg = (void *)ARG_FROM_OFFSET(pStubMsg->StackTop, pDesc->offset);
memcpy(&pObject, pArg, pDesc->flag_and_size & 0xf);
pGenPair = &pStubMsg->StubDesc->aGenericBindingRoutinePairs[pDesc->binding_routine_pair_index];
pGenPair->pfnUnbind(pObject, hBinding);
void * This = NULL;
PFORMAT_STRING pHandleFormat;
/* correlation cache */
- ULONG_PTR NdrCorrCache[256];
+ unsigned long NdrCorrCache[256];
TRACE("pStubDesc %p, pFormat %p, ...\n", pStubDesc, pFormat);
* 4. PROXY_SENDRECEIVE - send/receive buffer
* 5. PROXY_UNMARHSAL - unmarshal [out] params from buffer
*/
- if ((pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT) ||
- (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_HAS_COMM_OR_FAULT))
+ if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
{
__TRY
{
switch (phase)
{
case PROXY_GETBUFFER:
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
- {
- /* allocate the buffer */
- NdrProxyGetBuffer(This, &stubMsg);
- }
- else
- {
- /* allocate the buffer */
- if (Oif_flags.HasPipes)
- /* NdrGetPipeBuffer(...) */
- FIXME("pipes not supported yet\n");
- else
- {
- if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
-#if 0
- NdrNsGetBuffer(&stubMsg, stubMsg.BufferLength, hBinding);
-#else
- FIXME("using auto handle - call NdrNsGetBuffer when it gets implemented\n");
-#endif
- else
- NdrGetBuffer(&stubMsg, stubMsg.BufferLength, hBinding);
- }
- }
+ /* allocate the buffer */
+ NdrProxyGetBuffer(This, &stubMsg);
break;
case PROXY_SENDRECEIVE:
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
- {
- /* send the [in] params and receive the [out] and [retval]
- * params */
- NdrProxySendReceive(This, &stubMsg);
- }
- else
- {
- /* send the [in] params and receive the [out] and [retval]
- * params */
- if (Oif_flags.HasPipes)
- /* NdrPipesSendReceive(...) */
- FIXME("pipes not supported yet\n");
- else
- {
- if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
-#if 0
- NdrNsSendReceive(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle);
-#else
- FIXME("using auto handle - call NdrNsSendReceive when it gets implemented\n");
-#endif
- else
- NdrSendReceive(&stubMsg, stubMsg.Buffer);
- }
- }
+ /* send the [in] params and receive the [out] and [retval]
+ * params */
+ NdrProxySendReceive(This, &stubMsg);
/* convert strings, floating point values and endianess into our
* preferred format */
}
__EXCEPT_ALL
{
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
- RetVal = NdrProxyErrorHandler(GetExceptionCode());
- else
- {
- const COMM_FAULT_OFFSETS *comm_fault_offsets = &pStubDesc->CommFaultOffsets[procedure_number];
- ULONG *comm_status;
- ULONG *fault_status;
-
- TRACE("comm_fault_offsets = {0x%hx, 0x%hx}\n", comm_fault_offsets->CommOffset, comm_fault_offsets->FaultOffset);
-
- if (comm_fault_offsets->CommOffset == -1)
- comm_status = (ULONG *)&RetVal;
- else if (comm_fault_offsets->CommOffset >= 0)
- comm_status = *(ULONG **)ARG_FROM_OFFSET(stubMsg.StackTop, comm_fault_offsets->CommOffset);
- else
- comm_status = NULL;
-
- if (comm_fault_offsets->FaultOffset == -1)
- fault_status = (ULONG *)&RetVal;
- else if (comm_fault_offsets->FaultOffset >= 0)
- fault_status = *(ULONG **)ARG_FROM_OFFSET(stubMsg.StackTop, comm_fault_offsets->CommOffset);
- else
- fault_status = NULL;
-
- NdrMapCommAndFaultStatus(&stubMsg, comm_status, fault_status,
- GetExceptionCode());
- }
+ RetVal = NdrProxyErrorHandler(GetExceptionCode());
}
__ENDTRY
}
LONG_PTR __cdecl call_server_func(SERVER_ROUTINE func, unsigned char * args, unsigned int stack_size);
__ASM_GLOBAL_FUNC(call_server_func,
"pushl %ebp\n\t"
- __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
- __ASM_CFI(".cfi_rel_offset %ebp,0\n\t")
- "movl %esp,%ebp\n\t"
- __ASM_CFI(".cfi_def_cfa_register %ebp\n\t")
+ "movl %esp, %ebp\n\t"
"pushl %edi\n\t" /* Save registers */
- __ASM_CFI(".cfi_rel_offset %edi,-4\n\t")
"pushl %esi\n\t"
- __ASM_CFI(".cfi_rel_offset %esi,-8\n\t")
"movl 16(%ebp), %eax\n\t" /* Get stack size */
"subl %eax, %esp\n\t" /* Make room in stack for arguments */
"andl $~15, %esp\n\t" /* Make sure stack has 16-byte alignment for Mac OS X */
"call *8(%ebp)\n\t" /* Call function */
"leal -8(%ebp), %esp\n\t" /* Restore stack */
"popl %esi\n\t" /* Restore registers */
- __ASM_CFI(".cfi_same_value %esi\n\t")
"popl %edi\n\t"
- __ASM_CFI(".cfi_same_value %edi\n\t")
"popl %ebp\n\t"
- __ASM_CFI(".cfi_def_cfa %esp,4\n\t")
- __ASM_CFI(".cfi_same_value %ebp\n\t")
- "ret" )
+ "ret\n" )
#else
#warning call_server_func not implemented for your architecture
LONG_PTR __cdecl call_server_func(SERVER_ROUTINE func, unsigned char * args, unsigned short stack_size)
size = ComplexStructSize(pStubMsg, pFormat);
size *= pStubMsg->MaxCount;
break;
- case RPC_FC_C_CSTRING:
- case RPC_FC_C_WSTRING:
- if (*pFormat == RPC_FC_C_CSTRING)
- size = sizeof(CHAR);
- else
- size = sizeof(WCHAR);
- if (pFormat[1] == RPC_FC_STRING_SIZED)
- ComputeConformance(pStubMsg, NULL, pFormat + 2, 0);
- else
- pStubMsg->MaxCount = 0;
- size *= pStubMsg->MaxCount;
- break;
default:
FIXME("Unhandled type %02x\n", *pFormat);
/* fallthrough */
!pParam->param_attributes.IsByValue &&
!pParam->param_attributes.ServerAllocSize)
{
- if (*pTypeFormat != RPC_FC_BIND_CONTEXT)
- pStubMsg->pfnFree(*(void **)pArg);
+ pStubMsg->pfnFree(*(void **)pArg);
}
if (pParam->param_attributes.ServerAllocSize)
!pParam->param_attributes.ServerAllocSize &&
!pParam->param_attributes.IsByValue)
{
- if (*pTypeFormat == RPC_FC_BIND_CONTEXT)
- {
- NDR_SCONTEXT ctxt = NdrContextHandleInitialize(
- pStubMsg, pTypeFormat);
- *(void **)pArg = NDRSContextValue(ctxt);
- }
- else
- {
- DWORD size = calc_arg_size(pStubMsg, pTypeFormat);
+ DWORD size = calc_arg_size(pStubMsg, pTypeFormat);
- if(size)
- {
- *(void **)pArg = NdrAllocate(pStubMsg, size);
- memset(*(void **)pArg, 0, size);
- }
+ if(size)
+ {
+ *(void **)pArg = NdrAllocate(pStubMsg, size);
+ memset(*(void **)pArg, 0, size);
}
}
break;
TRACE("NDR Version: 0x%x\n", pStubDesc->Version);
+ /* create the full pointer translation tables, if requested */
+ if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
+ stubMsg.FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_SERVER);
+
if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
{
const NDR_PROC_HEADER_RPC *pProcHeader = (const NDR_PROC_HEADER_RPC *)&pFormat[0];
else
NdrServerInitializeNew(pRpcMsg, &stubMsg, pStubDesc);
- /* create the full pointer translation tables, if requested */
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
- stubMsg.FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_SERVER);
-
/* store the RPC flags away */
if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
pRpcMsg->RpcFlags = ((const NDR_PROC_HEADER_RPC *)pProcHeader)->rpc_flags;
DWORD dwPhase;
NdrStubCall2(NULL, NULL, pRpcMsg, &dwPhase);
}
-
-struct async_call_data
-{
- MIDL_STUB_MESSAGE *pStubMsg;
- const NDR_PROC_HEADER *pProcHeader;
- PFORMAT_STRING pHandleFormat;
- PFORMAT_STRING pParamFormat;
- RPC_BINDING_HANDLE hBinding;
- /* size of stack */
- unsigned short stack_size;
- /* number of parameters. optional for client to give it to us */
- unsigned char number_of_params;
- /* correlation cache */
- ULONG_PTR NdrCorrCache[256];
-};
-
-LONG_PTR WINAPIV NdrAsyncClientCall(PMIDL_STUB_DESC pStubDesc,
- PFORMAT_STRING pFormat, ...)
-{
- /* pointer to start of stack where arguments start */
- PRPC_MESSAGE pRpcMsg;
- PMIDL_STUB_MESSAGE pStubMsg;
- RPC_ASYNC_STATE *pAsync;
- struct async_call_data *async_call_data;
- /* procedure number */
- unsigned short procedure_number;
- /* cache of Oif_flags from v2 procedure header */
- INTERPRETER_OPT_FLAGS Oif_flags = { 0 };
- /* cache of extension flags from NDR_PROC_HEADER_EXTS */
- INTERPRETER_OPT_FLAGS2 ext_flags = { 0 };
- /* the type of pass we are currently doing */
- int phase;
- /* header for procedure string */
- const NDR_PROC_HEADER * pProcHeader = (const NDR_PROC_HEADER *)&pFormat[0];
- /* -Oif or -Oicf generated format */
- BOOL bV2Format = FALSE;
-
- TRACE("pStubDesc %p, pFormat %p, ...\n", pStubDesc, pFormat);
-
- /* Later NDR language versions probably won't be backwards compatible */
- if (pStubDesc->Version > 0x50002)
- {
- FIXME("Incompatible stub description version: 0x%x\n", pStubDesc->Version);
- RpcRaiseException(RPC_X_WRONG_STUB_VERSION);
- }
-
- async_call_data = I_RpcAllocate(sizeof(*async_call_data) + sizeof(MIDL_STUB_MESSAGE) + sizeof(RPC_MESSAGE));
- if (!async_call_data) RpcRaiseException(ERROR_OUTOFMEMORY);
- async_call_data->number_of_params = ~0;
- async_call_data->pProcHeader = pProcHeader;
-
- async_call_data->pStubMsg = pStubMsg = (PMIDL_STUB_MESSAGE)(async_call_data + 1);
- pRpcMsg = (PRPC_MESSAGE)(pStubMsg + 1);
-
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
- {
- const NDR_PROC_HEADER_RPC *pProcHeader = (const NDR_PROC_HEADER_RPC *)&pFormat[0];
- async_call_data->stack_size = pProcHeader->stack_size;
- procedure_number = pProcHeader->proc_num;
- pFormat += sizeof(NDR_PROC_HEADER_RPC);
- }
- else
- {
- async_call_data->stack_size = pProcHeader->stack_size;
- procedure_number = pProcHeader->proc_num;
- pFormat += sizeof(NDR_PROC_HEADER);
- }
- TRACE("stack size: 0x%x\n", async_call_data->stack_size);
- TRACE("proc num: %d\n", procedure_number);
-
- /* create the full pointer translation tables, if requested */
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
- pStubMsg->FullPtrXlatTables = NdrFullPointerXlatInit(0,XLAT_CLIENT);
-
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT)
- {
- ERR("objects not supported\n");
- I_RpcFree(async_call_data);
- RpcRaiseException(RPC_X_BAD_STUB_DATA);
- }
-
- NdrClientInitializeNew(pRpcMsg, pStubMsg, pStubDesc, procedure_number);
-
- TRACE("Oi_flags = 0x%02x\n", pProcHeader->Oi_flags);
- TRACE("MIDL stub version = 0x%x\n", pStubDesc->MIDLVersion);
-
- /* needed for conformance of top-level objects */
-#ifdef __i386__
- pStubMsg->StackTop = I_RpcAllocate(async_call_data->stack_size);
- /* FIXME: this may read one more DWORD than is necessary, but it shouldn't hurt */
- memcpy(pStubMsg->StackTop, *(unsigned char **)(&pFormat+1), async_call_data->stack_size);
-#else
-# warning Stack not retrieved for your CPU architecture
-#endif
-
- pAsync = *(RPC_ASYNC_STATE **)pStubMsg->StackTop;
- pAsync->StubInfo = async_call_data;
- async_call_data->pHandleFormat = pFormat;
-
- pFormat = client_get_handle(pStubMsg, pProcHeader, async_call_data->pHandleFormat, &async_call_data->hBinding);
- if (!pFormat) return 0;
-
- bV2Format = (pStubDesc->Version >= 0x20000);
-
- if (bV2Format)
- {
- const NDR_PROC_PARTIAL_OIF_HEADER *pOIFHeader =
- (const NDR_PROC_PARTIAL_OIF_HEADER *)pFormat;
-
- Oif_flags = pOIFHeader->Oi2Flags;
- async_call_data->number_of_params = pOIFHeader->number_of_params;
-
- pFormat += sizeof(NDR_PROC_PARTIAL_OIF_HEADER);
- }
-
- TRACE("Oif_flags = "); dump_INTERPRETER_OPT_FLAGS(Oif_flags);
-
- if (Oif_flags.HasExtensions)
- {
- const NDR_PROC_HEADER_EXTS *pExtensions =
- (const NDR_PROC_HEADER_EXTS *)pFormat;
- ext_flags = pExtensions->Flags2;
- pFormat += pExtensions->Size;
- }
-
- async_call_data->pParamFormat = pFormat;
-
- pStubMsg->BufferLength = 0;
-
- /* store the RPC flags away */
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCFLAGS)
- pRpcMsg->RpcFlags = ((const NDR_PROC_HEADER_RPC *)pProcHeader)->rpc_flags;
-
- /* use alternate memory allocation routines */
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_RPCSSALLOC)
- NdrRpcSmSetClientToOsf(pStubMsg);
-
- if (Oif_flags.HasPipes)
- {
- FIXME("pipes not supported yet\n");
- RpcRaiseException(RPC_X_WRONG_STUB_VERSION); /* FIXME: remove when implemented */
- /* init pipes package */
- /* NdrPipesInitialize(...) */
- }
- if (ext_flags.HasNewCorrDesc)
- {
- /* initialize extra correlation package */
- NdrCorrelationInitialize(pStubMsg, async_call_data->NdrCorrCache, sizeof(async_call_data->NdrCorrCache), 0);
- }
-
- /* order of phases:
- * 1. PROXY_CALCSIZE - calculate the buffer size
- * 2. PROXY_GETBUFFER - allocate the buffer
- * 3. PROXY_MARHSAL - marshal [in] params into the buffer
- * 4. PROXY_SENDRECEIVE - send buffer
- * Then in NdrpCompleteAsyncClientCall:
- * 1. PROXY_SENDRECEIVE - receive buffer
- * 2. PROXY_UNMARHSAL - unmarshal [out] params from buffer
- */
- for (phase = PROXY_CALCSIZE; phase <= PROXY_SENDRECEIVE; phase++)
- {
- RPC_STATUS status;
- TRACE("phase = %d\n", phase);
- switch (phase)
- {
- case PROXY_GETBUFFER:
- /* allocate the buffer */
- if (Oif_flags.HasPipes)
- /* NdrGetPipeBuffer(...) */
- FIXME("pipes not supported yet\n");
- else
- {
- if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
-#if 0
- NdrNsGetBuffer(pStubMsg, pStubMsg->BufferLength, async_call_data->hBinding);
-#else
- FIXME("using auto handle - call NdrNsGetBuffer when it gets implemented\n");
-#endif
- else
- NdrGetBuffer(pStubMsg, pStubMsg->BufferLength, async_call_data->hBinding);
- }
- pRpcMsg->RpcFlags |= RPC_BUFFER_ASYNC;
- status = I_RpcAsyncSetHandle(pRpcMsg, pAsync);
- if (status != RPC_S_OK)
- RpcRaiseException(status);
- break;
- case PROXY_SENDRECEIVE:
- pRpcMsg->RpcFlags |= RPC_BUFFER_ASYNC;
- /* send the [in] params only */
- if (Oif_flags.HasPipes)
- /* NdrPipesSend(...) */
- FIXME("pipes not supported yet\n");
- else
- {
- if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
-#if 0
- NdrNsSend(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle);
-#else
- FIXME("using auto handle - call NdrNsSend when it gets implemented\n");
-#endif
- else
- {
- pStubMsg->RpcMsg->BufferLength = pStubMsg->Buffer - (unsigned char *)pStubMsg->RpcMsg->Buffer;
- status = I_RpcSend(pStubMsg->RpcMsg);
- if (status != RPC_S_OK)
- RpcRaiseException(status);
- }
- }
-
- break;
- case PROXY_CALCSIZE:
- case PROXY_MARSHAL:
- if (bV2Format)
- client_do_args(pStubMsg, pFormat, phase, pStubMsg->StackTop,
- async_call_data->number_of_params, NULL);
- else
- client_do_args_old_format(pStubMsg, pFormat, phase,
- pStubMsg->StackTop, async_call_data->stack_size, NULL,
- (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_OBJECT), FALSE);
- break;
- default:
- ERR("shouldn't reach here. phase %d\n", phase);
- break;
- }
- }
-
- TRACE("returning 0\n");
- return 0;
-}
-
-RPC_STATUS NdrpCompleteAsyncClientCall(RPC_ASYNC_STATE *pAsync, void *Reply)
-{
- /* pointer to start of stack where arguments start */
- PMIDL_STUB_MESSAGE pStubMsg;
- struct async_call_data *async_call_data;
- /* the type of pass we are currently doing */
- int phase;
- /* header for procedure string */
- const NDR_PROC_HEADER * pProcHeader;
- /* -Oif or -Oicf generated format */
- BOOL bV2Format;
- RPC_STATUS status = RPC_S_OK;
-
- if (!pAsync->StubInfo)
- return RPC_S_INVALID_ASYNC_HANDLE;
-
- async_call_data = pAsync->StubInfo;
- pStubMsg = async_call_data->pStubMsg;
- pProcHeader = async_call_data->pProcHeader;
-
- bV2Format = (pStubMsg->StubDesc->Version >= 0x20000);
-
- /* order of phases:
- * 1. PROXY_CALCSIZE - calculate the buffer size
- * 2. PROXY_GETBUFFER - allocate the buffer
- * 3. PROXY_MARHSAL - marshal [in] params into the buffer
- * 4. PROXY_SENDRECEIVE - send buffer
- * Then in NdrpCompleteAsyncClientCall:
- * 1. PROXY_SENDRECEIVE - receive buffer
- * 2. PROXY_UNMARHSAL - unmarshal [out] params from buffer
- */
- for (phase = PROXY_SENDRECEIVE; phase <= PROXY_UNMARSHAL; phase++)
- {
- switch (phase)
- {
- case PROXY_SENDRECEIVE:
- pStubMsg->RpcMsg->RpcFlags |= RPC_BUFFER_ASYNC;
- /* receive the [out] params */
- if (pProcHeader->handle_type == RPC_FC_AUTO_HANDLE)
-#if 0
- NdrNsReceive(&stubMsg, stubMsg.Buffer, pStubDesc->IMPLICIT_HANDLE_INFO.pAutoHandle);
-#else
- FIXME("using auto handle - call NdrNsReceive when it gets implemented\n");
-#endif
- else
- {
- status = I_RpcReceive(pStubMsg->RpcMsg);
- if (status != RPC_S_OK)
- goto cleanup;
- pStubMsg->BufferLength = pStubMsg->RpcMsg->BufferLength;
- pStubMsg->BufferStart = pStubMsg->RpcMsg->Buffer;
- pStubMsg->BufferEnd = pStubMsg->BufferStart + pStubMsg->BufferLength;
- pStubMsg->Buffer = pStubMsg->BufferStart;
- }
-
- /* convert strings, floating point values and endianess into our
- * preferred format */
-#if 0
- if ((pStubMsg->RpcMsg.DataRepresentation & 0x0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION)
- NdrConvert(pStubMsg, pFormat);
-#endif
-
- break;
- case PROXY_UNMARSHAL:
- if (bV2Format)
- client_do_args(pStubMsg, async_call_data->pParamFormat, phase, pStubMsg->StackTop,
- async_call_data->number_of_params, Reply);
- else
- client_do_args_old_format(pStubMsg, async_call_data->pParamFormat, phase,
- pStubMsg->StackTop, async_call_data->stack_size, Reply, FALSE, FALSE);
- break;
- default:
- ERR("shouldn't reach here. phase %d\n", phase);
- break;
- }
- }
-
-cleanup:
- if (pStubMsg->fHasNewCorrDesc)
- {
- /* free extra correlation package */
- NdrCorrelationFree(pStubMsg);
- }
-
- /* free the full pointer translation tables */
- if (pProcHeader->Oi_flags & RPC_FC_PROC_OIF_FULLPTR)
- NdrFullPointerXlatFree(pStubMsg->FullPtrXlatTables);
-
- /* free marshalling buffer */
- NdrFreeBuffer(pStubMsg);
- client_free_handle(pStubMsg, pProcHeader, async_call_data->pHandleFormat, async_call_data->hBinding);
-
- I_RpcFree(pStubMsg->StackTop);
- I_RpcFree(async_call_data);
-
- TRACE("-- 0x%x\n", status);
- return status;
-}
-
-RPCRTAPI LONG RPC_ENTRY NdrAsyncStubCall(struct IRpcStubBuffer* pThis,
- struct IRpcChannelBuffer* pChannel, PRPC_MESSAGE pRpcMsg,
- DWORD * pdwStubPhase)
-{
- FIXME("unimplemented, expect crash!\n");
- return 0;
-}
* RPCF_Asynchronous = 0x4000 - [async] MIDL attribute
* Reserved = 0x8000
*/
- unsigned int rpc_flags;
+ unsigned long rpc_flags;
unsigned short proc_num;
unsigned short stack_size;
PFORMAT_STRING pFormat, int phase, unsigned char *args,
unsigned short stack_size, unsigned char *pRetVal, BOOL object_proc,
BOOL ignore_retval);
-RPC_STATUS NdrpCompleteAsyncClientCall(RPC_ASYNC_STATE *pAsync, void *Reply);
return RPC_S_OK;
}
-static BOOL compare_networkoptions(LPCWSTR opts1, LPCWSTR opts2)
-{
- if ((opts1 == NULL) && (opts2 == NULL))
- return TRUE;
- if ((opts1 == NULL) || (opts2 == NULL))
- return FALSE;
- return !strcmpW(opts1, opts2);
-}
-
RPC_STATUS RPCRT4_GetAssociation(LPCSTR Protseq, LPCSTR NetworkAddr,
LPCSTR Endpoint, LPCWSTR NetworkOptions,
RpcAssoc **assoc_out)
if (!strcmp(Protseq, assoc->Protseq) &&
!strcmp(NetworkAddr, assoc->NetworkAddr) &&
!strcmp(Endpoint, assoc->Endpoint) &&
- compare_networkoptions(NetworkOptions, assoc->NetworkOptions))
+ ((!assoc->NetworkOptions && !NetworkOptions) || !strcmpW(NetworkOptions, assoc->NetworkOptions)))
{
assoc->refs++;
*assoc_out = assoc;
RPC_STATUS RpcServerAssoc_GetAssociation(LPCSTR Protseq, LPCSTR NetworkAddr,
LPCSTR Endpoint, LPCWSTR NetworkOptions,
- ULONG assoc_gid,
+ unsigned long assoc_gid,
RpcAssoc **assoc_out)
{
RpcAssoc *assoc;
RPC_MESSAGE msg;
RPC_STATUS status;
unsigned char *auth_data = NULL;
- ULONG auth_length;
+ unsigned long auth_length;
TRACE("sending bind request to server\n");
{
unsigned short remaining = msg.BufferLength -
ROUND_UP(FIELD_OFFSET(RpcAddressString, string[server_address->length]), 4);
- RpcResultList *results = (RpcResultList*)((ULONG_PTR)server_address +
- ROUND_UP(FIELD_OFFSET(RpcAddressString, string[server_address->length]), 4));
- if ((results->num_results == 1) &&
- (remaining >= FIELD_OFFSET(RpcResultList, results[results->num_results])))
+ RpcResults *results = (RpcResults*)((ULONG_PTR)server_address +
+ ROUND_UP(FIELD_OFFSET(RpcAddressString, string[server_address->length]), 4));
+ if ((results->num_results == 1) && (remaining >= sizeof(*results)))
{
switch (results->results[0].result)
{
case RESULT_ACCEPT:
/* respond to authorization request */
if (auth_length > sizeof(RpcAuthVerifier))
- status = RPCRT4_ClientConnectionAuth(conn,
- auth_data + sizeof(RpcAuthVerifier),
- auth_length);
+ status = RPCRT4_AuthorizeConnection(conn,
+ auth_data + sizeof(RpcAuthVerifier),
+ auth_length);
if (status == RPC_S_OK)
{
conn->assoc_group_id = response_hdr->bind_ack.assoc_gid;
if (status != RPC_S_OK)
return status;
- NewConnection->assoc = assoc;
status = RPCRT4_OpenClientConnection(NewConnection);
if (status != RPC_S_OK)
{
void RpcAssoc_ReleaseIdleConnection(RpcAssoc *assoc, RpcConnection *Connection)
{
assert(!Connection->server);
- Connection->async_state = NULL;
EnterCriticalSection(&assoc->cs);
if (!assoc->assoc_group_id) assoc->assoc_group_id = Connection->assoc_group_id;
list_add_head(&assoc->free_connection_pool, &Connection->conn_pool_entry);
/* id of this association group */
ULONG assoc_group_id;
- UUID http_uuid;
CRITICAL_SECTION cs;
RPC_STATUS RpcAssoc_GetClientConnection(RpcAssoc *assoc, const RPC_SYNTAX_IDENTIFIER *InterfaceId, const RPC_SYNTAX_IDENTIFIER *TransferSyntax, RpcAuthInfo *AuthInfo, RpcQualityOfService *QOS, RpcConnection **Connection);
void RpcAssoc_ReleaseIdleConnection(RpcAssoc *assoc, RpcConnection *Connection);
ULONG RpcAssoc_Release(RpcAssoc *assoc);
-RPC_STATUS RpcServerAssoc_GetAssociation(LPCSTR Protseq, LPCSTR NetworkAddr, LPCSTR Endpoint, LPCWSTR NetworkOptions, ULONG assoc_gid, RpcAssoc **assoc_out);
+RPC_STATUS RpcServerAssoc_GetAssociation(LPCSTR Protseq, LPCSTR NetworkAddr, LPCSTR Endpoint, LPCWSTR NetworkOptions, unsigned long assoc_gid, RpcAssoc **assoc_out);
RPC_STATUS RpcServerAssoc_AllocateContextHandle(RpcAssoc *assoc, void *CtxGuard, NDR_SCONTEXT *SContext);
RPC_STATUS RpcServerAssoc_FindContextHandle(RpcAssoc *assoc, const UUID *uuid, void *CtxGuard, ULONG Flags, NDR_SCONTEXT *SContext);
RPC_STATUS RpcServerAssoc_UpdateContextHandle(RpcAssoc *assoc, NDR_SCONTEXT SContext, void *CtxGuard, NDR_RUNDOWN rundown_routine);
#include "rpc_binding.h"
#include "rpc_message.h"
-#include "ndr_stubless.h"
WINE_DEFAULT_DEBUG_CHANNEL(rpc);
#define RPC_ASYNC_SIGNATURE 0x43595341
-static inline BOOL valid_async_handle(PRPC_ASYNC_STATE pAsync)
-{
- return pAsync->Signature == RPC_ASYNC_SIGNATURE;
-}
-
/***********************************************************************
* RpcAsyncInitializeHandle [RPCRT4.@]
*
*/
RPC_STATUS WINAPI RpcAsyncCompleteCall(PRPC_ASYNC_STATE pAsync, void *Reply)
{
- TRACE("(%p, %p)\n", pAsync, Reply);
-
- if (!valid_async_handle(pAsync))
- return RPC_S_INVALID_ASYNC_HANDLE;
-
- /* FIXME: check completed */
-
- return NdrpCompleteAsyncClientCall(pAsync, Reply);
+ FIXME("(%p, %p): stub\n", pAsync, Reply);
+ return RPC_S_INVALID_ASYNC_HANDLE;
}
/***********************************************************************
return RPC_S_OK;
fail:
- if (ObjUuid) RpcStringFreeA(ObjUuid);
- if (Protseq) RpcStringFreeA(Protseq);
- if (NetworkAddr) RpcStringFreeA(NetworkAddr);
- if (Endpoint) RpcStringFreeA(Endpoint);
- if (Options) RpcStringFreeA(Options);
+ if (ObjUuid) RpcStringFreeA((unsigned char**)ObjUuid);
+ if (Protseq) RpcStringFreeA((unsigned char**)Protseq);
+ if (NetworkAddr) RpcStringFreeA((unsigned char**)NetworkAddr);
+ if (Endpoint) RpcStringFreeA((unsigned char**)Endpoint);
+ if (Options) RpcStringFreeA((unsigned char**)Options);
return RPC_S_INVALID_STRING_BINDING;
}
RPC_STATUS WINAPI RpcBindingVectorFree( RPC_BINDING_VECTOR** BindingVector )
{
RPC_STATUS status;
- ULONG c;
+ unsigned long c;
TRACE("(%p)\n", BindingVector);
for (c=0; c<(*BindingVector)->Count; c++) {
*/
RPC_STATUS WINAPI RpcBindingInqObject( RPC_BINDING_HANDLE Binding, UUID* ObjectUuid )
{
- RpcBinding* bind = Binding;
+ RpcBinding* bind = (RpcBinding*)Binding;
TRACE("(%p,%p) = %s\n", Binding, ObjectUuid, debugstr_guid(&bind->ObjectUuid));
*ObjectUuid = bind->ObjectUuid;
*/
RPC_STATUS WINAPI RpcBindingSetObject( RPC_BINDING_HANDLE Binding, UUID* ObjectUuid )
{
- RpcBinding* bind = Binding;
+ RpcBinding* bind = (RpcBinding*)Binding;
TRACE("(%p,%s)\n", Binding, debugstr_guid(ObjectUuid));
if (bind->server) return RPC_S_WRONG_KIND_OF_BINDING;
if (ret == RPC_S_OK)
ret = RPCRT4_CompleteBindingA(bind, (char*)NetworkAddr, (char*)Endpoint, (char*)Options);
- RpcStringFreeA(&Options);
- RpcStringFreeA(&Endpoint);
- RpcStringFreeA(&NetworkAddr);
- RpcStringFreeA(&Protseq);
- RpcStringFreeA(&ObjectUuid);
+ RpcStringFreeA((unsigned char**)&Options);
+ RpcStringFreeA((unsigned char**)&Endpoint);
+ RpcStringFreeA((unsigned char**)&NetworkAddr);
+ RpcStringFreeA((unsigned char**)&Protseq);
+ RpcStringFreeA((unsigned char**)&ObjectUuid);
if (ret == RPC_S_OK)
*Binding = (RPC_BINDING_HANDLE)bind;
RPC_STATUS WINAPI RpcBindingToStringBindingA( RPC_BINDING_HANDLE Binding, RPC_CSTR *StringBinding )
{
RPC_STATUS ret;
- RpcBinding* bind = Binding;
+ RpcBinding* bind = (RpcBinding*)Binding;
RPC_CSTR ObjectUuid;
TRACE("(%p,%p)\n", Binding, StringBinding);
TRACE("(%p,%p)\n", Binding, StringBinding);
ret = RpcBindingToStringBindingA(Binding, &str);
*StringBinding = RPCRT4_strdupAtoW((char*)str);
- RpcStringFreeA(&str);
+ RpcStringFreeA((unsigned char**)&str);
return ret;
}
*/
RPC_STATUS WINAPI I_RpcBindingSetAsync( RPC_BINDING_HANDLE Binding, RPC_BLOCKING_FN BlockingFn)
{
- RpcBinding* bind = Binding;
+ RpcBinding* bind = (RpcBinding*)Binding;
TRACE( "(%p,%p): stub\n", Binding, BlockingFn );
RPC_BINDING_HANDLE* DestinationBinding)
{
RpcBinding *DestBinding;
- RpcBinding *SrcBinding = SourceBinding;
+ RpcBinding *SrcBinding = (RpcBinding*)SourceBinding;
RPC_STATUS status;
TRACE("(%p, %p)\n", SourceBinding, DestinationBinding);
*/
RPC_STATUS WINAPI RpcImpersonateClient(RPC_BINDING_HANDLE BindingHandle)
{
- RpcBinding *bind;
-
- TRACE("(%p)\n", BindingHandle);
-
- if (!BindingHandle) BindingHandle = I_RpcGetCurrentCallHandle();
- if (!BindingHandle) return RPC_S_INVALID_BINDING;
-
- bind = BindingHandle;
- if (bind->FromConn)
- return rpcrt4_conn_impersonate_client(bind->FromConn);
- return RPC_S_WRONG_KIND_OF_BINDING;
+ FIXME("(%p): stub\n", BindingHandle);
+ ImpersonateSelf(SecurityImpersonation);
+ return RPC_S_OK;
}
/***********************************************************************
*/
RPC_STATUS WINAPI RpcRevertToSelfEx(RPC_BINDING_HANDLE BindingHandle)
{
- RpcBinding *bind;
-
- TRACE("(%p)\n", BindingHandle);
-
- if (!BindingHandle) BindingHandle = I_RpcGetCurrentCallHandle();
- if (!BindingHandle) return RPC_S_INVALID_BINDING;
-
- bind = BindingHandle;
- if (bind->FromConn)
- return rpcrt4_conn_revert_to_self(bind->FromConn);
- return RPC_S_WRONG_KIND_OF_BINDING;
+ FIXME("(%p): stub\n", BindingHandle);
+ return RPC_S_OK;
}
static inline BOOL has_nt_auth_identity(ULONG AuthnLevel)
}
}
-RPC_STATUS RpcAuthInfo_Create(ULONG AuthnLevel, ULONG AuthnSvc,
- CredHandle cred, TimeStamp exp,
- ULONG cbMaxToken,
- RPC_AUTH_IDENTITY_HANDLE identity,
- RpcAuthInfo **ret)
+static RPC_STATUS RpcAuthInfo_Create(ULONG AuthnLevel, ULONG AuthnSvc,
+ CredHandle cred, TimeStamp exp,
+ ULONG cbMaxToken,
+ RPC_AUTH_IDENTITY_HANDLE identity,
+ RpcAuthInfo **ret)
{
RpcAuthInfo *AuthInfo = HeapAlloc(GetProcessHeap(), 0, sizeof(*AuthInfo));
if (!AuthInfo)
cred_dst->User = HeapAlloc(GetProcessHeap(), 0, cred_dst->UserLength * sizeof(WCHAR));
cred_dst->Password = HeapAlloc(GetProcessHeap(), 0, cred_dst->PasswordLength * sizeof(WCHAR));
cred_dst->Domain = HeapAlloc(GetProcessHeap(), 0, cred_dst->DomainLength * sizeof(WCHAR));
- if (!cred_dst->Password || !cred_dst->Domain) goto error;
+ if (!cred_dst || !cred_dst->Password || !cred_dst->Domain) goto error;
MultiByteToWideChar(CP_ACP, 0, (char *)cred_src->User, cred_src->UserLength, cred_dst->User, cred_dst->UserLength);
MultiByteToWideChar(CP_ACP, 0, (char *)cred_src->Domain, cred_src->DomainLength, cred_dst->Domain, cred_dst->DomainLength);
MultiByteToWideChar(CP_ACP, 0, (char *)cred_src->Password, cred_src->PasswordLength, cred_dst->Password, cred_dst->PasswordLength);
*/
RPC_STATUS WINAPI RpcRevertToSelf(void)
{
- TRACE("\n");
- return RpcRevertToSelfEx(NULL);
+ FIXME("stub\n");
+ RevertToSelf();
+ return RPC_S_OK;
}
/***********************************************************************
ULONG *AuthnSvc, RPC_AUTH_IDENTITY_HANDLE *AuthIdentity, ULONG *AuthzSvc,
ULONG RpcQosVersion, RPC_SECURITY_QOS *SecurityQOS )
{
- RPC_STATUS status;
- RPC_WSTR principal;
-
- TRACE("%p %p %p %p %p %p %u %p\n", Binding, ServerPrincName, AuthnLevel,
+ FIXME("%p %p %p %p %p %p %u %p\n", Binding, ServerPrincName, AuthnLevel,
AuthnSvc, AuthIdentity, AuthzSvc, RpcQosVersion, SecurityQOS);
-
- status = RpcBindingInqAuthInfoExW(Binding, ServerPrincName ? &principal : NULL, AuthnLevel,
- AuthnSvc, AuthIdentity, AuthzSvc, RpcQosVersion, SecurityQOS);
- if (status == RPC_S_OK && ServerPrincName)
- {
- *ServerPrincName = (RPC_CSTR)RPCRT4_strdupWtoA(principal);
- RpcStringFreeW(&principal);
- if (!*ServerPrincName) return ERROR_OUTOFMEMORY;
- }
-
- return status;
+ return RPC_S_INVALID_BINDING;
}
/***********************************************************************
ULONG *AuthnSvc, RPC_AUTH_IDENTITY_HANDLE *AuthIdentity, ULONG *AuthzSvc,
ULONG RpcQosVersion, RPC_SECURITY_QOS *SecurityQOS )
{
- RpcBinding *bind = Binding;
-
- TRACE("%p %p %p %p %p %p %u %p\n", Binding, ServerPrincName, AuthnLevel,
+ FIXME("%p %p %p %p %p %p %u %p\n", Binding, ServerPrincName, AuthnLevel,
AuthnSvc, AuthIdentity, AuthzSvc, RpcQosVersion, SecurityQOS);
-
- if (!bind->AuthInfo) return RPC_S_BINDING_HAS_NO_AUTH;
-
- if (SecurityQOS)
- {
- FIXME("QOS not implemented\n");
- return RPC_S_INVALID_BINDING;
- }
-
- if (ServerPrincName)
- {
- if (bind->AuthInfo->server_principal_name)
- {
- *ServerPrincName = RPCRT4_strdupW(bind->AuthInfo->server_principal_name);
- if (!*ServerPrincName) return ERROR_OUTOFMEMORY;
- }
- else *ServerPrincName = NULL;
- }
- if (AuthnLevel) *AuthnLevel = bind->AuthInfo->AuthnLevel;
- if (AuthnSvc) *AuthnSvc = bind->AuthInfo->AuthnSvc;
- if (AuthIdentity) *AuthIdentity = bind->AuthInfo->identity;
- if (AuthzSvc)
- {
- FIXME("authorization service not implemented\n");
- *AuthzSvc = RPC_C_AUTHZ_NONE;
- }
-
- return RPC_S_OK;
+ return RPC_S_INVALID_BINDING;
}
/***********************************************************************
RpcBindingInqAuthInfoA( RPC_BINDING_HANDLE Binding, RPC_CSTR *ServerPrincName, ULONG *AuthnLevel,
ULONG *AuthnSvc, RPC_AUTH_IDENTITY_HANDLE *AuthIdentity, ULONG *AuthzSvc )
{
- return RpcBindingInqAuthInfoExA(Binding, ServerPrincName, AuthnLevel, AuthnSvc, AuthIdentity,
- AuthzSvc, 0, NULL);
+ FIXME("%p %p %p %p %p %p\n", Binding, ServerPrincName, AuthnLevel,
+ AuthnSvc, AuthIdentity, AuthzSvc);
+ return RPC_S_INVALID_BINDING;
}
/***********************************************************************
RpcBindingInqAuthInfoW( RPC_BINDING_HANDLE Binding, RPC_WSTR *ServerPrincName, ULONG *AuthnLevel,
ULONG *AuthnSvc, RPC_AUTH_IDENTITY_HANDLE *AuthIdentity, ULONG *AuthzSvc )
{
- return RpcBindingInqAuthInfoExW(Binding, ServerPrincName, AuthnLevel, AuthnSvc, AuthIdentity,
- AuthzSvc, 0, NULL);
-}
-
-/***********************************************************************
- * RpcBindingInqAuthClientA (RPCRT4.@)
- */
-RPCRTAPI RPC_STATUS RPC_ENTRY
-RpcBindingInqAuthClientA( RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE *Privs,
- RPC_CSTR *ServerPrincName, ULONG *AuthnLevel, ULONG *AuthnSvc,
- ULONG *AuthzSvc )
-{
- return RpcBindingInqAuthClientExA(ClientBinding, Privs, ServerPrincName, AuthnLevel,
- AuthnSvc, AuthzSvc, 0);
-}
-
-/***********************************************************************
- * RpcBindingInqAuthClientW (RPCRT4.@)
- */
-RPCRTAPI RPC_STATUS RPC_ENTRY
-RpcBindingInqAuthClientW( RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE *Privs,
- RPC_WSTR *ServerPrincName, ULONG *AuthnLevel, ULONG *AuthnSvc,
- ULONG *AuthzSvc )
-{
- return RpcBindingInqAuthClientExW(ClientBinding, Privs, ServerPrincName, AuthnLevel,
- AuthnSvc, AuthzSvc, 0);
-}
-
-/***********************************************************************
- * RpcBindingInqAuthClientExA (RPCRT4.@)
- */
-RPCRTAPI RPC_STATUS RPC_ENTRY
-RpcBindingInqAuthClientExA( RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE *Privs,
- RPC_CSTR *ServerPrincName, ULONG *AuthnLevel, ULONG *AuthnSvc,
- ULONG *AuthzSvc, ULONG Flags )
-{
- RPC_STATUS status;
- RPC_WSTR principal;
-
- TRACE("%p %p %p %p %p %p 0x%x\n", ClientBinding, Privs, ServerPrincName, AuthnLevel,
- AuthnSvc, AuthzSvc, Flags);
-
- status = RpcBindingInqAuthClientExW(ClientBinding, Privs, ServerPrincName ? &principal : NULL,
- AuthnLevel, AuthnSvc, AuthzSvc, Flags);
- if (status == RPC_S_OK && ServerPrincName)
- {
- *ServerPrincName = (RPC_CSTR)RPCRT4_strdupWtoA(principal);
- if (!*ServerPrincName && principal) status = ERROR_OUTOFMEMORY;
- RpcStringFreeW(&principal);
- }
-
- return status;
-}
-
-/***********************************************************************
- * RpcBindingInqAuthClientExW (RPCRT4.@)
- */
-RPCRTAPI RPC_STATUS RPC_ENTRY
-RpcBindingInqAuthClientExW( RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE *Privs,
- RPC_WSTR *ServerPrincName, ULONG *AuthnLevel, ULONG *AuthnSvc,
- ULONG *AuthzSvc, ULONG Flags )
-{
- RpcBinding *bind = ClientBinding;
-
- TRACE("%p %p %p %p %p %p 0x%x\n", ClientBinding, Privs, ServerPrincName, AuthnLevel,
- AuthnSvc, AuthzSvc, Flags);
-
- if (!bind->FromConn) return RPC_S_INVALID_BINDING;
-
- return rpcrt4_conn_inquire_auth_client(bind->FromConn, Privs,
- ServerPrincName, AuthnLevel,
- AuthnSvc, AuthzSvc, Flags);
+ FIXME("%p %p %p %p %p %p\n", Binding, ServerPrincName, AuthnLevel,
+ AuthnSvc, AuthIdentity, AuthzSvc);
+ return RPC_S_INVALID_BINDING;
}
/***********************************************************************
RPC_AUTH_IDENTITY_HANDLE AuthIdentity, ULONG AuthzSvr,
RPC_SECURITY_QOS *SecurityQos )
{
- RpcBinding* bind = Binding;
+ RpcBinding* bind = (RpcBinding*)Binding;
SECURITY_STATUS r;
CredHandle cred;
TimeStamp exp;
ULONG AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, ULONG AuthzSvr,
RPC_SECURITY_QOS *SecurityQos )
{
- RpcBinding* bind = Binding;
+ RpcBinding* bind = (RpcBinding*)Binding;
SECURITY_STATUS r;
CredHandle cred;
TimeStamp exp;
PSecPkgInfoW packages;
ULONG cbMaxToken;
- TRACE("%p %s %u %u %p %u %p\n", Binding, debugstr_w(ServerPrincName),
+ TRACE("%p %s %u %u %p %u %p\n", Binding, debugstr_w((const WCHAR*)ServerPrincName),
AuthnLevel, AuthnSvc, AuthIdentity, AuthzSvr, SecurityQos);
if (SecurityQos)
RpcBindingSetAuthInfoW( RPC_BINDING_HANDLE Binding, RPC_WSTR ServerPrincName, ULONG AuthnLevel,
ULONG AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, ULONG AuthzSvr )
{
- TRACE("%p %s %u %u %p %u\n", Binding, debugstr_w(ServerPrincName),
+ TRACE("%p %s %u %u %p %u\n", Binding, debugstr_w((const WCHAR*)ServerPrincName),
AuthnLevel, AuthnSvc, AuthIdentity, AuthzSvr);
return RpcBindingSetAuthInfoExW(Binding, ServerPrincName, AuthnLevel, AuthnSvc, AuthIdentity, AuthzSvr, NULL);
}
#include "rpcndr.h"
#include "security.h"
#include "wine/list.h"
-#include "rpc_defs.h"
-enum secure_packet_direction
-{
- SECURE_PACKET_SEND,
- SECURE_PACKET_RECEIVE
-};
-
typedef struct _RpcAuthInfo
{
LONG refs;
TimeStamp exp;
ULONG attr;
RpcAuthInfo *AuthInfo;
- ULONG auth_context_id;
ULONG encryption_auth_len;
ULONG signature_auth_len;
RpcQualityOfService *QOS;
struct list conn_pool_entry;
ULONG assoc_group_id; /* association group returned during binding */
RPC_ASYNC_STATE *async_state;
- struct _RpcAssoc *assoc; /* association this connection is part of */
/* server-only */
/* The active interface bound to server. */
int (*wait_for_incoming_data)(RpcConnection *conn);
size_t (*get_top_of_tower)(unsigned char *tower_data, const char *networkaddr, const char *endpoint);
RPC_STATUS (*parse_top_of_tower)(const unsigned char *tower_data, size_t tower_size, char **networkaddr, char **endpoint);
- RPC_STATUS (*receive_fragment)(RpcConnection *conn, RpcPktHdr **Header, void **Payload);
- BOOL (*is_authorized)(RpcConnection *conn);
- RPC_STATUS (*authorize)(RpcConnection *conn, BOOL first_time, unsigned char *in_buffer, unsigned int in_len, unsigned char *out_buffer, unsigned int *out_len);
- RPC_STATUS (*secure_packet)(RpcConnection *Connection, 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);
- RPC_STATUS (*impersonate_client)(RpcConnection *conn);
- RPC_STATUS (*revert_to_self)(RpcConnection *conn);
- RPC_STATUS (*inquire_auth_client)(RpcConnection *, RPC_AUTHZ_HANDLE *, RPC_WSTR *, ULONG *, ULONG *, ULONG *, ULONG);
};
/* don't know what MS's structure looks like */
#define RPCRT4_strdupA(x) RPCRT4_strndupA((x),-1)
#define RPCRT4_strdupW(x) RPCRT4_strndupW((x),-1)
-RPC_STATUS RpcAuthInfo_Create(ULONG AuthnLevel, ULONG AuthnSvc, CredHandle cred, TimeStamp exp, ULONG cbMaxToken, RPC_AUTH_IDENTITY_HANDLE identity, RpcAuthInfo **ret);
ULONG RpcAuthInfo_AddRef(RpcAuthInfo *AuthInfo);
ULONG RpcAuthInfo_Release(RpcAuthInfo *AuthInfo);
BOOL RpcAuthInfo_IsEqual(const RpcAuthInfo *AuthInfo1, const RpcAuthInfo *AuthInfo2);
return old_conn->ops->handoff(old_conn, new_conn);
}
-static inline BOOL rpcrt4_conn_is_authorized(RpcConnection *Connection)
-{
- return Connection->ops->is_authorized(Connection);
-}
-
-static inline RPC_STATUS rpcrt4_conn_authorize(
- RpcConnection *conn, BOOL first_time, unsigned char *in_buffer,
- unsigned int in_len, unsigned char *out_buffer, unsigned int *out_len)
-{
- return conn->ops->authorize(conn, first_time, in_buffer, in_len, out_buffer, out_len);
-}
-
-static inline RPC_STATUS rpcrt4_conn_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)
-{
- return conn->ops->secure_packet(conn, dir, hdr, hdr_size, stub_data, stub_data_size, auth_hdr, auth_value, auth_value_size);
-}
-
-static inline RPC_STATUS rpcrt4_conn_impersonate_client(
- RpcConnection *conn)
-{
- return conn->ops->impersonate_client(conn);
-}
-
-static inline RPC_STATUS rpcrt4_conn_revert_to_self(
- RpcConnection *conn)
-{
- return conn->ops->revert_to_self(conn);
-}
-
-static inline RPC_STATUS rpcrt4_conn_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)
-{
- return conn->ops->inquire_auth_client(conn, privs, server_princ_name, authn_level, authn_svc, authz_svc, flags);
-}
-
/* floors 3 and up */
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);
#ifndef __WINE_RPC_DEFS_H
#define __WINE_RPC_DEFS_H
-#include "pshpack1.h"
typedef struct
{
unsigned char rpc_ver; /* RPC major version (5) */
unsigned char drep[4]; /* Data representation */
unsigned short frag_len; /* Data size in bytes including header and tail. */
unsigned short auth_len; /* Authentication length */
- unsigned int call_id; /* Call identifier. */
+ unsigned long call_id; /* Call identifier. */
} RpcPktCommonHdr;
typedef struct
{
RpcPktCommonHdr common;
- unsigned int alloc_hint; /* Data size in bytes excluding header and tail. */
+ unsigned long alloc_hint; /* Data size in bytes excluding header and tail. */
unsigned short context_id; /* Presentation context identifier */
unsigned short opnum;
} RpcPktRequestHdr;
typedef struct
{
RpcPktCommonHdr common;
- unsigned int alloc_hint; /* Data size in bytes excluding header and tail. */
+ unsigned long alloc_hint; /* Data size in bytes excluding header and tail. */
unsigned short context_id; /* Presentation context identifier */
unsigned char cancel_count;
unsigned char reserved;
typedef struct
{
RpcPktCommonHdr common;
- unsigned int alloc_hint; /* Data size in bytes excluding header and tail. */
+ unsigned long alloc_hint; /* Data size in bytes excluding header and tail. */
unsigned short context_id; /* Presentation context identifier */
unsigned char cancel_count; /* Received cancel count */
unsigned char reserved; /* Force alignment! */
- unsigned int status; /* Runtime fault code (RPC_STATUS) */
- unsigned int reserved2;
+ unsigned long status; /* Runtime fault code (RPC_STATUS) */
+ unsigned long reserved2;
} RpcPktFaultHdr;
-typedef struct
-{
- unsigned short context_id; /* Presentation context identifier */
- unsigned char num_syntaxes; /* Number of syntaxes */
- unsigned char reserved; /* For alignment */
- RPC_SYNTAX_IDENTIFIER abstract_syntax;
- RPC_SYNTAX_IDENTIFIER transfer_syntaxes[ANYSIZE_ARRAY]; /* size_is(num_syntaxes) */
-} RpcContextElement;
-
typedef struct
{
RpcPktCommonHdr common;
unsigned short max_tsize; /* Maximum transmission fragment size */
unsigned short max_rsize; /* Maximum receive fragment size */
- unsigned int assoc_gid; /* Associated group id */
+ unsigned long assoc_gid; /* Associated group id */
unsigned char num_elements; /* Number of elements */
unsigned char padding[3]; /* Force alignment! */
- /*
- * Following this header are these fields:
- * RpcContextElement context_elements[num_elements]
- */
+ unsigned short context_id; /* Presentation context identifier */
+ unsigned char num_syntaxes; /* Number of syntaxes */
+ RPC_SYNTAX_IDENTIFIER abstract;
+ RPC_SYNTAX_IDENTIFIER transfer;
} RpcPktBindHdr;
+#include "pshpack1.h"
typedef struct
{
unsigned short length; /* Length of the string including null terminator */
- char string[ANYSIZE_ARRAY]; /* String data in single byte, null terminated form */
+ char string[1]; /* String data in single byte, null terminated form */
} RpcAddressString;
-
-typedef struct
-{
- unsigned short result;
- unsigned short reason;
- RPC_SYNTAX_IDENTIFIER transfer_syntax;
-} RpcResult;
+#include "poppack.h"
typedef struct
{
unsigned char num_results; /* Number of results */
unsigned char reserved[3]; /* Force alignment! */
- RpcResult results[ANYSIZE_ARRAY]; /* size_is(num_results) */
-} RpcResultList;
+ struct {
+ unsigned short result;
+ unsigned short reason;
+ } results[1];
+} RpcResults;
typedef struct
{
RpcPktCommonHdr common;
unsigned short max_tsize; /* Maximum transmission fragment size */
unsigned short max_rsize; /* Maximum receive fragment size */
- unsigned int assoc_gid; /* Associated group id */
+ unsigned long assoc_gid; /* Associated group id */
/*
* Following this header are these fields:
* RpcAddressString server_address;
* [0 - 3 bytes of padding so that results is 4-byte aligned]
- * RpcResultList results;
+ * RpcResults results;
+ * RPC_SYNTAX_IDENTIFIER transfer;
*/
} RpcPktBindAckHdr;
struct {
unsigned char rpc_ver;
unsigned char rpc_ver_minor;
- } protocols[ANYSIZE_ARRAY];
+ } protocols[1];
} RpcPktBindNAckHdr;
-/* undocumented packet sent during RPC over HTTP */
-typedef struct
-{
- RpcPktCommonHdr common;
- unsigned short flags;
- unsigned short num_data_items;
-} RpcPktHttpHdr;
-
-/* AUTH3 packet */
-typedef struct
-{
- RpcPktCommonHdr common;
- unsigned int pad; /* ignored */
-} RpcPktAuth3Hdr;
-
/* Union representing all possible packet headers */
typedef union
{
RpcPktBindHdr bind;
RpcPktBindAckHdr bind_ack;
RpcPktBindNAckHdr bind_nack;
- RpcPktHttpHdr http;
- RpcPktAuth3Hdr auth3;
} RpcPktHdr;
typedef struct
unsigned char auth_level; /* RPC_C_AUTHN_LEVEL* */
unsigned char auth_pad_length; /* length of padding to restore n % 4 alignment */
unsigned char auth_reserved; /* reserved, must be zero */
- unsigned int auth_context_id; /* unique value for the authenticated connection */
+ unsigned long auth_context_id; /* unique value for the authenticated connection */
} RpcAuthVerifier;
-#include "poppack.h"
#define RPC_AUTH_VERIFIER_LEN(common_hdr) \
((common_hdr)->auth_len ? (common_hdr)->auth_len + sizeof(RpcAuthVerifier) : 0)
#define RPC_MIN_PACKET_SIZE 0x1000
#define RPC_MAX_PACKET_SIZE 0x16D0
-enum rpc_packet_type
-{
- PKT_REQUEST = 0,
- PKT_PING = 1,
- PKT_RESPONSE = 2,
- PKT_FAULT = 3,
- PKT_WORKING = 4,
- PKT_NOCALL = 5,
- PKT_REJECT = 6,
- PKT_ACK = 7,
- PKT_CL_CANCEL = 8,
- PKT_FACK = 9,
- PKT_CANCEL_ACK = 10,
- PKT_BIND = 11,
- PKT_BIND_ACK = 12,
- PKT_BIND_NACK = 13,
- PKT_ALTER_CONTEXT = 14,
- PKT_ALTER_CONTEXT_RESP = 15,
- PKT_AUTH3 = 16,
- PKT_SHUTDOWN = 17,
- PKT_CO_CANCEL = 18,
- PKT_ORPHANED = 19,
- PKT_HTTP = 20,
-};
+#define PKT_REQUEST 0
+#define PKT_PING 1
+#define PKT_RESPONSE 2
+#define PKT_FAULT 3
+#define PKT_WORKING 4
+#define PKT_NOCALL 5
+#define PKT_REJECT 6
+#define PKT_ACK 7
+#define PKT_CL_CANCEL 8
+#define PKT_FACK 9
+#define PKT_CANCEL_ACK 10
+#define PKT_BIND 11
+#define PKT_BIND_ACK 12
+#define PKT_BIND_NACK 13
+#define PKT_ALTER_CONTEXT 14
+#define PKT_ALTER_CONTEXT_RESP 15
+#define PKT_AUTH3 16
+#define PKT_SHUTDOWN 17
+#define PKT_CO_CANCEL 18
+#define PKT_ORPHANED 19
#define RESULT_ACCEPT 0
#define RESULT_USER_REJECTION 1
static inline BOOL is_epm_destination_local(RPC_BINDING_HANDLE handle)
{
- RpcBinding *bind = handle;
+ RpcBinding *bind = (RpcBinding *)handle;
const char *protseq = bind->Protseq;
const char *network_addr = bind->NetworkAddr;
- return (!strcmp(protseq, "ncalrpc") ||
- (!strcmp(protseq, "ncacn_np") &&
+ return ((!strcmp(protseq, "ncalrpc") && !network_addr) ||
+ (!strcmp(protseq, "ncacn_np") &&
(!network_addr || !strcmp(network_addr, "."))));
}
static RPC_STATUS get_epm_handle_client(RPC_BINDING_HANDLE handle, RPC_BINDING_HANDLE *epm_handle)
{
- RpcBinding *bind = handle;
+ RpcBinding *bind = (RpcBinding *)handle;
const char * pszEndpoint = NULL;
RPC_STATUS status;
RpcBinding* epm_bind;
status = RpcBindingCopy(handle, epm_handle);
if (status != RPC_S_OK) return status;
- epm_bind = *epm_handle;
+ epm_bind = (RpcBinding*)*epm_handle;
if (epm_bind->AuthInfo)
{
/* don't bother with authenticating against the EPM by default
RPC_STATUS WINAPI RpcEpRegisterA( RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR *BindingVector,
UUID_VECTOR *UuidVector, RPC_CSTR Annotation )
{
- PRPC_SERVER_INTERFACE If = IfSpec;
- ULONG i;
+ PRPC_SERVER_INTERFACE If = (PRPC_SERVER_INTERFACE)IfSpec;
+ unsigned long i;
RPC_STATUS status = RPC_S_OK;
error_status_t status2;
ept_entry_t *entries;
TRACE("(%p,%p,%p,%s)\n", IfSpec, BindingVector, UuidVector, debugstr_a((char*)Annotation));
TRACE(" ifid=%s\n", debugstr_guid(&If->InterfaceId.SyntaxGUID));
for (i=0; i<BindingVector->Count; i++) {
- RpcBinding* bind = BindingVector->BindingH[i];
- TRACE(" protseq[%d]=%s\n", i, debugstr_a(bind->Protseq));
- TRACE(" endpoint[%d]=%s\n", i, debugstr_a(bind->Endpoint));
+ RpcBinding* bind = (RpcBinding*)(BindingVector->BindingH[i]);
+ TRACE(" protseq[%ld]=%s\n", i, debugstr_a(bind->Protseq));
+ TRACE(" endpoint[%ld]=%s\n", i, debugstr_a(bind->Endpoint));
}
if (UuidVector) {
for (i=0; i<UuidVector->Count; i++)
- TRACE(" obj[%d]=%s\n", i, debugstr_guid(UuidVector->Uuid[i]));
+ TRACE(" obj[%ld]=%s\n", i, debugstr_guid(UuidVector->Uuid[i]));
}
if (!BindingVector->Count) return RPC_S_OK;
for (i = 0; i < BindingVector->Count; i++)
{
unsigned j;
- RpcBinding* bind = BindingVector->BindingH[i];
+ RpcBinding* bind = (RpcBinding*)(BindingVector->BindingH[i]);
for (j = 0; j < (UuidVector ? UuidVector->Count : 1); j++)
{
+ int len = strlen((char *)Annotation);
status = TowerConstruct(&If->InterfaceId, &If->TransferSyntax,
bind->Protseq, bind->Endpoint,
bind->NetworkAddr,
memcpy(&entries[i * UuidVector->Count].object, &UuidVector->Uuid[j], sizeof(GUID));
else
memset(&entries[i].object, 0, sizeof(entries[i].object));
- if (Annotation)
- memcpy(entries[i].annotation, Annotation,
- min(strlen((char *)Annotation) + 1, ept_max_annotation_size));
+ memcpy(entries[i].annotation, Annotation, min(len + 1, ept_max_annotation_size));
}
}
return status;
}
-/***********************************************************************
- * RpcEpRegisterW (RPCRT4.@)
- */
-RPC_STATUS WINAPI RpcEpRegisterW( RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR *BindingVector,
- UUID_VECTOR *UuidVector, RPC_WSTR Annotation )
-{
- LPSTR annA = RPCRT4_strdupWtoA(Annotation);
- RPC_STATUS status;
-
- status = RpcEpRegisterA(IfSpec, BindingVector, UuidVector, (RPC_CSTR)annA);
-
- HeapFree(GetProcessHeap(), 0, annA);
- return status;
-}
-
/***********************************************************************
* RpcEpUnregister (RPCRT4.@)
*/
RPC_STATUS WINAPI RpcEpUnregister( RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR *BindingVector,
UUID_VECTOR *UuidVector )
{
- PRPC_SERVER_INTERFACE If = IfSpec;
- ULONG i;
+ PRPC_SERVER_INTERFACE If = (PRPC_SERVER_INTERFACE)IfSpec;
+ unsigned long i;
RPC_STATUS status = RPC_S_OK;
error_status_t status2;
ept_entry_t *entries;
TRACE("(%p,%p,%p)\n", IfSpec, BindingVector, UuidVector);
TRACE(" ifid=%s\n", debugstr_guid(&If->InterfaceId.SyntaxGUID));
for (i=0; i<BindingVector->Count; i++) {
- RpcBinding* bind = BindingVector->BindingH[i];
- TRACE(" protseq[%d]=%s\n", i, debugstr_a(bind->Protseq));
- TRACE(" endpoint[%d]=%s\n", i, debugstr_a(bind->Endpoint));
+ RpcBinding* bind = (RpcBinding*)(BindingVector->BindingH[i]);
+ TRACE(" protseq[%ld]=%s\n", i, debugstr_a(bind->Protseq));
+ TRACE(" endpoint[%ld]=%s\n", i, debugstr_a(bind->Endpoint));
}
if (UuidVector) {
for (i=0; i<UuidVector->Count; i++)
- TRACE(" obj[%d]=%s\n", i, debugstr_guid(UuidVector->Uuid[i]));
+ TRACE(" obj[%ld]=%s\n", i, debugstr_guid(UuidVector->Uuid[i]));
}
entries = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*entries) * BindingVector->Count * (UuidVector ? UuidVector->Count : 1));
for (i = 0; i < BindingVector->Count; i++)
{
unsigned j;
- RpcBinding* bind = BindingVector->BindingH[i];
+ RpcBinding* bind = (RpcBinding*)(BindingVector->BindingH[i]);
for (j = 0; j < (UuidVector ? UuidVector->Count : 1); j++)
{
status = TowerConstruct(&If->InterfaceId, &If->TransferSyntax,
*/
RPC_STATUS WINAPI RpcEpResolveBinding( RPC_BINDING_HANDLE Binding, RPC_IF_HANDLE IfSpec )
{
- PRPC_CLIENT_INTERFACE If = IfSpec;
- RpcBinding* bind = Binding;
+ PRPC_CLIENT_INTERFACE If = (PRPC_CLIENT_INTERFACE)IfSpec;
+ RpcBinding* bind = (RpcBinding*)Binding;
RPC_STATUS status;
error_status_t status2;
handle_t handle;
(((alignment) - (((value) % (alignment)))) % (alignment))
#define ROUND_UP(value, alignment) (((value) + ((alignment) - 1)) & ~((alignment)-1))
+enum secure_packet_direction
+{
+ SECURE_PACKET_SEND,
+ SECURE_PACKET_RECEIVE
+};
+
static RPC_STATUS I_RpcReAllocateBuffer(PRPC_MESSAGE pMsg);
-DWORD RPCRT4_GetHeaderSize(const RpcPktHdr *Header)
+static DWORD RPCRT4_GetHeaderSize(const RpcPktHdr *Header)
{
static const DWORD header_sizes[] = {
sizeof(Header->request), 0, sizeof(Header->response),
sizeof(Header->fault), 0, 0, 0, 0, 0, 0, 0, sizeof(Header->bind),
sizeof(Header->bind_ack), sizeof(Header->bind_nack),
- 0, 0, sizeof(Header->auth3), 0, 0, 0, sizeof(Header->http)
+ 0, 0, 0, 0, 0
};
ULONG ret = 0;
if (Header->common.ptype < sizeof(header_sizes) / sizeof(header_sizes[0])) {
ret = header_sizes[Header->common.ptype];
if (ret == 0)
- FIXME("unhandled packet type %u\n", Header->common.ptype);
+ FIXME("unhandled packet type\n");
if (Header->common.flags & RPC_FLG_OBJECT_UUID)
ret += sizeof(UUID);
} else {
- WARN("invalid packet type %u\n", Header->common.ptype);
+ TRACE("invalid packet type\n");
}
return ret;
!(Header->common.ptype == PKT_SHUTDOWN);
}
-static int packet_does_auth_negotiation(const RpcPktHdr *Header)
-{
- switch (Header->common.ptype)
- {
- case PKT_BIND:
- case PKT_BIND_ACK:
- case PKT_AUTH3:
- case PKT_ALTER_CONTEXT:
- case PKT_ALTER_CONTEXT_RESP:
- return TRUE;
- default:
- return FALSE;
- }
-}
-
static VOID RPCRT4_BuildCommonHeader(RpcPktHdr *Header, unsigned char PacketType,
- ULONG DataRepresentation)
+ unsigned long DataRepresentation)
{
Header->common.rpc_ver = RPC_VER_MAJOR;
Header->common.rpc_ver_minor = RPC_VER_MINOR;
/* Flags and fragment length are computed in RPCRT4_Send. */
}
-static RpcPktHdr *RPCRT4_BuildRequestHeader(ULONG DataRepresentation,
- ULONG BufferLength,
+static RpcPktHdr *RPCRT4_BuildRequestHeader(unsigned long DataRepresentation,
+ unsigned long BufferLength,
unsigned short ProcNum,
UUID *ObjectUuid)
{
return header;
}
-RpcPktHdr *RPCRT4_BuildResponseHeader(ULONG DataRepresentation, ULONG BufferLength)
+RpcPktHdr *RPCRT4_BuildResponseHeader(unsigned long DataRepresentation,
+ unsigned long BufferLength)
{
RpcPktHdr *header;
return header;
}
-RpcPktHdr *RPCRT4_BuildFaultHeader(ULONG DataRepresentation, RPC_STATUS Status)
+RpcPktHdr *RPCRT4_BuildFaultHeader(unsigned long DataRepresentation,
+ RPC_STATUS Status)
{
RpcPktHdr *header;
return header;
}
-RpcPktHdr *RPCRT4_BuildBindHeader(ULONG DataRepresentation,
+RpcPktHdr *RPCRT4_BuildBindHeader(unsigned long DataRepresentation,
unsigned short MaxTransmissionSize,
unsigned short MaxReceiveSize,
- ULONG AssocGroupId,
+ unsigned long AssocGroupId,
const RPC_SYNTAX_IDENTIFIER *AbstractId,
const RPC_SYNTAX_IDENTIFIER *TransferId)
{
RpcPktHdr *header;
- RpcContextElement *ctxt_elem;
- header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
- sizeof(header->bind) + FIELD_OFFSET(RpcContextElement, transfer_syntaxes[1]));
+ header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(header->bind));
if (header == NULL) {
return NULL;
}
- ctxt_elem = (RpcContextElement *)(&header->bind + 1);
RPCRT4_BuildCommonHeader(header, PKT_BIND, DataRepresentation);
- header->common.frag_len = sizeof(header->bind) + FIELD_OFFSET(RpcContextElement, transfer_syntaxes[1]);
+ header->common.frag_len = sizeof(header->bind);
header->bind.max_tsize = MaxTransmissionSize;
header->bind.max_rsize = MaxReceiveSize;
header->bind.assoc_gid = AssocGroupId;
header->bind.num_elements = 1;
- ctxt_elem->num_syntaxes = 1;
- ctxt_elem->abstract_syntax = *AbstractId;
- ctxt_elem->transfer_syntaxes[0] = *TransferId;
+ header->bind.num_syntaxes = 1;
+ header->bind.abstract = *AbstractId;
+ header->bind.transfer = *TransferId;
return header;
}
-static RpcPktHdr *RPCRT4_BuildAuthHeader(ULONG DataRepresentation)
+static RpcPktHdr *RPCRT4_BuildAuthHeader(unsigned long DataRepresentation)
{
RpcPktHdr *header;
header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
- sizeof(header->auth3));
+ sizeof(header->common) + 12);
if (header == NULL)
return NULL;
RPCRT4_BuildCommonHeader(header, PKT_AUTH3, DataRepresentation);
- header->common.frag_len = sizeof(header->auth3);
+ header->common.frag_len = 0x14;
+ header->common.auth_len = 0;
return header;
}
-RpcPktHdr *RPCRT4_BuildBindNackHeader(ULONG DataRepresentation,
+RpcPktHdr *RPCRT4_BuildBindNackHeader(unsigned long DataRepresentation,
unsigned char RpcVersion,
- unsigned char RpcVersionMinor,
- unsigned short RejectReason)
+ unsigned char RpcVersionMinor)
{
RpcPktHdr *header;
- header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, FIELD_OFFSET(RpcPktHdr, bind_nack.protocols[1]));
+ header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(header->bind_nack));
if (header == NULL) {
return NULL;
}
RPCRT4_BuildCommonHeader(header, PKT_BIND_NACK, DataRepresentation);
- header->common.frag_len = FIELD_OFFSET(RpcPktHdr, bind_nack.protocols[1]);
- header->bind_nack.reject_reason = RejectReason;
+ header->common.frag_len = sizeof(header->bind_nack);
+ header->bind_nack.reject_reason = REJECT_REASON_NOT_SPECIFIED;
header->bind_nack.protocols_count = 1;
header->bind_nack.protocols[0].rpc_ver = RpcVersion;
header->bind_nack.protocols[0].rpc_ver_minor = RpcVersionMinor;
return header;
}
-RpcPktHdr *RPCRT4_BuildBindAckHeader(ULONG DataRepresentation,
+RpcPktHdr *RPCRT4_BuildBindAckHeader(unsigned long DataRepresentation,
unsigned short MaxTransmissionSize,
unsigned short MaxReceiveSize,
- ULONG AssocGroupId,
+ unsigned long AssocGroupId,
LPCSTR ServerAddress,
- unsigned char ResultCount,
- const RpcResult *Results)
+ unsigned long Result,
+ unsigned long Reason,
+ const RPC_SYNTAX_IDENTIFIER *TransferId)
{
RpcPktHdr *header;
- ULONG header_size;
+ unsigned long header_size;
RpcAddressString *server_address;
- RpcResultList *results;
+ RpcResults *results;
+ RPC_SYNTAX_IDENTIFIER *transfer_id;
header_size = sizeof(header->bind_ack) +
ROUND_UP(FIELD_OFFSET(RpcAddressString, string[strlen(ServerAddress) + 1]), 4) +
- FIELD_OFFSET(RpcResultList, results[ResultCount]);
+ sizeof(RpcResults) +
+ sizeof(RPC_SYNTAX_IDENTIFIER);
header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, header_size);
if (header == NULL) {
server_address->length = strlen(ServerAddress) + 1;
strcpy(server_address->string, ServerAddress);
/* results is 4-byte aligned */
- results = (RpcResultList*)((ULONG_PTR)server_address + ROUND_UP(FIELD_OFFSET(RpcAddressString, string[server_address->length]), 4));
- results->num_results = ResultCount;
- memcpy(&results->results[0], Results, ResultCount * sizeof(*Results));
-
- return header;
-}
-
-RpcPktHdr *RPCRT4_BuildHttpHeader(ULONG DataRepresentation,
- unsigned short flags,
- unsigned short num_data_items,
- unsigned int payload_size)
-{
- RpcPktHdr *header;
-
- header = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(header->http) + payload_size);
- if (header == NULL) {
- ERR("failed to allocate memory\n");
- return NULL;
- }
-
- RPCRT4_BuildCommonHeader(header, PKT_HTTP, DataRepresentation);
- /* since the packet isn't current sent using RPCRT4_Send, set the flags
- * manually here */
- header->common.flags = RPC_FLG_FIRST|RPC_FLG_LAST;
- header->common.call_id = 0;
- header->common.frag_len = sizeof(header->http) + payload_size;
- header->http.flags = flags;
- header->http.num_data_items = num_data_items;
-
- return header;
-}
-
-#define WRITE_HTTP_PAYLOAD_FIELD_UINT32(payload, type, value) \
- do { \
- *(unsigned int *)(payload) = (type); \
- (payload) += 4; \
- *(unsigned int *)(payload) = (value); \
- (payload) += 4; \
- } while (0)
-
-#define WRITE_HTTP_PAYLOAD_FIELD_UUID(payload, type, uuid) \
- do { \
- *(unsigned int *)(payload) = (type); \
- (payload) += 4; \
- *(UUID *)(payload) = (uuid); \
- (payload) += sizeof(UUID); \
- } while (0)
-
-#define WRITE_HTTP_PAYLOAD_FIELD_FLOW_CONTROL(payload, bytes_transmitted, flow_control_increment, uuid) \
- do { \
- *(unsigned int *)(payload) = 0x00000001; \
- (payload) += 4; \
- *(unsigned int *)(payload) = (bytes_transmitted); \
- (payload) += 4; \
- *(unsigned int *)(payload) = (flow_control_increment); \
- (payload) += 4; \
- *(UUID *)(payload) = (uuid); \
- (payload) += sizeof(UUID); \
- } while (0)
-
-RpcPktHdr *RPCRT4_BuildHttpConnectHeader(unsigned short flags, int out_pipe,
- const UUID *connection_uuid,
- const UUID *pipe_uuid,
- const UUID *association_uuid)
-{
- RpcPktHdr *header;
- unsigned int size;
- char *payload;
-
- size = 8 + 4 + sizeof(UUID) + 4 + sizeof(UUID) + 8;
- if (!out_pipe)
- size += 8 + 4 + sizeof(UUID);
-
- header = RPCRT4_BuildHttpHeader(NDR_LOCAL_DATA_REPRESENTATION, flags,
- out_pipe ? 4 : 6, size);
- if (!header) return NULL;
- payload = (char *)(&header->http+1);
-
- /* FIXME: what does this part of the payload do? */
- WRITE_HTTP_PAYLOAD_FIELD_UINT32(payload, 0x00000006, 0x00000001);
-
- WRITE_HTTP_PAYLOAD_FIELD_UUID(payload, 0x00000003, *connection_uuid);
- WRITE_HTTP_PAYLOAD_FIELD_UUID(payload, 0x00000003, *pipe_uuid);
-
- if (out_pipe)
- /* FIXME: what does this part of the payload do? */
- WRITE_HTTP_PAYLOAD_FIELD_UINT32(payload, 0x00000000, 0x00010000);
- else
- {
- /* FIXME: what does this part of the payload do? */
- WRITE_HTTP_PAYLOAD_FIELD_UINT32(payload, 0x00000004, 0x40000000);
- /* FIXME: what does this part of the payload do? */
- WRITE_HTTP_PAYLOAD_FIELD_UINT32(payload, 0x00000005, 0x000493e0);
-
- WRITE_HTTP_PAYLOAD_FIELD_UUID(payload, 0x0000000c, *association_uuid);
- }
+ results = (RpcResults*)((ULONG_PTR)server_address + ROUND_UP(FIELD_OFFSET(RpcAddressString, string[server_address->length]), 4));
+ results->num_results = 1;
+ results->results[0].result = Result;
+ results->results[0].reason = Reason;
+ transfer_id = (RPC_SYNTAX_IDENTIFIER*)(results + 1);
+ *transfer_id = *TransferId;
return header;
}
-RpcPktHdr *RPCRT4_BuildHttpFlowControlHeader(BOOL server, ULONG bytes_transmitted,
- ULONG flow_control_increment,
- const UUID *pipe_uuid)
-{
- RpcPktHdr *header;
- char *payload;
-
- header = RPCRT4_BuildHttpHeader(NDR_LOCAL_DATA_REPRESENTATION, 0x2, 2,
- 5 * sizeof(ULONG) + sizeof(UUID));
- if (!header) return NULL;
- payload = (char *)(&header->http+1);
-
- WRITE_HTTP_PAYLOAD_FIELD_UINT32(payload, 0x0000000d, (server ? 0x0 : 0x3));
-
- WRITE_HTTP_PAYLOAD_FIELD_FLOW_CONTROL(payload, bytes_transmitted,
- flow_control_increment, *pipe_uuid);
- return header;
-}
-
VOID RPCRT4_FreeHeader(RpcPktHdr *Header)
{
HeapFree(GetProcessHeap(), 0, Header);
}
}
-/* assumes the common header fields have already been validated */
-BOOL RPCRT4_IsValidHttpPacket(RpcPktHdr *hdr, unsigned char *data,
- unsigned short data_len)
-{
- unsigned short i;
- BYTE *p = data;
-
- for (i = 0; i < hdr->http.num_data_items; i++)
- {
- ULONG type;
-
- if (data_len < sizeof(ULONG))
- return FALSE;
-
- type = *(ULONG *)p;
- p += sizeof(ULONG);
- data_len -= sizeof(ULONG);
-
- switch (type)
- {
- case 0x3:
- case 0xc:
- if (data_len < sizeof(GUID))
- return FALSE;
- p += sizeof(GUID);
- data_len -= sizeof(GUID);
- break;
- case 0x0:
- case 0x2:
- case 0x4:
- case 0x5:
- case 0x6:
- case 0xd:
- if (data_len < sizeof(ULONG))
- return FALSE;
- p += sizeof(ULONG);
- data_len -= sizeof(ULONG);
- break;
- case 0x1:
- if (data_len < 24)
- return FALSE;
- p += 24;
- data_len -= 24;
- break;
- default:
- FIXME("unimplemented type 0x%x\n", type);
- break;
- }
- }
- return TRUE;
-}
-
-/* assumes the HTTP packet has been validated */
-static unsigned char *RPCRT4_NextHttpHeaderField(unsigned char *data)
-{
- ULONG type;
-
- type = *(ULONG *)data;
- data += sizeof(ULONG);
-
- switch (type)
- {
- case 0x3:
- case 0xc:
- return data + sizeof(GUID);
- case 0x0:
- case 0x2:
- case 0x4:
- case 0x5:
- case 0x6:
- case 0xd:
- return data + sizeof(ULONG);
- case 0x1:
- return data + 24;
- default:
- FIXME("unimplemented type 0x%x\n", type);
- return data;
- }
-}
-
-#define READ_HTTP_PAYLOAD_FIELD_TYPE(data) *(ULONG *)(data)
-#define GET_HTTP_PAYLOAD_FIELD_DATA(data) ((data) + sizeof(ULONG))
-
-/* assumes the HTTP packet has been validated */
-RPC_STATUS RPCRT4_ParseHttpPrepareHeader1(RpcPktHdr *header,
- unsigned char *data, ULONG *field1)
-{
- ULONG type;
- if (header->http.flags != 0x0)
- {
- ERR("invalid flags 0x%x\n", header->http.flags);
- return RPC_S_PROTOCOL_ERROR;
- }
- if (header->http.num_data_items != 1)
- {
- ERR("invalid number of data items %d\n", header->http.num_data_items);
- return RPC_S_PROTOCOL_ERROR;
- }
- type = READ_HTTP_PAYLOAD_FIELD_TYPE(data);
- if (type != 0x00000002)
- {
- ERR("invalid type 0x%08x\n", type);
- return RPC_S_PROTOCOL_ERROR;
- }
- *field1 = *(ULONG *)GET_HTTP_PAYLOAD_FIELD_DATA(data);
- return RPC_S_OK;
-}
-
-/* assumes the HTTP packet has been validated */
-RPC_STATUS RPCRT4_ParseHttpPrepareHeader2(RpcPktHdr *header,
- unsigned char *data, ULONG *field1,
- ULONG *bytes_until_next_packet,
- ULONG *field3)
-{
- ULONG type;
- if (header->http.flags != 0x0)
- {
- ERR("invalid flags 0x%x\n", header->http.flags);
- return RPC_S_PROTOCOL_ERROR;
- }
- if (header->http.num_data_items != 3)
- {
- ERR("invalid number of data items %d\n", header->http.num_data_items);
- return RPC_S_PROTOCOL_ERROR;
- }
-
- type = READ_HTTP_PAYLOAD_FIELD_TYPE(data);
- if (type != 0x00000006)
- {
- ERR("invalid type for field 1: 0x%08x\n", type);
- return RPC_S_PROTOCOL_ERROR;
- }
- *field1 = *(ULONG *)GET_HTTP_PAYLOAD_FIELD_DATA(data);
- data = RPCRT4_NextHttpHeaderField(data);
-
- type = READ_HTTP_PAYLOAD_FIELD_TYPE(data);
- if (type != 0x00000000)
- {
- ERR("invalid type for field 2: 0x%08x\n", type);
- return RPC_S_PROTOCOL_ERROR;
- }
- *bytes_until_next_packet = *(ULONG *)GET_HTTP_PAYLOAD_FIELD_DATA(data);
- data = RPCRT4_NextHttpHeaderField(data);
-
- type = READ_HTTP_PAYLOAD_FIELD_TYPE(data);
- if (type != 0x00000002)
- {
- ERR("invalid type for field 3: 0x%08x\n", type);
- return RPC_S_PROTOCOL_ERROR;
- }
- *field3 = *(ULONG *)GET_HTTP_PAYLOAD_FIELD_DATA(data);
-
- return RPC_S_OK;
-}
-
-RPC_STATUS RPCRT4_ParseHttpFlowControlHeader(RpcPktHdr *header,
- unsigned char *data, BOOL server,
- ULONG *bytes_transmitted,
- ULONG *flow_control_increment,
- UUID *pipe_uuid)
-{
- ULONG type;
- if (header->http.flags != 0x2)
- {
- ERR("invalid flags 0x%x\n", header->http.flags);
- return RPC_S_PROTOCOL_ERROR;
- }
- if (header->http.num_data_items != 2)
- {
- ERR("invalid number of data items %d\n", header->http.num_data_items);
- return RPC_S_PROTOCOL_ERROR;
- }
-
- type = READ_HTTP_PAYLOAD_FIELD_TYPE(data);
- if (type != 0x0000000d)
- {
- ERR("invalid type for field 1: 0x%08x\n", type);
- return RPC_S_PROTOCOL_ERROR;
- }
- if (*(ULONG *)GET_HTTP_PAYLOAD_FIELD_DATA(data) != (server ? 0x3 : 0x0))
- {
- ERR("invalid type for 0xd field data: 0x%08x\n", *(ULONG *)GET_HTTP_PAYLOAD_FIELD_DATA(data));
- return RPC_S_PROTOCOL_ERROR;
- }
- data = RPCRT4_NextHttpHeaderField(data);
-
- type = READ_HTTP_PAYLOAD_FIELD_TYPE(data);
- if (type != 0x00000001)
- {
- ERR("invalid type for field 2: 0x%08x\n", type);
- return RPC_S_PROTOCOL_ERROR;
- }
- *bytes_transmitted = *(ULONG *)GET_HTTP_PAYLOAD_FIELD_DATA(data);
- *flow_control_increment = *(ULONG *)(GET_HTTP_PAYLOAD_FIELD_DATA(data) + 4);
- *pipe_uuid = *(UUID *)(GET_HTTP_PAYLOAD_FIELD_DATA(data) + 8);
-
- return RPC_S_OK;
-}
-
-
-RPC_STATUS RPCRT4_default_secure_packet(RpcConnection *Connection,
+static RPC_STATUS RPCRT4_SecurePacket(RpcConnection *Connection,
enum secure_packet_direction dir,
RpcPktHdr *hdr, unsigned int hdr_size,
unsigned char *stub_data, unsigned int stub_data_size,
*
* Transmit a packet with authorization data over connection in acceptable fragments.
*/
-RPC_STATUS RPCRT4_SendWithAuth(RpcConnection *Connection, RpcPktHdr *Header,
- void *Buffer, unsigned int BufferLength,
- const void *Auth, unsigned int AuthLength)
+static RPC_STATUS RPCRT4_SendWithAuth(RpcConnection *Connection, RpcPktHdr *Header,
+ void *Buffer, unsigned int BufferLength,
+ const void *Auth, unsigned int AuthLength)
{
PUCHAR buffer_pos;
DWORD hdr_size;
memcpy(pkt + hdr_size, buffer_pos, Header->common.frag_len - hdr_size - auth_pad_len - alen);
/* add the authorization info */
- if (Header->common.auth_len)
+ if (Connection->AuthInfo && packet_has_auth_verifier(Header))
{
RpcAuthVerifier *auth_hdr = (RpcAuthVerifier *)&pkt[Header->common.frag_len - alen];
auth_hdr->auth_pad_length = auth_pad_len;
auth_hdr->auth_reserved = 0;
/* a unique number... */
- auth_hdr->auth_context_id = Connection->auth_context_id;
+ auth_hdr->auth_context_id = (unsigned long)Connection;
if (AuthLength)
memcpy(auth_hdr + 1, Auth, AuthLength);
else
{
- status = rpcrt4_conn_secure_packet(Connection, SECURE_PACKET_SEND,
+ status = RPCRT4_SecurePacket(Connection, SECURE_PACKET_SEND,
(RpcPktHdr *)pkt, hdr_size,
pkt + hdr_size, Header->common.frag_len - hdr_size - alen,
auth_hdr,
}
/***********************************************************************
- * RPCRT4_default_authorize (internal)
+ * RPCRT4_ClientAuthorize (internal)
*
- * Authorize a client connection.
+ * Authorize a client connection. A NULL in param signifies a new connection.
*/
-RPC_STATUS RPCRT4_default_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_ClientAuthorize(RpcConnection *conn, SecBuffer *in,
+ SecBuffer *out)
{
SECURITY_STATUS r;
SecBufferDesc out_desc;
SecBufferDesc inp_desc;
SecPkgContext_Sizes secctx_sizes;
BOOL continue_needed;
- ULONG context_req;
- SecBuffer in, out;
+ ULONG context_req = ISC_REQ_CONNECTION | ISC_REQ_USE_DCE_STYLE |
+ ISC_REQ_MUTUAL_AUTH | ISC_REQ_DELEGATE;
- if (!out_buffer)
- {
- *out_size = conn->AuthInfo->cbMaxToken;
- return RPC_S_OK;
- }
-
- in.BufferType = SECBUFFER_TOKEN;
- in.pvBuffer = in_buffer;
- in.cbBuffer = in_size;
+ if (conn->AuthInfo->AuthnLevel == RPC_C_AUTHN_LEVEL_PKT_INTEGRITY)
+ context_req |= ISC_REQ_INTEGRITY;
+ else if (conn->AuthInfo->AuthnLevel == RPC_C_AUTHN_LEVEL_PKT_PRIVACY)
+ context_req |= ISC_REQ_CONFIDENTIALITY | ISC_REQ_INTEGRITY;
- out.BufferType = SECBUFFER_TOKEN;
- out.pvBuffer = out_buffer;
- out.cbBuffer = *out_size;
+ out->BufferType = SECBUFFER_TOKEN;
+ out->cbBuffer = conn->AuthInfo->cbMaxToken;
+ out->pvBuffer = HeapAlloc(GetProcessHeap(), 0, out->cbBuffer);
+ if (!out->pvBuffer) return ERROR_OUTOFMEMORY;
out_desc.ulVersion = 0;
out_desc.cBuffers = 1;
- out_desc.pBuffers = &out;
+ out_desc.pBuffers = out;
- inp_desc.ulVersion = 0;
inp_desc.cBuffers = 1;
- inp_desc.pBuffers = ∈
+ inp_desc.pBuffers = in;
+ inp_desc.ulVersion = 0;
- if (conn->server)
- {
- context_req = ASC_REQ_CONNECTION | ASC_REQ_USE_DCE_STYLE |
- ASC_REQ_DELEGATE;
-
- if (conn->AuthInfo->AuthnLevel == RPC_C_AUTHN_LEVEL_PKT_INTEGRITY)
- context_req |= ASC_REQ_INTEGRITY;
- else if (conn->AuthInfo->AuthnLevel == RPC_C_AUTHN_LEVEL_PKT_PRIVACY)
- context_req |= ASC_REQ_CONFIDENTIALITY | ASC_REQ_INTEGRITY;
-
- r = AcceptSecurityContext(&conn->AuthInfo->cred,
- first_time ? NULL : &conn->ctx,
- &inp_desc, context_req, SECURITY_NETWORK_DREP,
- &conn->ctx,
- &out_desc, &conn->attr, &conn->exp);
- if (r == SEC_E_OK || r == SEC_I_COMPLETE_NEEDED)
- {
- /* authorisation done, so nothing more to send */
- out.cbBuffer = 0;
- }
- }
- else
- {
- context_req = ISC_REQ_CONNECTION | ISC_REQ_USE_DCE_STYLE |
- ISC_REQ_MUTUAL_AUTH | ISC_REQ_DELEGATE;
-
- if (conn->AuthInfo->AuthnLevel == RPC_C_AUTHN_LEVEL_PKT_INTEGRITY)
- context_req |= ISC_REQ_INTEGRITY;
- else if (conn->AuthInfo->AuthnLevel == RPC_C_AUTHN_LEVEL_PKT_PRIVACY)
- context_req |= ISC_REQ_CONFIDENTIALITY | ISC_REQ_INTEGRITY;
-
- r = InitializeSecurityContextW(&conn->AuthInfo->cred,
- first_time ? NULL: &conn->ctx,
- first_time ? conn->AuthInfo->server_principal_name : NULL,
- context_req, 0, SECURITY_NETWORK_DREP,
- first_time ? NULL : &inp_desc, 0, &conn->ctx,
- &out_desc, &conn->attr, &conn->exp);
- }
+ r = InitializeSecurityContextW(&conn->AuthInfo->cred, in ? &conn->ctx : NULL,
+ in ? NULL : conn->AuthInfo->server_principal_name, context_req, 0,
+ SECURITY_NETWORK_DREP, in ? &inp_desc : NULL, 0, &conn->ctx,
+ &out_desc, &conn->attr, &conn->exp);
if (FAILED(r))
{
WARN("InitializeSecurityContext failed with error 0x%08x\n", r);
}
}
- TRACE("cbBuffer = %d\n", out.cbBuffer);
+ TRACE("cbBuffer = %d\n", out->cbBuffer);
if (!continue_needed)
{
conn->encryption_auth_len = secctx_sizes.cbSecurityTrailer;
}
- *out_size = out.cbBuffer;
return RPC_S_OK;
failed:
- *out_size = 0;
+ HeapFree(GetProcessHeap(), 0, out->pvBuffer);
+ out->pvBuffer = NULL;
return ERROR_ACCESS_DENIED; /* FIXME: is this correct? */
}
/***********************************************************************
- * RPCRT4_ClientConnectionAuth (internal)
+ * RPCRT4_AuthorizeBinding (internal)
*/
-RPC_STATUS RPCRT4_ClientConnectionAuth(RpcConnection* conn, BYTE *challenge,
- ULONG count)
+RPC_STATUS RPCRT4_AuthorizeConnection(RpcConnection* conn, BYTE *challenge,
+ ULONG count)
{
+ SecBuffer inp, out;
RpcPktHdr *resp_hdr;
RPC_STATUS status;
- unsigned char *out_buffer;
- unsigned int out_len = 0;
TRACE("challenge %s, %d bytes\n", challenge, count);
- status = rpcrt4_conn_authorize(conn, FALSE, challenge, count, NULL, &out_len);
- if (status) return status;
- out_buffer = HeapAlloc(GetProcessHeap(), 0, out_len);
- if (!out_buffer) return RPC_S_OUT_OF_RESOURCES;
- status = rpcrt4_conn_authorize(conn, FALSE, challenge, count, out_buffer, &out_len);
+ inp.BufferType = SECBUFFER_TOKEN;
+ inp.pvBuffer = challenge;
+ inp.cbBuffer = count;
+
+ status = RPCRT4_ClientAuthorize(conn, &inp, &out);
if (status) return status;
resp_hdr = RPCRT4_BuildAuthHeader(NDR_LOCAL_DATA_REPRESENTATION);
+ if (!resp_hdr)
+ return E_OUTOFMEMORY;
- if (resp_hdr)
- status = RPCRT4_SendWithAuth(conn, resp_hdr, NULL, 0, out_buffer, out_len);
- else
- status = RPC_S_OUT_OF_RESOURCES;
+ status = RPCRT4_SendWithAuth(conn, resp_hdr, NULL, 0, out.pvBuffer, out.cbBuffer);
- HeapFree(GetProcessHeap(), 0, out_buffer);
+ HeapFree(GetProcessHeap(), 0, out.pvBuffer);
RPCRT4_FreeHeader(resp_hdr);
return status;
}
-/***********************************************************************
- * RPCRT4_ServerConnectionAuth (internal)
- */
-RPC_STATUS RPCRT4_ServerConnectionAuth(RpcConnection* conn,
- BOOL start,
- RpcAuthVerifier *auth_data_in,
- ULONG auth_length_in,
- unsigned char **auth_data_out,
- ULONG *auth_length_out)
-{
- unsigned char *out_buffer;
- unsigned int out_size;
- RPC_STATUS status;
-
- if (start)
- {
- /* remove any existing authentication information */
- if (conn->AuthInfo)
- {
- RpcAuthInfo_Release(conn->AuthInfo);
- conn->AuthInfo = NULL;
- }
- if (SecIsValidHandle(&conn->ctx))
- {
- DeleteSecurityContext(&conn->ctx);
- SecInvalidateHandle(&conn->ctx);
- }
- if (auth_length_in >= sizeof(RpcAuthVerifier))
- {
- CredHandle cred;
- TimeStamp exp;
- ULONG max_token;
-
- status = RPCRT4_ServerGetRegisteredAuthInfo(
- auth_data_in->auth_type, &cred, &exp, &max_token);
- if (status != RPC_S_OK)
- {
- ERR("unknown authentication service %u\n", auth_data_in->auth_type);
- return status;
- }
-
- status = RpcAuthInfo_Create(auth_data_in->auth_level,
- auth_data_in->auth_type, cred, exp,
- max_token, NULL, &conn->AuthInfo);
- if (status != RPC_S_OK)
- return status;
-
- /* FIXME: should auth_data_in->auth_context_id be checked in the !start case? */
- conn->auth_context_id = auth_data_in->auth_context_id;
- }
- }
-
- if (auth_length_in < sizeof(RpcAuthVerifier))
- return RPC_S_OK;
-
- if (!conn->AuthInfo)
- /* should have filled in authentication info by now */
- return RPC_S_PROTOCOL_ERROR;
-
- status = rpcrt4_conn_authorize(
- conn, start, (unsigned char *)(auth_data_in + 1),
- auth_length_in - sizeof(RpcAuthVerifier), NULL, &out_size);
- if (status) return status;
-
- out_buffer = HeapAlloc(GetProcessHeap(), 0, out_size);
- if (!out_buffer) return RPC_S_OUT_OF_RESOURCES;
-
- status = rpcrt4_conn_authorize(
- conn, start, (unsigned char *)(auth_data_in + 1),
- auth_length_in - sizeof(RpcAuthVerifier), out_buffer, &out_size);
- if (status != RPC_S_OK)
- {
- HeapFree(GetProcessHeap(), 0, out_buffer);
- return status;
- }
-
- if (out_size && !auth_length_out)
- {
- ERR("expected authentication to be complete but SSP returned data of "
- "%u bytes to be sent back to client\n", out_size);
- HeapFree(GetProcessHeap(), 0, out_buffer);
- return RPC_S_SEC_PKG_ERROR;
- }
- else
- {
- *auth_data_out = out_buffer;
- *auth_length_out = out_size;
- }
-
- return status;
-}
-
-/***********************************************************************
- * RPCRT4_default_is_authorized (internal)
- *
- * Has a connection started the process of authorizing with the server?
- */
-BOOL RPCRT4_default_is_authorized(RpcConnection *Connection)
-{
- return Connection->AuthInfo && SecIsValidHandle(&Connection->ctx);
-}
-
-/***********************************************************************
- * RPCRT4_default_impersonate_client (internal)
- *
- */
-RPC_STATUS RPCRT4_default_impersonate_client(RpcConnection *conn)
-{
- SECURITY_STATUS sec_status;
-
- TRACE("(%p)\n", conn);
-
- if (!conn->AuthInfo || !SecIsValidHandle(&conn->ctx))
- return RPC_S_NO_CONTEXT_AVAILABLE;
- sec_status = ImpersonateSecurityContext(&conn->ctx);
- if (sec_status != SEC_E_OK)
- WARN("ImpersonateSecurityContext returned 0x%08x\n", sec_status);
- switch (sec_status)
- {
- case SEC_E_UNSUPPORTED_FUNCTION:
- return RPC_S_CANNOT_SUPPORT;
- case SEC_E_NO_IMPERSONATION:
- return RPC_S_NO_CONTEXT_AVAILABLE;
- case SEC_E_OK:
- return RPC_S_OK;
- default:
- return RPC_S_SEC_PKG_ERROR;
- }
-}
-
-/***********************************************************************
- * RPCRT4_default_revert_to_self (internal)
- *
- */
-RPC_STATUS RPCRT4_default_revert_to_self(RpcConnection *conn)
-{
- SECURITY_STATUS sec_status;
-
- TRACE("(%p)\n", conn);
-
- if (!conn->AuthInfo || !SecIsValidHandle(&conn->ctx))
- return RPC_S_NO_CONTEXT_AVAILABLE;
- sec_status = RevertSecurityContext(&conn->ctx);
- if (sec_status != SEC_E_OK)
- WARN("RevertSecurityContext returned 0x%08x\n", sec_status);
- switch (sec_status)
- {
- case SEC_E_UNSUPPORTED_FUNCTION:
- return RPC_S_CANNOT_SUPPORT;
- case SEC_E_NO_IMPERSONATION:
- return RPC_S_NO_CONTEXT_AVAILABLE;
- case SEC_E_OK:
- return RPC_S_OK;
- default:
- return RPC_S_SEC_PKG_ERROR;
- }
-}
-
-/***********************************************************************
- * RPCRT4_default_inquire_auth_client (internal)
- *
- * Default function to retrieve the authentication details that the client
- * is using to call the server.
- */
-RPC_STATUS RPCRT4_default_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)
-{
- if (!conn->AuthInfo) return RPC_S_BINDING_HAS_NO_AUTH;
-
- if (privs)
- {
- FIXME("privs not implemented\n");
- *privs = NULL;
- }
- if (server_princ_name)
- {
- *server_princ_name = RPCRT4_strdupW(conn->AuthInfo->server_principal_name);
- if (!*server_princ_name) return ERROR_OUTOFMEMORY;
- }
- if (authn_level) *authn_level = conn->AuthInfo->AuthnLevel;
- if (authn_svc) *authn_svc = conn->AuthInfo->AuthnSvc;
- if (authz_svc)
- {
- FIXME("authorization service not implemented\n");
- *authz_svc = RPC_C_AUTHZ_NONE;
- }
- if (flags)
- FIXME("flags 0x%x not implemented\n", flags);
-
- return RPC_S_OK;
-}
-
/***********************************************************************
* RPCRT4_Send (internal)
*
void *Buffer, unsigned int BufferLength)
{
RPC_STATUS r;
+ SecBuffer out;
- if (packet_does_auth_negotiation(Header) &&
- Connection->AuthInfo &&
- !rpcrt4_conn_is_authorized(Connection))
+ if (!Connection->AuthInfo || SecIsValidHandle(&Connection->ctx))
{
- unsigned int out_size = 0;
- unsigned char *out_buffer;
-
- r = rpcrt4_conn_authorize(Connection, TRUE, NULL, 0, NULL, &out_size);
- if (r != RPC_S_OK) return r;
-
- out_buffer = HeapAlloc(GetProcessHeap(), 0, out_size);
- if (!out_buffer) return RPC_S_OUT_OF_RESOURCES;
-
- /* tack on a negotiate packet */
- r = rpcrt4_conn_authorize(Connection, TRUE, NULL, 0, out_buffer, &out_size);
- if (r == RPC_S_OK)
- r = RPCRT4_SendWithAuth(Connection, Header, Buffer, BufferLength, out_buffer, out_size);
+ return RPCRT4_SendWithAuth(Connection, Header, Buffer, BufferLength, NULL, 0);
+ }
- HeapFree(GetProcessHeap(), 0, out_buffer);
+ /* tack on a negotiate packet */
+ r = RPCRT4_ClientAuthorize(Connection, NULL, &out);
+ if (r == RPC_S_OK)
+ {
+ r = RPCRT4_SendWithAuth(Connection, Header, Buffer, BufferLength, out.pvBuffer, out.cbBuffer);
+ HeapFree(GetProcessHeap(), 0, out.pvBuffer);
}
- else
- r = RPCRT4_SendWithAuth(Connection, Header, Buffer, BufferLength, NULL, 0);
return r;
}
/* validates version and frag_len fields */
-RPC_STATUS RPCRT4_ValidateCommonHeader(const RpcPktCommonHdr *hdr)
+static RPC_STATUS RPCRT4_ValidateCommonHeader(const RpcPktCommonHdr *hdr)
{
DWORD hdr_length;
}
/***********************************************************************
- * RPCRT4_default_receive_fragment (internal)
+ * RPCRT4_receive_fragment (internal)
*
* Receive a fragment from a connection.
*/
-static RPC_STATUS RPCRT4_default_receive_fragment(RpcConnection *Connection, RpcPktHdr **Header, void **Payload)
+static RPC_STATUS RPCRT4_receive_fragment(RpcConnection *Connection, RpcPktHdr **Header, void **Payload)
{
RPC_STATUS status;
DWORD hdr_length;
return status;
}
-static RPC_STATUS RPCRT4_receive_fragment(RpcConnection *Connection, RpcPktHdr **Header, void **Payload)
-{
- if (Connection->ops->receive_fragment)
- return Connection->ops->receive_fragment(Connection, Header, Payload);
- else
- return RPCRT4_default_receive_fragment(Connection, Header, Payload);
-}
-
/***********************************************************************
* RPCRT4_ReceiveWithAuth (internal)
*
RPC_STATUS RPCRT4_ReceiveWithAuth(RpcConnection *Connection, RpcPktHdr **Header,
PRPC_MESSAGE pMsg,
unsigned char **auth_data_out,
- ULONG *auth_length_out)
+ unsigned long *auth_length_out)
{
RPC_STATUS status;
DWORD hdr_length;
unsigned short first_flag;
- ULONG data_length;
- ULONG buffer_length;
- ULONG auth_length = 0;
+ unsigned long data_length;
+ unsigned long buffer_length;
+ unsigned long auth_length = 0;
unsigned char *auth_data = NULL;
RpcPktHdr *CurrentHeader = NULL;
void *payload = NULL;
*Header = NULL;
pMsg->Buffer = NULL;
- if (auth_data_out) *auth_data_out = NULL;
- if (auth_length_out) *auth_length_out = 0;
TRACE("(%p, %p, %p, %p)\n", Connection, Header, pMsg, auth_data_out);
}
if (CurrentHeader->common.auth_len != auth_length) {
- WARN("auth_len header field changed from %d to %d\n",
+ WARN("auth_len header field changed from %ld to %d\n",
auth_length, CurrentHeader->common.auth_len);
status = RPC_S_PROTOCOL_ERROR;
goto fail;
data_length = CurrentHeader->common.frag_len - hdr_length - header_auth_len;
if (data_length + buffer_length > pMsg->BufferLength) {
- TRACE("allocation hint exceeded, new buffer length = %d\n",
+ TRACE("allocation hint exceeded, new buffer length = %ld\n",
data_length + buffer_length);
pMsg->BufferLength = data_length + buffer_length;
status = I_RpcReAllocateBuffer(pMsg);
/* these packets are handled specially, not by the generic SecurePacket
* function */
- if (!packet_does_auth_negotiation(*Header) && rpcrt4_conn_is_authorized(Connection))
+ if (!auth_data_out && SecIsValidHandle(&Connection->ctx))
{
- status = rpcrt4_conn_secure_packet(Connection, SECURE_PACKET_RECEIVE,
+ status = RPCRT4_SecurePacket(Connection, SECURE_PACKET_RECEIVE,
CurrentHeader, hdr_length,
(unsigned char *)pMsg->Buffer + buffer_length, data_length,
(RpcAuthVerifier *)auth_data,
*/
RPC_STATUS WINAPI I_RpcNegotiateTransferSyntax(PRPC_MESSAGE pMsg)
{
- RpcBinding* bind = pMsg->Handle;
+ RpcBinding* bind = (RpcBinding*)pMsg->Handle;
RpcConnection* conn;
RPC_STATUS status = RPC_S_OK;
RPC_STATUS WINAPI I_RpcGetBuffer(PRPC_MESSAGE pMsg)
{
RPC_STATUS status;
- RpcBinding* bind = pMsg->Handle;
+ RpcBinding* bind = (RpcBinding*)pMsg->Handle;
TRACE("(%p): BufferLength=%d\n", pMsg, pMsg->BufferLength);
*/
RPC_STATUS WINAPI I_RpcFreeBuffer(PRPC_MESSAGE pMsg)
{
- RpcBinding* bind = pMsg->Handle;
+ RpcBinding* bind = (RpcBinding*)pMsg->Handle;
TRACE("(%p) Buffer=%p\n", pMsg, pMsg->Buffer);
*/
RPC_STATUS WINAPI I_RpcSend(PRPC_MESSAGE pMsg)
{
- RpcBinding* bind = pMsg->Handle;
+ RpcBinding* bind = (RpcBinding*)pMsg->Handle;
RpcConnection* conn;
RPC_STATUS status;
RpcPktHdr *hdr;
*/
RPC_STATUS WINAPI I_RpcReceive(PRPC_MESSAGE pMsg)
{
- RpcBinding* bind = pMsg->Handle;
+ RpcBinding* bind = (RpcBinding*)pMsg->Handle;
RPC_STATUS status;
RpcPktHdr *hdr = NULL;
RpcConnection *conn;
case PKT_RESPONSE:
break;
case PKT_FAULT:
- ERR ("we got fault packet with status 0x%x\n", hdr->fault.status);
+ ERR ("we got fault packet with status 0x%lx\n", hdr->fault.status);
status = NCA2RPC_STATUS(hdr->fault.status);
if (is_hard_error(status))
goto fail;
*/
RPC_STATUS WINAPI I_RpcAsyncSetHandle(PRPC_MESSAGE pMsg, PRPC_ASYNC_STATE pAsync)
{
- RpcBinding* bind = pMsg->Handle;
+ RpcBinding* bind = (RpcBinding*)pMsg->Handle;
RpcConnection *conn;
TRACE("(%p, %p)\n", pMsg, pAsync);
typedef unsigned int NCA_STATUS;
-RpcPktHdr *RPCRT4_BuildFaultHeader(ULONG DataRepresentation, RPC_STATUS Status);
-RpcPktHdr *RPCRT4_BuildResponseHeader(ULONG DataRepresentation, ULONG BufferLength);
-RpcPktHdr *RPCRT4_BuildBindHeader(ULONG DataRepresentation, unsigned short MaxTransmissionSize, unsigned short MaxReceiveSize, ULONG AssocGroupId, const RPC_SYNTAX_IDENTIFIER *AbstractId, const RPC_SYNTAX_IDENTIFIER *TransferId);
-RpcPktHdr *RPCRT4_BuildBindNackHeader(ULONG DataRepresentation, unsigned char RpcVersion, unsigned char RpcVersionMinor, unsigned short RejectReason);
-RpcPktHdr *RPCRT4_BuildBindAckHeader(ULONG DataRepresentation, unsigned short MaxTransmissionSize, unsigned short MaxReceiveSize, ULONG AssocGroupId, LPCSTR ServerAddress, unsigned char ResultCount, const RpcResult *Results);
-RpcPktHdr *RPCRT4_BuildHttpHeader(ULONG DataRepresentation, unsigned short flags, unsigned short num_data_items, unsigned int payload_size);
-RpcPktHdr *RPCRT4_BuildHttpConnectHeader(unsigned short flags, int out_pipe, const UUID *connection_uuid, const UUID *pipe_uuid, const UUID *association_uuid);
-RpcPktHdr *RPCRT4_BuildHttpFlowControlHeader(BOOL server, ULONG bytes_transmitted, ULONG flow_control_increment, const UUID *pipe_uuid);
+RpcPktHdr *RPCRT4_BuildFaultHeader(unsigned long DataRepresentation, RPC_STATUS Status);
+RpcPktHdr *RPCRT4_BuildResponseHeader(unsigned long DataRepresentation, unsigned long BufferLength);
+RpcPktHdr *RPCRT4_BuildBindHeader(unsigned long DataRepresentation, unsigned short MaxTransmissionSize, unsigned short MaxReceiveSize, unsigned long AssocGroupId, const RPC_SYNTAX_IDENTIFIER *AbstractId, const RPC_SYNTAX_IDENTIFIER *TransferId);
+RpcPktHdr *RPCRT4_BuildBindNackHeader(unsigned long DataRepresentation, unsigned char RpcVersion, unsigned char RpcVersionMinor);
+RpcPktHdr *RPCRT4_BuildBindAckHeader(unsigned long DataRepresentation, unsigned short MaxTransmissionSize, unsigned short MaxReceiveSize, unsigned long AssocGroupId, LPCSTR ServerAddress, unsigned long Result, unsigned long Reason, const RPC_SYNTAX_IDENTIFIER *TransferId);
VOID RPCRT4_FreeHeader(RpcPktHdr *Header);
RPC_STATUS RPCRT4_Send(RpcConnection *Connection, RpcPktHdr *Header, void *Buffer, unsigned int BufferLength);
-RPC_STATUS RPCRT4_SendWithAuth(RpcConnection *Connection, RpcPktHdr *Header, void *Buffer, unsigned int BufferLength, const void *Auth, unsigned int AuthLength);
RPC_STATUS RPCRT4_Receive(RpcConnection *Connection, RpcPktHdr **Header, PRPC_MESSAGE pMsg);
-RPC_STATUS RPCRT4_ReceiveWithAuth(RpcConnection *Connection, RpcPktHdr **Header, PRPC_MESSAGE pMsg, unsigned char **auth_data_out, ULONG *auth_length_out);
-DWORD RPCRT4_GetHeaderSize(const RpcPktHdr *Header);
-RPC_STATUS RPCRT4_ValidateCommonHeader(const RpcPktCommonHdr *hdr);
-
-BOOL RPCRT4_IsValidHttpPacket(RpcPktHdr *hdr, unsigned char *data, unsigned short data_len);
-RPC_STATUS RPCRT4_ParseHttpPrepareHeader1(RpcPktHdr *header, unsigned char *data, ULONG *field1);
-RPC_STATUS RPCRT4_ParseHttpPrepareHeader2(RpcPktHdr *header, unsigned char *data, ULONG *field1, ULONG *bytes_until_next_packet, ULONG *field3);
-RPC_STATUS RPCRT4_ParseHttpFlowControlHeader(RpcPktHdr *header, unsigned char *data, BOOL server, ULONG *bytes_transmitted, ULONG *flow_control_increment, UUID *pipe_uuid);
+RPC_STATUS RPCRT4_ReceiveWithAuth(RpcConnection *Connection, RpcPktHdr **Header, PRPC_MESSAGE pMsg, unsigned char **auth_data_out, unsigned long *auth_length_out);
NCA_STATUS RPC2NCA_STATUS(RPC_STATUS status);
-RPC_STATUS RPCRT4_ClientConnectionAuth(RpcConnection* conn, BYTE *challenge, ULONG count);
-RPC_STATUS RPCRT4_ServerConnectionAuth(RpcConnection* conn, BOOL start, RpcAuthVerifier *auth_data_in, ULONG auth_length_in, unsigned char **auth_data_out, ULONG *auth_length_out);
RPC_STATUS RPCRT4_AuthorizeConnection(RpcConnection* conn, BYTE *challenge, ULONG count);
-RPC_STATUS RPCRT4_ServerGetRegisteredAuthInfo(USHORT auth_type, CredHandle *cred, TimeStamp *exp, ULONG *max_token);
-RPC_STATUS RPCRT4_default_authorize(RpcConnection *conn, BOOL first_time, unsigned char *in_buffer, unsigned int in_size, unsigned char *out_buffer, unsigned int *out_size);
-BOOL RPCRT4_default_is_authorized(RpcConnection *Connection);
-RPC_STATUS RPCRT4_default_secure_packet(RpcConnection *Connection, 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);
-RPC_STATUS RPCRT4_default_impersonate_client(RpcConnection *conn);
-RPC_STATUS RPCRT4_default_revert_to_self(RpcConnection *conn);
-RPC_STATUS RPCRT4_default_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);
#endif
struct _RpcConnection* conn;
RpcPktHdr* hdr;
RPC_MESSAGE* msg;
- unsigned char *auth_data;
- ULONG auth_length;
} RpcPacket;
typedef struct _RpcObjTypeMap
/* list of type RpcServerProtseq */
static struct list protseqs = LIST_INIT(protseqs);
static struct list server_interfaces = LIST_INIT(server_interfaces);
-static struct list server_registered_auth_info = LIST_INIT(server_registered_auth_info);
static CRITICAL_SECTION server_cs;
static CRITICAL_SECTION_DEBUG server_cs_debug =
};
static CRITICAL_SECTION listen_cs = { &listen_cs_debug, -1, 0, 0, 0, 0 };
-static CRITICAL_SECTION server_auth_info_cs;
-static CRITICAL_SECTION_DEBUG server_auth_info_cs_debug =
-{
- 0, 0, &server_auth_info_cs,
- { &server_auth_info_cs_debug.ProcessLocksList, &server_auth_info_cs_debug.ProcessLocksList },
- 0, 0, { (DWORD_PTR)(__FILE__ ": server_auth_info_cs") }
-};
-static CRITICAL_SECTION server_auth_info_cs = { &server_auth_info_cs_debug, -1, 0, 0, 0, 0 };
-
/* whether the server is currently listening */
static BOOL std_listen;
/* number of manual listeners (calls to RpcServerListen) */
}
static RpcServerInterface* RPCRT4_find_interface(UUID* object,
- const RPC_SYNTAX_IDENTIFIER *if_id,
- const RPC_SYNTAX_IDENTIFIER *transfer_syntax,
+ const RPC_SYNTAX_IDENTIFIER* if_id,
BOOL check_object)
{
UUID* MgrType = NULL;
EnterCriticalSection(&server_cs);
LIST_FOR_EACH_ENTRY(cif, &server_interfaces, RpcServerInterface, entry) {
if (!memcmp(if_id, &cif->If->InterfaceId, sizeof(RPC_SYNTAX_IDENTIFIER)) &&
- (!transfer_syntax || !memcmp(transfer_syntax, &cif->If->TransferSyntax, sizeof(RPC_SYNTAX_IDENTIFIER))) &&
(check_object == FALSE || UuidEqual(MgrType, &cif->MgrTypeUuid, &status)) &&
std_listen) {
InterlockedIncrement(&cif->CurrentCalls);
}
}
-static RpcPktHdr *handle_bind_error(RpcConnection *conn, RPC_STATUS error)
-{
- unsigned int reject_reason;
- switch (error)
- {
- case RPC_S_SERVER_TOO_BUSY:
- reject_reason = REJECT_TEMPORARY_CONGESTION;
- break;
- case ERROR_OUTOFMEMORY:
- case RPC_S_OUT_OF_RESOURCES:
- reject_reason = REJECT_LOCAL_LIMIT_EXCEEDED;
- break;
- case RPC_S_PROTOCOL_ERROR:
- reject_reason = REJECT_PROTOCOL_VERSION_NOT_SUPPORTED;
- break;
- case RPC_S_UNKNOWN_AUTHN_SERVICE:
- reject_reason = REJECT_UNKNOWN_AUTHN_SERVICE;
- break;
- case ERROR_ACCESS_DENIED:
- reject_reason = REJECT_INVALID_CHECKSUM;
- break;
- default:
- FIXME("unexpected status value %d\n", error);
- /* fall through */
- case RPC_S_INVALID_BOUND:
- reject_reason = REJECT_REASON_NOT_SPECIFIED;
- break;
- }
- return RPCRT4_BuildBindNackHeader(NDR_LOCAL_DATA_REPRESENTATION,
- RPC_VER_MAJOR, RPC_VER_MINOR,
- reject_reason);
-}
-
-static RPC_STATUS process_bind_packet_no_send(
- RpcConnection *conn, RpcPktBindHdr *hdr, RPC_MESSAGE *msg,
- unsigned char *auth_data, ULONG auth_length, RpcPktHdr **ack_response,
- unsigned char **auth_data_out, ULONG *auth_length_out)
+static RPC_STATUS process_bind_packet(RpcConnection *conn, RpcPktBindHdr *hdr, RPC_MESSAGE *msg)
{
RPC_STATUS status;
- RpcContextElement *ctxt_elem;
- unsigned int i;
- RpcResult *results;
-
- /* validate data */
- for (i = 0, ctxt_elem = msg->Buffer;
- i < hdr->num_elements;
- i++, ctxt_elem = (RpcContextElement *)&ctxt_elem->transfer_syntaxes[ctxt_elem->num_syntaxes])
- {
- if (((char *)ctxt_elem - (char *)msg->Buffer) > msg->BufferLength ||
- ((char *)&ctxt_elem->transfer_syntaxes[ctxt_elem->num_syntaxes] - (char *)msg->Buffer) > msg->BufferLength)
- {
- ERR("inconsistent data in packet - packet length %d, num elements %d\n",
- msg->BufferLength, hdr->num_elements);
- return RPC_S_INVALID_BOUND;
- }
- }
+ RpcServerInterface* sif;
+ RpcPktHdr *response = NULL;
+ /* FIXME: do more checks! */
if (hdr->max_tsize < RPC_MIN_PACKET_SIZE ||
!UuidIsNil(&conn->ActiveInterface.SyntaxGUID, &status) ||
- conn->server_binding)
- {
+ conn->server_binding) {
TRACE("packet size less than min size, or active interface syntax guid non-null\n");
-
- return RPC_S_INVALID_BOUND;
- }
-
- results = HeapAlloc(GetProcessHeap(), 0,
- hdr->num_elements * sizeof(*results));
- if (!results)
- return RPC_S_OUT_OF_RESOURCES;
-
- for (i = 0, ctxt_elem = (RpcContextElement *)msg->Buffer;
- i < hdr->num_elements;
- i++, ctxt_elem = (RpcContextElement *)&ctxt_elem->transfer_syntaxes[ctxt_elem->num_syntaxes])
- {
- RpcServerInterface* sif = NULL;
- unsigned int j;
-
- for (j = 0; !sif && j < ctxt_elem->num_syntaxes; j++)
- {
- sif = RPCRT4_find_interface(NULL, &ctxt_elem->abstract_syntax,
- &ctxt_elem->transfer_syntaxes[j], FALSE);
- if (sif)
- break;
- }
- if (sif)
- {
- RPCRT4_release_server_interface(sif);
- TRACE("accepting bind request on connection %p for %s\n", conn,
- debugstr_guid(&ctxt_elem->abstract_syntax.SyntaxGUID));
- results[i].result = RESULT_ACCEPT;
- results[i].reason = REASON_NONE;
- results[i].transfer_syntax = ctxt_elem->transfer_syntaxes[j];
-
- /* save the interface for later use */
- /* FIXME: save linked list */
- conn->ActiveInterface = ctxt_elem->abstract_syntax;
- }
- else if ((sif = RPCRT4_find_interface(NULL, &ctxt_elem->abstract_syntax,
- NULL, FALSE)) != NULL)
- {
- RPCRT4_release_server_interface(sif);
- TRACE("not accepting bind request on connection %p for %s - no transfer syntaxes supported\n",
- conn, debugstr_guid(&ctxt_elem->abstract_syntax.SyntaxGUID));
- results[i].result = RESULT_PROVIDER_REJECTION;
- results[i].reason = REASON_TRANSFER_SYNTAXES_NOT_SUPPORTED;
- memset(&results[i].transfer_syntax, 0, sizeof(results[i].transfer_syntax));
- }
- else
- {
- TRACE("not accepting bind request on connection %p for %s - abstract syntax not supported\n",
- conn, debugstr_guid(&ctxt_elem->abstract_syntax.SyntaxGUID));
- results[i].result = RESULT_PROVIDER_REJECTION;
- results[i].reason = REASON_ABSTRACT_SYNTAX_NOT_SUPPORTED;
- memset(&results[i].transfer_syntax, 0, sizeof(results[i].transfer_syntax));
- }
- }
-
- /* create temporary binding */
- status = RPCRT4_MakeBinding(&conn->server_binding, conn);
- if (status != RPC_S_OK)
- {
- HeapFree(GetProcessHeap(), 0, results);
- return status;
- }
-
- status = RpcServerAssoc_GetAssociation(rpcrt4_conn_get_name(conn),
- conn->NetworkAddr, conn->Endpoint,
- conn->NetworkOptions,
- hdr->assoc_gid,
- &conn->server_binding->Assoc);
- if (status != RPC_S_OK)
- {
- HeapFree(GetProcessHeap(), 0, results);
- return status;
+ sif = NULL;
+ } else {
+ /* create temporary binding */
+ if (RPCRT4_MakeBinding(&conn->server_binding, conn) == RPC_S_OK &&
+ RpcServerAssoc_GetAssociation(rpcrt4_conn_get_name(conn),
+ conn->NetworkAddr, conn->Endpoint,
+ conn->NetworkOptions,
+ hdr->assoc_gid,
+ &conn->server_binding->Assoc) == RPC_S_OK)
+ sif = RPCRT4_find_interface(NULL, &hdr->abstract, FALSE);
+ else
+ sif = NULL;
}
-
- if (auth_length)
- {
- status = RPCRT4_ServerConnectionAuth(conn, TRUE,
- (RpcAuthVerifier *)auth_data,
- auth_length, auth_data_out,
- auth_length_out);
- if (status != RPC_S_OK)
- {
- HeapFree(GetProcessHeap(), 0, results);
- return status;
- }
+ if (sif == NULL) {
+ TRACE("rejecting bind request on connection %p\n", conn);
+ /* Report failure to client. */
+ response = RPCRT4_BuildBindNackHeader(NDR_LOCAL_DATA_REPRESENTATION,
+ RPC_VER_MAJOR, RPC_VER_MINOR);
+ } else {
+ TRACE("accepting bind request on connection %p for %s\n", conn,
+ debugstr_guid(&hdr->abstract.SyntaxGUID));
+
+ /* accept. */
+ response = RPCRT4_BuildBindAckHeader(NDR_LOCAL_DATA_REPRESENTATION,
+ RPC_MAX_PACKET_SIZE,
+ RPC_MAX_PACKET_SIZE,
+ conn->server_binding->Assoc->assoc_group_id,
+ conn->Endpoint,
+ RESULT_ACCEPT, REASON_NONE,
+ &sif->If->TransferSyntax);
+
+ /* save the interface for later use */
+ conn->ActiveInterface = hdr->abstract;
+ conn->MaxTransmissionSize = hdr->max_tsize;
+
+ RPCRT4_release_server_interface(sif);
}
- *ack_response = RPCRT4_BuildBindAckHeader(NDR_LOCAL_DATA_REPRESENTATION,
- RPC_MAX_PACKET_SIZE,
- RPC_MAX_PACKET_SIZE,
- conn->server_binding->Assoc->assoc_group_id,
- conn->Endpoint, hdr->num_elements,
- results);
- HeapFree(GetProcessHeap(), 0, results);
-
- if (*ack_response)
- conn->MaxTransmissionSize = hdr->max_tsize;
+ if (response)
+ status = RPCRT4_Send(conn, response, NULL, 0);
else
- status = RPC_S_OUT_OF_RESOURCES;
+ status = ERROR_OUTOFMEMORY;
+ RPCRT4_FreeHeader(response);
return status;
}
-static RPC_STATUS process_bind_packet(RpcConnection *conn, RpcPktBindHdr *hdr,
- RPC_MESSAGE *msg,
- unsigned char *auth_data,
- ULONG auth_length)
-{
- RPC_STATUS status;
- RpcPktHdr *response = NULL;
- unsigned char *auth_data_out = NULL;
- ULONG auth_length_out = 0;
-
- status = process_bind_packet_no_send(conn, hdr, msg, auth_data, auth_length,
- &response, &auth_data_out,
- &auth_length_out);
- if (status != RPC_S_OK)
- response = handle_bind_error(conn, status);
- if (response)
- status = RPCRT4_SendWithAuth(conn, response, NULL, 0, auth_data_out, auth_length_out);
- else
- status = ERROR_OUTOFMEMORY;
- RPCRT4_FreeHeader(response);
-
- return status;
-}
-
-
static RPC_STATUS process_request_packet(RpcConnection *conn, RpcPktRequestHdr *hdr, RPC_MESSAGE *msg)
{
RPC_STATUS status;
object_uuid = NULL;
}
- sif = RPCRT4_find_interface(object_uuid, &conn->ActiveInterface, NULL, TRUE);
+ sif = RPCRT4_find_interface(object_uuid, &conn->ActiveInterface, TRUE);
if (!sif) {
WARN("interface %s no longer registered, returning fault packet\n", debugstr_guid(&conn->ActiveInterface.SyntaxGUID));
response = RPCRT4_BuildFaultHeader(NDR_LOCAL_DATA_REPRESENTATION,
return status;
}
-static RPC_STATUS process_auth3_packet(RpcConnection *conn,
- RpcPktCommonHdr *hdr,
- RPC_MESSAGE *msg,
- unsigned char *auth_data,
- ULONG auth_length)
-{
- RPC_STATUS status;
-
- if (UuidIsNil(&conn->ActiveInterface.SyntaxGUID, &status) ||
- !auth_length || msg->BufferLength != 0)
- status = RPC_S_PROTOCOL_ERROR;
- else
- {
- status = RPCRT4_ServerConnectionAuth(conn, FALSE,
- (RpcAuthVerifier *)auth_data,
- auth_length, NULL, NULL);
- }
-
- /* FIXME: client doesn't expect a response to this message so must store
- * status in connection so that fault packet can be returned when next
- * packet is received */
-
- return RPC_S_OK;
-}
-
-static void RPCRT4_process_packet(RpcConnection* conn, RpcPktHdr* hdr,
- RPC_MESSAGE* msg, unsigned char *auth_data,
- ULONG auth_length)
+static void RPCRT4_process_packet(RpcConnection* conn, RpcPktHdr* hdr, RPC_MESSAGE* msg)
{
RPC_STATUS status;
case PKT_BIND:
TRACE("got bind packet\n");
- status = process_bind_packet(conn, &hdr->bind, msg, auth_data,
- auth_length);
+ status = process_bind_packet(conn, &hdr->bind, msg);
break;
case PKT_REQUEST:
status = process_request_packet(conn, &hdr->request, msg);
break;
- case PKT_AUTH3:
- TRACE("got auth3 packet\n");
-
- status = process_auth3_packet(conn, &hdr->common, msg, auth_data,
- auth_length);
- break;
default:
FIXME("unhandled packet type %u\n", hdr->common.ptype);
break;
I_RpcFree(msg->Buffer);
RPCRT4_FreeHeader(hdr);
HeapFree(GetProcessHeap(), 0, msg);
- HeapFree(GetProcessHeap(), 0, auth_data);
}
static DWORD CALLBACK RPCRT4_worker_thread(LPVOID the_arg)
{
RpcPacket *pkt = the_arg;
- RPCRT4_process_packet(pkt->conn, pkt->hdr, pkt->msg, pkt->auth_data,
- pkt->auth_length);
+ RPCRT4_process_packet(pkt->conn, pkt->hdr, pkt->msg);
HeapFree(GetProcessHeap(), 0, pkt);
return 0;
}
static DWORD CALLBACK RPCRT4_io_thread(LPVOID the_arg)
{
- RpcConnection* conn = the_arg;
+ RpcConnection* conn = (RpcConnection*)the_arg;
RpcPktHdr *hdr;
RPC_MESSAGE *msg;
RPC_STATUS status;
RpcPacket *packet;
- unsigned char *auth_data;
- ULONG auth_length;
TRACE("(%p)\n", conn);
for (;;) {
msg = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RPC_MESSAGE));
- if (!msg) break;
- status = RPCRT4_ReceiveWithAuth(conn, &hdr, msg, &auth_data, &auth_length);
+ status = RPCRT4_Receive(conn, &hdr, msg);
if (status != RPC_S_OK) {
WARN("receive failed with error %x\n", status);
HeapFree(GetProcessHeap(), 0, msg);
break;
}
- switch (hdr->common.ptype) {
- case PKT_BIND:
- TRACE("got bind packet\n");
-
- status = process_bind_packet(conn, &hdr->bind, msg, auth_data,
- auth_length);
- break;
-
- case PKT_REQUEST:
- TRACE("got request packet\n");
-
- packet = HeapAlloc(GetProcessHeap(), 0, sizeof(RpcPacket));
- if (!packet) {
- I_RpcFree(msg->Buffer);
- RPCRT4_FreeHeader(hdr);
- HeapFree(GetProcessHeap(), 0, msg);
- HeapFree(GetProcessHeap(), 0, auth_data);
- goto exit;
- }
- packet->conn = conn;
- packet->hdr = hdr;
- packet->msg = msg;
- packet->auth_data = auth_data;
- packet->auth_length = auth_length;
- if (!QueueUserWorkItem(RPCRT4_worker_thread, packet, WT_EXECUTELONGFUNCTION)) {
- ERR("couldn't queue work item for worker thread, error was %d\n", GetLastError());
- HeapFree(GetProcessHeap(), 0, packet);
- status = RPC_S_OUT_OF_RESOURCES;
- } else {
- continue;
- }
- break;
-
- case PKT_AUTH3:
- TRACE("got auth3 packet\n");
-
- status = process_auth3_packet(conn, &hdr->common, msg, auth_data,
- auth_length);
- break;
- default:
- FIXME("unhandled packet type %u\n", hdr->common.ptype);
+ packet = HeapAlloc(GetProcessHeap(), 0, sizeof(RpcPacket));
+ if (!packet) {
+ I_RpcFree(msg->Buffer);
+ RPCRT4_FreeHeader(hdr);
+ HeapFree(GetProcessHeap(), 0, msg);
break;
}
-
- I_RpcFree(msg->Buffer);
- RPCRT4_FreeHeader(hdr);
- HeapFree(GetProcessHeap(), 0, msg);
- HeapFree(GetProcessHeap(), 0, auth_data);
-
- if (status != RPC_S_OK) {
- WARN("processing packet failed with error %u\n", status);
+ packet->conn = conn;
+ packet->hdr = hdr;
+ packet->msg = msg;
+ if (!QueueUserWorkItem(RPCRT4_worker_thread, packet, WT_EXECUTELONGFUNCTION)) {
+ ERR("couldn't queue work item for worker thread, error was %d\n", GetLastError());
+ I_RpcFree(msg->Buffer);
+ RPCRT4_FreeHeader(hdr);
+ HeapFree(GetProcessHeap(), 0, msg);
+ HeapFree(GetProcessHeap(), 0, packet);
break;
}
+
+ msg = NULL;
}
-exit:
RPCRT4_DestroyConnection(conn);
return 0;
}
/* start waiting */
res = cps->ops->wait_for_new_connection(cps, count, objs);
-
- if (res == -1 || (res == 0 && !std_listen))
- {
- /* cleanup */
- cps->ops->free_wait_array(cps, objs);
- EnterCriticalSection(&cps->cs);
- for (conn = cps->conn; conn; conn = conn->Next)
- RPCRT4_CloseConnection(conn);
- LeaveCriticalSection(&cps->cs);
-
- if (res == 0 && !std_listen)
- SetEvent(cps->server_ready_event);
+ if (res == -1)
break;
- }
else if (res == 0)
+ {
+ if (!std_listen)
+ {
+ SetEvent(cps->server_ready_event);
+ break;
+ }
set_ready_event = TRUE;
+ }
}
+ cps->ops->free_wait_array(cps, objs);
+ EnterCriticalSection(&cps->cs);
+ /* close connections */
+ conn = cps->conn;
+ while (conn) {
+ RPCRT4_CloseConnection(conn);
+ conn = conn->Next;
+ }
+ LeaveCriticalSection(&cps->cs);
return 0;
}
LeaveCriticalSection(&listen_cs);
}
-static BOOL RPCRT4_protseq_is_endpoint_registered(RpcServerProtseq *protseq, const char *endpoint)
-{
- RpcConnection *conn;
- EnterCriticalSection(&protseq->cs);
- for (conn = protseq->conn; conn; conn = conn->Next)
- {
- if (!endpoint || !strcmp(endpoint, conn->Endpoint))
- break;
- }
- LeaveCriticalSection(&protseq->cs);
- return (conn != NULL);
-}
-
-static RPC_STATUS RPCRT4_use_protseq(RpcServerProtseq* ps, const char *endpoint)
+static RPC_STATUS RPCRT4_use_protseq(RpcServerProtseq* ps, LPSTR endpoint)
{
RPC_STATUS status;
- EnterCriticalSection(&ps->cs);
-
- if (RPCRT4_protseq_is_endpoint_registered(ps, endpoint))
- status = RPC_S_OK;
- else
- status = ps->ops->open_endpoint(ps, endpoint);
-
- LeaveCriticalSection(&ps->cs);
-
+ status = ps->ops->open_endpoint(ps, endpoint);
if (status != RPC_S_OK)
return status;
count = 0;
LIST_FOR_EACH_ENTRY(ps, &protseqs, RpcServerProtseq, entry) {
EnterCriticalSection(&ps->cs);
- for (conn = ps->conn; conn; conn = conn->Next)
+ conn = ps->conn;
+ while (conn) {
count++;
+ conn = conn->Next;
+ }
LeaveCriticalSection(&ps->cs);
}
if (count) {
count = 0;
LIST_FOR_EACH_ENTRY(ps, &protseqs, RpcServerProtseq, entry) {
EnterCriticalSection(&ps->cs);
- for (conn = ps->conn; conn; conn = conn->Next) {
+ conn = ps->conn;
+ while (conn) {
RPCRT4_MakeBinding((RpcBinding**)&(*BindingVector)->BindingH[count],
conn);
count++;
+ conn = conn->Next;
}
LeaveCriticalSection(&ps->cs);
}
*
* Must be called with server_cs held.
*/
-static RPC_STATUS alloc_serverprotoseq(UINT MaxCalls, const char *Protseq, RpcServerProtseq **ps)
+static RPC_STATUS alloc_serverprotoseq(UINT MaxCalls, char *Protseq, RpcServerProtseq **ps)
{
const struct protseq_ops *ops = rpcrt4_get_protseq_ops(Protseq);
if (!*ps)
return RPC_S_OUT_OF_RESOURCES;
(*ps)->MaxCalls = MaxCalls;
- (*ps)->Protseq = RPCRT4_strdupA(Protseq);
+ (*ps)->Protseq = Protseq;
(*ps)->ops = ops;
(*ps)->MaxCalls = 0;
(*ps)->conn = NULL;
return RPC_S_OK;
}
-/* must be called with server_cs held */
-static void destroy_serverprotoseq(RpcServerProtseq *ps)
-{
- RPCRT4_strfree(ps->Protseq);
- DeleteCriticalSection(&ps->cs);
- CloseHandle(ps->mgr_mutex);
- CloseHandle(ps->server_ready_event);
- list_remove(&ps->entry);
- HeapFree(GetProcessHeap(), 0, ps);
-}
-
/* Finds a given protseq or creates a new one if one doesn't already exist */
-static RPC_STATUS RPCRT4_get_or_create_serverprotseq(UINT MaxCalls, const char *Protseq, RpcServerProtseq **ps)
+static RPC_STATUS RPCRT4_get_or_create_serverprotseq(UINT MaxCalls, char *Protseq, RpcServerProtseq **ps)
{
RPC_STATUS status;
RpcServerProtseq *cps;
RPC_STATUS WINAPI RpcServerUseProtseqEpExA( RPC_CSTR Protseq, UINT MaxCalls, RPC_CSTR Endpoint, LPVOID SecurityDescriptor,
PRPC_POLICY lpPolicy )
{
+ char *szps = (char*)Protseq, *szep = (char*)Endpoint;
RpcServerProtseq* ps;
RPC_STATUS status;
- TRACE("(%s,%u,%s,%p,{%u,%u,%u})\n", debugstr_a((const char *)Protseq),
- MaxCalls, debugstr_a((const char *)Endpoint), SecurityDescriptor,
+ TRACE("(%s,%u,%s,%p,{%u,%u,%u})\n", debugstr_a(szps), MaxCalls,
+ debugstr_a(szep), SecurityDescriptor,
lpPolicy->Length, lpPolicy->EndpointFlags, lpPolicy->NICFlags );
- status = RPCRT4_get_or_create_serverprotseq(MaxCalls, (const char *)Protseq, &ps);
+ status = RPCRT4_get_or_create_serverprotseq(MaxCalls, RPCRT4_strdupA(szps), &ps);
if (status != RPC_S_OK)
return status;
- return RPCRT4_use_protseq(ps, (const char *)Endpoint);
+ return RPCRT4_use_protseq(ps, szep);
}
/***********************************************************************
{
RpcServerProtseq* ps;
RPC_STATUS status;
- LPSTR ProtseqA;
LPSTR EndpointA;
TRACE("(%s,%u,%s,%p,{%u,%u,%u})\n", debugstr_w( Protseq ), MaxCalls,
debugstr_w( Endpoint ), SecurityDescriptor,
lpPolicy->Length, lpPolicy->EndpointFlags, lpPolicy->NICFlags );
- ProtseqA = RPCRT4_strdupWtoA(Protseq);
- status = RPCRT4_get_or_create_serverprotseq(MaxCalls, ProtseqA, &ps);
- RPCRT4_strfree(ProtseqA);
+ status = RPCRT4_get_or_create_serverprotseq(MaxCalls, RPCRT4_strdupWtoA(Protseq), &ps);
if (status != RPC_S_OK)
return status;
*/
RPC_STATUS WINAPI RpcServerUseProtseqA(RPC_CSTR Protseq, unsigned int MaxCalls, void *SecurityDescriptor)
{
- RPC_STATUS status;
- RpcServerProtseq* ps;
-
TRACE("(Protseq == %s, MaxCalls == %d, SecurityDescriptor == ^%p)\n", debugstr_a((char*)Protseq), MaxCalls, SecurityDescriptor);
-
- status = RPCRT4_get_or_create_serverprotseq(MaxCalls, (const char *)Protseq, &ps);
- if (status != RPC_S_OK)
- return status;
-
- return RPCRT4_use_protseq(ps, NULL);
+ return RpcServerUseProtseqEpA(Protseq, MaxCalls, NULL, SecurityDescriptor);
}
/***********************************************************************
*/
RPC_STATUS WINAPI RpcServerUseProtseqW(RPC_WSTR Protseq, unsigned int MaxCalls, void *SecurityDescriptor)
{
- RPC_STATUS status;
- RpcServerProtseq* ps;
- LPSTR ProtseqA;
-
TRACE("Protseq == %s, MaxCalls == %d, SecurityDescriptor == ^%p)\n", debugstr_w(Protseq), MaxCalls, SecurityDescriptor);
-
- ProtseqA = RPCRT4_strdupWtoA(Protseq);
- status = RPCRT4_get_or_create_serverprotseq(MaxCalls, ProtseqA, &ps);
- RPCRT4_strfree(ProtseqA);
- if (status != RPC_S_OK)
- return status;
-
- return RPCRT4_use_protseq(ps, NULL);
-}
-
-void RPCRT4_destroy_all_protseqs(void)
-{
- RpcServerProtseq *cps, *cursor2;
-
- if (listen_count != 0)
- std_listen = FALSE;
-
- EnterCriticalSection(&server_cs);
- LIST_FOR_EACH_ENTRY_SAFE(cps, cursor2, &protseqs, RpcServerProtseq, entry)
- {
- if (listen_count != 0)
- RPCRT4_sync_with_server_thread(cps);
- destroy_serverprotoseq(cps);
- }
- LeaveCriticalSection(&server_cs);
+ return RpcServerUseProtseqEpW(Protseq, MaxCalls, NULL, SecurityDescriptor);
}
/***********************************************************************
RPC_STATUS WINAPI RpcServerRegisterIf2( RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv,
UINT Flags, UINT MaxCalls, UINT MaxRpcSize, RPC_IF_CALLBACK_FN* IfCallbackFn )
{
- PRPC_SERVER_INTERFACE If = IfSpec;
+ PRPC_SERVER_INTERFACE If = (PRPC_SERVER_INTERFACE)IfSpec;
RpcServerInterface* sif;
unsigned int i;
*/
RPC_STATUS WINAPI RpcServerUnregisterIf( RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, UINT WaitForCallsToComplete )
{
- PRPC_SERVER_INTERFACE If = IfSpec;
+ PRPC_SERVER_INTERFACE If = (PRPC_SERVER_INTERFACE)IfSpec;
HANDLE event = NULL;
BOOL found = FALSE;
BOOL completed = TRUE;
return RPC_S_OK;
}
-struct rpc_server_registered_auth_info
-{
- struct list entry;
- TimeStamp exp;
- CredHandle cred;
- ULONG max_token;
- USHORT auth_type;
-};
-
-RPC_STATUS RPCRT4_ServerGetRegisteredAuthInfo(
- USHORT auth_type, CredHandle *cred, TimeStamp *exp, ULONG *max_token)
-{
- RPC_STATUS status = RPC_S_UNKNOWN_AUTHN_SERVICE;
- struct rpc_server_registered_auth_info *auth_info;
-
- EnterCriticalSection(&server_auth_info_cs);
- LIST_FOR_EACH_ENTRY(auth_info, &server_registered_auth_info, struct rpc_server_registered_auth_info, entry)
- {
- if (auth_info->auth_type == auth_type)
- {
- *cred = auth_info->cred;
- *exp = auth_info->exp;
- *max_token = auth_info->max_token;
- status = RPC_S_OK;
- break;
- }
- }
- LeaveCriticalSection(&server_auth_info_cs);
-
- return status;
-}
-
-void RPCRT4_ServerFreeAllRegisteredAuthInfo(void)
-{
- struct rpc_server_registered_auth_info *auth_info, *cursor2;
-
- EnterCriticalSection(&server_auth_info_cs);
- LIST_FOR_EACH_ENTRY_SAFE(auth_info, cursor2, &server_registered_auth_info, struct rpc_server_registered_auth_info, entry)
- {
- FreeCredentialsHandle(&auth_info->cred);
- HeapFree(GetProcessHeap(), 0, auth_info);
- }
- LeaveCriticalSection(&server_auth_info_cs);
-}
-
/***********************************************************************
* RpcServerRegisterAuthInfoA (RPCRT4.@)
*/
RPC_STATUS WINAPI RpcServerRegisterAuthInfoA( RPC_CSTR ServerPrincName, ULONG AuthnSvc, RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn,
LPVOID Arg )
{
- SECURITY_STATUS sec_status;
- CredHandle cred;
- TimeStamp exp;
- ULONG package_count;
- ULONG i;
- PSecPkgInfoA packages;
- ULONG max_token;
- struct rpc_server_registered_auth_info *auth_info;
-
- TRACE("(%s,%u,%p,%p)\n", ServerPrincName, AuthnSvc, GetKeyFn, Arg);
-
- sec_status = EnumerateSecurityPackagesA(&package_count, &packages);
- if (sec_status != SEC_E_OK)
- {
- ERR("EnumerateSecurityPackagesA failed with error 0x%08x\n",
- sec_status);
- return RPC_S_SEC_PKG_ERROR;
- }
-
- for (i = 0; i < package_count; i++)
- if (packages[i].wRPCID == AuthnSvc)
- break;
-
- if (i == package_count)
- {
- WARN("unsupported AuthnSvc %u\n", AuthnSvc);
- FreeContextBuffer(packages);
- return RPC_S_UNKNOWN_AUTHN_SERVICE;
- }
- TRACE("found package %s for service %u\n", packages[i].Name,
- AuthnSvc);
- sec_status = AcquireCredentialsHandleA((SEC_CHAR *)ServerPrincName,
- packages[i].Name,
- SECPKG_CRED_INBOUND, NULL, NULL,
- NULL, NULL, &cred, &exp);
- max_token = packages[i].cbMaxToken;
- FreeContextBuffer(packages);
- if (sec_status != SEC_E_OK)
- return RPC_S_SEC_PKG_ERROR;
-
- auth_info = HeapAlloc(GetProcessHeap(), 0, sizeof(*auth_info));
- if (!auth_info)
- {
- FreeCredentialsHandle(&cred);
- return RPC_S_OUT_OF_RESOURCES;
- }
-
- auth_info->exp = exp;
- auth_info->cred = cred;
- auth_info->max_token = max_token;
- auth_info->auth_type = AuthnSvc;
-
- EnterCriticalSection(&server_auth_info_cs);
- list_add_tail(&server_registered_auth_info, &auth_info->entry);
- LeaveCriticalSection(&server_auth_info_cs);
-
- return RPC_S_OK;
+ FIXME( "(%s,%u,%p,%p): stub\n", ServerPrincName, AuthnSvc, GetKeyFn, Arg );
+
+ return RPC_S_UNKNOWN_AUTHN_SERVICE; /* We don't know any authentication services */
}
/***********************************************************************
RPC_STATUS WINAPI RpcServerRegisterAuthInfoW( RPC_WSTR ServerPrincName, ULONG AuthnSvc, RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn,
LPVOID Arg )
{
- SECURITY_STATUS sec_status;
- CredHandle cred;
- TimeStamp exp;
- ULONG package_count;
- ULONG i;
- PSecPkgInfoW packages;
- ULONG max_token;
- struct rpc_server_registered_auth_info *auth_info;
-
- TRACE("(%s,%u,%p,%p)\n", debugstr_w(ServerPrincName), AuthnSvc, GetKeyFn, Arg);
-
- sec_status = EnumerateSecurityPackagesW(&package_count, &packages);
- if (sec_status != SEC_E_OK)
- {
- ERR("EnumerateSecurityPackagesW failed with error 0x%08x\n",
- sec_status);
- return RPC_S_SEC_PKG_ERROR;
- }
-
- for (i = 0; i < package_count; i++)
- if (packages[i].wRPCID == AuthnSvc)
- break;
-
- if (i == package_count)
- {
- WARN("unsupported AuthnSvc %u\n", AuthnSvc);
- FreeContextBuffer(packages);
- return RPC_S_UNKNOWN_AUTHN_SERVICE;
- }
- TRACE("found package %s for service %u\n", debugstr_w(packages[i].Name),
- AuthnSvc);
- sec_status = AcquireCredentialsHandleW((SEC_WCHAR *)ServerPrincName,
- packages[i].Name,
- SECPKG_CRED_INBOUND, NULL, NULL,
- NULL, NULL, &cred, &exp);
- max_token = packages[i].cbMaxToken;
- FreeContextBuffer(packages);
- if (sec_status != SEC_E_OK)
- return RPC_S_SEC_PKG_ERROR;
-
- auth_info = HeapAlloc(GetProcessHeap(), 0, sizeof(*auth_info));
- if (!auth_info)
- {
- FreeCredentialsHandle(&cred);
- return RPC_S_OUT_OF_RESOURCES;
- }
-
- auth_info->exp = exp;
- auth_info->cred = cred;
- auth_info->max_token = max_token;
- auth_info->auth_type = AuthnSvc;
-
- EnterCriticalSection(&server_auth_info_cs);
- list_add_tail(&server_registered_auth_info, &auth_info->entry);
- LeaveCriticalSection(&server_auth_info_cs);
-
- return RPC_S_OK;
+ FIXME( "(%s,%u,%p,%p): stub\n", debugstr_w( ServerPrincName ), AuthnSvc, GetKeyFn, Arg );
+
+ return RPC_S_UNKNOWN_AUTHN_SERVICE; /* We don't know any authentication services */
}
/***********************************************************************
* new connection was established */
int (*wait_for_new_connection)(RpcServerProtseq *protseq, unsigned int count, void *wait_array);
/* opens the endpoint and optionally begins listening */
- RPC_STATUS (*open_endpoint)(RpcServerProtseq *protseq, const char *endpoint);
+ RPC_STATUS (*open_endpoint)(RpcServerProtseq *protseq, LPSTR endpoint);
};
typedef struct _RpcServerInterface
void RPCRT4_new_client(RpcConnection* conn);
const struct protseq_ops *rpcrt4_get_protseq_ops(const char *protseq);
-void RPCRT4_destroy_all_protseqs(void);
-void RPCRT4_ServerFreeAllRegisteredAuthInfo(void);
-
#endif /* __WINE_RPC_SERVER_H */
# ifndef EAGAIN
# define EAGAIN WSAEWOULDBLOCK
# endif
-# undef errno
-# define errno WSAGetLastError()
#else
# include <errno.h>
# ifdef HAVE_UNISTD_H
# define SOL_TCP IPPROTO_TCP
#endif
-#define DEFAULT_NCACN_HTTP_TIMEOUT (60 * 1000)
-
WINE_DEFAULT_DEBUG_CHANNEL(rpc);
static RPC_STATUS RPCRT4_SpawnConnection(RpcConnection** Connection, RpcConnection* OldConnection);
return r;
}
-static RPC_STATUS rpcrt4_protseq_ncalrpc_open_endpoint(RpcServerProtseq* protseq, const char *endpoint)
+static RPC_STATUS rpcrt4_protseq_ncalrpc_open_endpoint(RpcServerProtseq* protseq, LPSTR endpoint)
{
static const char prefix[] = "\\\\.\\pipe\\lrpc\\";
RPC_STATUS r;
return r;
}
-static RPC_STATUS rpcrt4_protseq_ncacn_np_open_endpoint(RpcServerProtseq *protseq, const char *endpoint)
+static RPC_STATUS rpcrt4_protseq_ncacn_np_open_endpoint(RpcServerProtseq *protseq, LPSTR endpoint)
{
static const char prefix[] = "\\\\.";
RPC_STATUS r;
return RPC_S_OK;
}
-static RPC_STATUS rpcrt4_conn_np_impersonate_client(RpcConnection *conn)
-{
- RpcConnection_np *npc = (RpcConnection_np *)conn;
- BOOL ret;
-
- TRACE("(%p)\n", conn);
-
- if (conn->AuthInfo && SecIsValidHandle(&conn->ctx))
- return RPCRT4_default_impersonate_client(conn);
-
- ret = ImpersonateNamedPipeClient(npc->pipe);
- if (!ret)
- {
- DWORD error = GetLastError();
- WARN("ImpersonateNamedPipeClient failed with error %u\n", error);
- switch (error)
- {
- case ERROR_CANNOT_IMPERSONATE:
- return RPC_S_NO_CONTEXT_AVAILABLE;
- }
- }
- return RPC_S_OK;
-}
-
-static RPC_STATUS rpcrt4_conn_np_revert_to_self(RpcConnection *conn)
-{
- BOOL ret;
-
- TRACE("(%p)\n", conn);
-
- if (conn->AuthInfo && SecIsValidHandle(&conn->ctx))
- return RPCRT4_default_revert_to_self(conn);
-
- ret = RevertToSelf();
- if (!ret)
- {
- WARN("RevertToSelf failed with error %u\n", GetLastError());
- return RPC_S_NO_CONTEXT_AVAILABLE;
- }
- return RPC_S_OK;
-}
-
typedef struct _RpcServerProtseq_np
{
RpcServerProtseq common;
return RPC_S_OK;
}
-static BOOL rpcrt4_ncalrpc_is_authorized(RpcConnection *conn)
-{
- return FALSE;
-}
-
-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)
-{
- /* since this protocol is local to the machine there is no need to
- * authenticate the caller */
- *out_size = 0;
- return RPC_S_OK;
-}
-
-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)
-{
- /* since this protocol is local to the machine there is no need to secure
- * the packet */
- return RPC_S_OK;
-}
-
-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)
-{
- TRACE("(%p, %p, %p, %p, %p, %p, 0x%x)\n", conn, privs,
- server_princ_name, authn_level, authn_svc, authz_svc, flags);
-
- if (privs)
- {
- FIXME("privs not implemented\n");
- *privs = NULL;
- }
- if (server_princ_name)
- {
- FIXME("server_princ_name not implemented\n");
- *server_princ_name = NULL;
- }
- if (authn_level) *authn_level = RPC_C_AUTHN_LEVEL_PKT_PRIVACY;
- if (authn_svc) *authn_svc = RPC_C_AUTHN_WINNT;
- if (authz_svc)
- {
- FIXME("authorization service not implemented\n");
- *authz_svc = RPC_C_AUTHZ_NONE;
- }
- if (flags)
- FIXME("flags 0x%x not implemented\n", flags);
-
- return RPC_S_OK;
-}
-
/**** ncacn_ip_tcp support ****/
static size_t rpcrt4_ip_tcp_get_top_of_tower(unsigned char *tower_data,
return RPC_S_SERVER_UNAVAILABLE;
}
-static RPC_STATUS rpcrt4_protseq_ncacn_ip_tcp_open_endpoint(RpcServerProtseq *protseq, const char *endpoint)
+static RPC_STATUS rpcrt4_protseq_ncacn_ip_tcp_open_endpoint(RpcServerProtseq *protseq, LPSTR endpoint)
{
RPC_STATUS status = RPC_S_CANT_CREATE_ENDPOINT;
int sock;
endpoint);
}
-#if 0
-/**** ncacn_http support ****/
-
-/* 60 seconds is the period native uses */
-#define HTTP_IDLE_TIME 60000
-
-/* reference counted to avoid a race between a cancelled call's connection
- * being destroyed and the asynchronous InternetReadFileEx call being
- * completed */
-typedef struct _RpcHttpAsyncData
-{
- LONG refs;
- HANDLE completion_event;
- INTERNET_BUFFERSA inet_buffers;
- void *destination_buffer; /* the address that inet_buffers.lpvBuffer will be
- * copied into when the call completes */
- CRITICAL_SECTION cs;
-} RpcHttpAsyncData;
-
-static ULONG RpcHttpAsyncData_AddRef(RpcHttpAsyncData *data)
-{
- return InterlockedIncrement(&data->refs);
-}
-
-static ULONG RpcHttpAsyncData_Release(RpcHttpAsyncData *data)
-{
- ULONG refs = InterlockedDecrement(&data->refs);
- if (!refs)
- {
- TRACE("destroying async data %p\n", data);
- CloseHandle(data->completion_event);
- HeapFree(GetProcessHeap(), 0, data->inet_buffers.lpvBuffer);
- DeleteCriticalSection(&data->cs);
- HeapFree(GetProcessHeap(), 0, data);
- }
- return refs;
-}
-
-typedef struct _RpcConnection_http
-{
- RpcConnection common;
- HINTERNET app_info;
- HINTERNET session;
- HINTERNET in_request;
- HINTERNET out_request;
- HANDLE timer_cancelled;
- HANDLE cancel_event;
- DWORD last_sent_time;
- ULONG bytes_received;
- ULONG flow_control_mark; /* send a control packet to the server when this many bytes received */
- ULONG flow_control_increment; /* number of bytes to increment flow_control_mark by */
- UUID connection_uuid;
- UUID in_pipe_uuid;
- UUID out_pipe_uuid;
- RpcHttpAsyncData *async_data;
-} RpcConnection_http;
-
-static RpcConnection *rpcrt4_ncacn_http_alloc(void)
-{
- RpcConnection_http *httpc;
- httpc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*httpc));
- if (!httpc) return NULL;
- httpc->async_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(RpcHttpAsyncData));
- if (!httpc->async_data)
- {
- HeapFree(GetProcessHeap(), 0, httpc);
- return NULL;
- }
- TRACE("async data = %p\n", httpc->async_data);
- httpc->cancel_event = CreateEventW(NULL, FALSE, FALSE, NULL);
- httpc->async_data->refs = 1;
- httpc->async_data->inet_buffers.dwStructSize = sizeof(INTERNET_BUFFERSA);
- httpc->async_data->inet_buffers.lpvBuffer = NULL;
- httpc->async_data->destination_buffer = NULL;
- InitializeCriticalSection(&httpc->async_data->cs);
- return &httpc->common;
-}
-
-typedef struct _HttpTimerThreadData
-{
- PVOID timer_param;
- DWORD *last_sent_time;
- HANDLE timer_cancelled;
-} HttpTimerThreadData;
-
-static VOID rpcrt4_http_keep_connection_active_timer_proc(PVOID param, BOOLEAN dummy)
-{
- HINTERNET in_request = param;
- RpcPktHdr *idle_pkt;
-
- idle_pkt = RPCRT4_BuildHttpHeader(NDR_LOCAL_DATA_REPRESENTATION, 0x0001,
- 0, 0);
- if (idle_pkt)
- {
- DWORD bytes_written;
- InternetWriteFile(in_request, idle_pkt, idle_pkt->common.frag_len, &bytes_written);
- RPCRT4_FreeHeader(idle_pkt);
- }
-}
-
-static inline DWORD rpcrt4_http_timer_calc_timeout(DWORD *last_sent_time)
-{
- DWORD cur_time = GetTickCount();
- DWORD cached_last_sent_time = *last_sent_time;
- return HTTP_IDLE_TIME - (cur_time - cached_last_sent_time > HTTP_IDLE_TIME ? 0 : cur_time - cached_last_sent_time);
-}
-
-static DWORD CALLBACK rpcrt4_http_timer_thread(PVOID param)
-{
- HttpTimerThreadData *data_in = param;
- HttpTimerThreadData data;
- DWORD timeout;
-
- data = *data_in;
- HeapFree(GetProcessHeap(), 0, data_in);
-
- for (timeout = HTTP_IDLE_TIME;
- WaitForSingleObject(data.timer_cancelled, timeout) == WAIT_TIMEOUT;
- timeout = rpcrt4_http_timer_calc_timeout(data.last_sent_time))
- {
- /* are we too soon after last send? */
- if (GetTickCount() - HTTP_IDLE_TIME < *data.last_sent_time)
- continue;
- rpcrt4_http_keep_connection_active_timer_proc(data.timer_param, TRUE);
- }
-
- CloseHandle(data.timer_cancelled);
- return 0;
-}
-
-static VOID WINAPI rpcrt4_http_internet_callback(
- HINTERNET hInternet,
- DWORD_PTR dwContext,
- DWORD dwInternetStatus,
- LPVOID lpvStatusInformation,
- DWORD dwStatusInformationLength)
-{
- RpcHttpAsyncData *async_data = (RpcHttpAsyncData *)dwContext;
-
- switch (dwInternetStatus)
- {
- case INTERNET_STATUS_REQUEST_COMPLETE:
- TRACE("INTERNET_STATUS_REQUEST_COMPLETED\n");
- if (async_data)
- {
- if (async_data->inet_buffers.lpvBuffer)
- {
- EnterCriticalSection(&async_data->cs);
- if (async_data->destination_buffer)
- {
- memcpy(async_data->destination_buffer,
- async_data->inet_buffers.lpvBuffer,
- async_data->inet_buffers.dwBufferLength);
- async_data->destination_buffer = NULL;
- }
- LeaveCriticalSection(&async_data->cs);
- }
- HeapFree(GetProcessHeap(), 0, async_data->inet_buffers.lpvBuffer);
- async_data->inet_buffers.lpvBuffer = NULL;
- SetEvent(async_data->completion_event);
- RpcHttpAsyncData_Release(async_data);
- }
- break;
- }
-}
-
-static RPC_STATUS rpcrt4_http_check_response(HINTERNET hor)
-{
- BOOL ret;
- DWORD status_code;
- DWORD size;
- DWORD index;
- WCHAR buf[32];
- WCHAR *status_text = buf;
- TRACE("\n");
-
- index = 0;
- size = sizeof(status_code);
- ret = HttpQueryInfoW(hor, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &status_code, &size, &index);
- if (!ret)
- return GetLastError();
- if (status_code < 400)
- return RPC_S_OK;
- index = 0;
- size = sizeof(buf);
- ret = HttpQueryInfoW(hor, HTTP_QUERY_STATUS_TEXT, status_text, &size, &index);
- if (!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER)
- {
- status_text = HeapAlloc(GetProcessHeap(), 0, size);
- ret = HttpQueryInfoW(hor, HTTP_QUERY_STATUS_TEXT, status_text, &size, &index);
- }
-
- ERR("server returned: %d %s\n", status_code, ret ? debugstr_w(status_text) : "<status text unavailable>");
- if(status_text != buf) HeapFree(GetProcessHeap(), 0, status_text);
-
- if (status_code == HTTP_STATUS_DENIED)
- return ERROR_ACCESS_DENIED;
- return RPC_S_SERVER_UNAVAILABLE;
-}
-
-static RPC_STATUS rpcrt4_http_internet_connect(RpcConnection_http *httpc)
-{
- static const WCHAR wszUserAgent[] = {'M','S','R','P','C',0};
- LPWSTR proxy = NULL;
- LPWSTR user = NULL;
- LPWSTR password = NULL;
- LPWSTR servername = NULL;
- const WCHAR *option;
- INTERNET_PORT port = INTERNET_INVALID_PORT_NUMBER; /* use default port */
-
- if (httpc->common.QOS &&
- (httpc->common.QOS->qos->AdditionalSecurityInfoType == RPC_C_AUTHN_INFO_TYPE_HTTP))
- {
- const RPC_HTTP_TRANSPORT_CREDENTIALS_W *http_cred = httpc->common.QOS->qos->u.HttpCredentials;
- if (http_cred->TransportCredentials)
- {
- WCHAR *p;
- const SEC_WINNT_AUTH_IDENTITY_W *cred = http_cred->TransportCredentials;
- ULONG len = cred->DomainLength + 1 + cred->UserLength;
- user = HeapAlloc(GetProcessHeap(), 0, (len + 1) * sizeof(WCHAR));
- if (!user)
- return RPC_S_OUT_OF_RESOURCES;
- p = user;
- if (cred->DomainLength)
- {
- memcpy(p, cred->Domain, cred->DomainLength * sizeof(WCHAR));
- p += cred->DomainLength;
- *p = '\\';
- p++;
- }
- memcpy(p, cred->User, cred->UserLength * sizeof(WCHAR));
- p[cred->UserLength] = 0;
-
- password = RPCRT4_strndupW(cred->Password, cred->PasswordLength);
- }
- }
-
- for (option = httpc->common.NetworkOptions; option;
- option = (strchrW(option, ',') ? strchrW(option, ',')+1 : NULL))
- {
- static const WCHAR wszRpcProxy[] = {'R','p','c','P','r','o','x','y','=',0};
- static const WCHAR wszHttpProxy[] = {'H','t','t','p','P','r','o','x','y','=',0};
-
- if (!strncmpiW(option, wszRpcProxy, sizeof(wszRpcProxy)/sizeof(wszRpcProxy[0])-1))
- {
- const WCHAR *value_start = option + sizeof(wszRpcProxy)/sizeof(wszRpcProxy[0])-1;
- const WCHAR *value_end;
- const WCHAR *p;
-
- value_end = strchrW(option, ',');
- if (!value_end)
- value_end = value_start + strlenW(value_start);
- for (p = value_start; p < value_end; p++)
- if (*p == ':')
- {
- port = atoiW(p+1);
- value_end = p;
- break;
- }
- TRACE("RpcProxy value is %s\n", debugstr_wn(value_start, value_end-value_start));
- servername = RPCRT4_strndupW(value_start, value_end-value_start);
- }
- else if (!strncmpiW(option, wszHttpProxy, sizeof(wszHttpProxy)/sizeof(wszHttpProxy[0])-1))
- {
- const WCHAR *value_start = option + sizeof(wszHttpProxy)/sizeof(wszHttpProxy[0])-1;
- const WCHAR *value_end;
-
- value_end = strchrW(option, ',');
- if (!value_end)
- value_end = value_start + strlenW(value_start);
- TRACE("HttpProxy value is %s\n", debugstr_wn(value_start, value_end-value_start));
- proxy = RPCRT4_strndupW(value_start, value_end-value_start);
- }
- else
- FIXME("unhandled option %s\n", debugstr_w(option));
- }
-
- httpc->app_info = InternetOpenW(wszUserAgent, proxy ? INTERNET_OPEN_TYPE_PROXY : INTERNET_OPEN_TYPE_PRECONFIG,
- NULL, NULL, INTERNET_FLAG_ASYNC);
- if (!httpc->app_info)
- {
- HeapFree(GetProcessHeap(), 0, password);
- HeapFree(GetProcessHeap(), 0, user);
- ERR("InternetOpenW failed with error %d\n", GetLastError());
- return RPC_S_SERVER_UNAVAILABLE;
- }
- InternetSetStatusCallbackW(httpc->app_info, rpcrt4_http_internet_callback);
-
- /* if no RpcProxy option specified, set the HTTP server address to the
- * RPC server address */
- if (!servername)
- {
- servername = HeapAlloc(GetProcessHeap(), 0, (strlen(httpc->common.NetworkAddr) + 1)*sizeof(WCHAR));
- if (!servername)
- {
- HeapFree(GetProcessHeap(), 0, password);
- HeapFree(GetProcessHeap(), 0, user);
- return RPC_S_OUT_OF_RESOURCES;
- }
- MultiByteToWideChar(CP_ACP, 0, httpc->common.NetworkAddr, -1, servername, strlen(httpc->common.NetworkAddr) + 1);
- }
-
- httpc->session = InternetConnectW(httpc->app_info, servername, port, user, password,
- INTERNET_SERVICE_HTTP, 0, 0);
-
- HeapFree(GetProcessHeap(), 0, password);
- HeapFree(GetProcessHeap(), 0, user);
- HeapFree(GetProcessHeap(), 0, servername);
-
- if (!httpc->session)
- {
- ERR("InternetConnectW failed with error %d\n", GetLastError());
- return RPC_S_SERVER_UNAVAILABLE;
- }
-
- return RPC_S_OK;
-}
-
-/* prepare the in pipe for use by RPC packets */
-static RPC_STATUS rpcrt4_http_prepare_in_pipe(HINTERNET in_request, RpcHttpAsyncData *async_data,
- const UUID *connection_uuid,
- const UUID *in_pipe_uuid,
- const UUID *association_uuid)
-{
- BYTE packet[44];
- BOOL ret;
- RPC_STATUS status;
- RpcPktHdr *hdr;
- INTERNET_BUFFERSW buffers_in;
- DWORD bytes_read, bytes_written;
-
- /* prepare in pipe */
- ResetEvent(async_data->completion_event);
- RpcHttpAsyncData_AddRef(async_data);
- ret = HttpSendRequestW(in_request, NULL, 0, NULL, 0);
- if (!ret)
- {
- if (GetLastError() == ERROR_IO_PENDING)
- WaitForSingleObject(async_data->completion_event, INFINITE);
- else
- {
- RpcHttpAsyncData_Release(async_data);
- ERR("HttpSendRequestW failed with error %d\n", GetLastError());
- return RPC_S_SERVER_UNAVAILABLE;
- }
- }
- status = rpcrt4_http_check_response(in_request);
- if (status != RPC_S_OK) return status;
-
- InternetReadFile(in_request, packet, 20, &bytes_read);
- /* FIXME: do something with retrieved data */
-
- memset(&buffers_in, 0, sizeof(buffers_in));
- buffers_in.dwStructSize = sizeof(buffers_in);
- /* FIXME: get this from the registry */
- buffers_in.dwBufferTotal = 1024 * 1024 * 1024; /* 1Gb */
- ResetEvent(async_data->completion_event);
- RpcHttpAsyncData_AddRef(async_data);
- ret = HttpSendRequestExW(in_request, &buffers_in, NULL, 0, 0);
- if (!ret)
- {
- if (GetLastError() == ERROR_IO_PENDING)
- WaitForSingleObject(async_data->completion_event, INFINITE);
- else
- {
- RpcHttpAsyncData_Release(async_data);
- ERR("HttpSendRequestExW failed with error %d\n", GetLastError());
- return RPC_S_SERVER_UNAVAILABLE;
- }
- }
-
- TRACE("sending HTTP connect header to server\n");
- hdr = RPCRT4_BuildHttpConnectHeader(0, FALSE, connection_uuid, in_pipe_uuid, association_uuid);
- if (!hdr) return RPC_S_OUT_OF_RESOURCES;
- ret = InternetWriteFile(in_request, hdr, hdr->common.frag_len, &bytes_written);
- RPCRT4_FreeHeader(hdr);
- if (!ret)
- {
- ERR("InternetWriteFile failed with error %d\n", GetLastError());
- return RPC_S_SERVER_UNAVAILABLE;
- }
-
- return RPC_S_OK;
-}
-
-static RPC_STATUS rpcrt4_http_read_http_packet(HINTERNET request, RpcPktHdr *hdr, BYTE **data)
-{
- BOOL ret;
- DWORD bytes_read;
- unsigned short data_len;
-
- ret = InternetReadFile(request, hdr, sizeof(hdr->common), &bytes_read);
- if (!ret)
- return RPC_S_SERVER_UNAVAILABLE;
- if (hdr->common.ptype != PKT_HTTP || hdr->common.frag_len < sizeof(hdr->http))
- {
- ERR("wrong packet type received %d or wrong frag_len %d\n",
- hdr->common.ptype, hdr->common.frag_len);
- return RPC_S_PROTOCOL_ERROR;
- }
-
- ret = InternetReadFile(request, &hdr->common + 1, sizeof(hdr->http) - sizeof(hdr->common), &bytes_read);
- if (!ret)
- return RPC_S_SERVER_UNAVAILABLE;
-
- data_len = hdr->common.frag_len - sizeof(hdr->http);
- if (data_len)
- {
- *data = HeapAlloc(GetProcessHeap(), 0, data_len);
- if (!*data)
- return RPC_S_OUT_OF_RESOURCES;
- ret = InternetReadFile(request, *data, data_len, &bytes_read);
- if (!ret)
- {
- HeapFree(GetProcessHeap(), 0, *data);
- return RPC_S_SERVER_UNAVAILABLE;
- }
- }
- else
- *data = NULL;
-
- if (!RPCRT4_IsValidHttpPacket(hdr, *data, data_len))
- {
- ERR("invalid http packet\n");
- return RPC_S_PROTOCOL_ERROR;
- }
-
- return RPC_S_OK;
-}
-
-/* prepare the out pipe for use by RPC packets */
-static RPC_STATUS rpcrt4_http_prepare_out_pipe(HINTERNET out_request,
- RpcHttpAsyncData *async_data,
- const UUID *connection_uuid,
- const UUID *out_pipe_uuid,
- ULONG *flow_control_increment)
-{
- BYTE packet[20];
- BOOL ret;
- RPC_STATUS status;
- RpcPktHdr *hdr;
- DWORD bytes_read;
- BYTE *data_from_server;
- RpcPktHdr pkt_from_server;
- ULONG field1, field3;
-
- ResetEvent(async_data->completion_event);
- RpcHttpAsyncData_AddRef(async_data);
- ret = HttpSendRequestW(out_request, NULL, 0, NULL, 0);
- if (!ret)
- {
- if (GetLastError() == ERROR_IO_PENDING)
- WaitForSingleObject(async_data->completion_event, INFINITE);
- else
- {
- RpcHttpAsyncData_Release(async_data);
- ERR("HttpSendRequestW failed with error %d\n", GetLastError());
- return RPC_S_SERVER_UNAVAILABLE;
- }
- }
- status = rpcrt4_http_check_response(out_request);
- if (status != RPC_S_OK) return status;
-
- InternetReadFile(out_request, packet, 20, &bytes_read);
- /* FIXME: do something with retrieved data */
-
- hdr = RPCRT4_BuildHttpConnectHeader(0, TRUE, connection_uuid, out_pipe_uuid, NULL);
- if (!hdr) return RPC_S_OUT_OF_RESOURCES;
- ResetEvent(async_data->completion_event);
- RpcHttpAsyncData_AddRef(async_data);
- ret = HttpSendRequestW(out_request, NULL, 0, hdr, hdr->common.frag_len);
- if (!ret)
- {
- if (GetLastError() == ERROR_IO_PENDING)
- WaitForSingleObject(async_data->completion_event, INFINITE);
- else
- {
- RpcHttpAsyncData_Release(async_data);
- ERR("HttpSendRequestW failed with error %d\n", GetLastError());
- RPCRT4_FreeHeader(hdr);
- return RPC_S_SERVER_UNAVAILABLE;
- }
- }
- RPCRT4_FreeHeader(hdr);
- status = rpcrt4_http_check_response(out_request);
- if (status != RPC_S_OK) return status;
-
- status = rpcrt4_http_read_http_packet(out_request, &pkt_from_server,
- &data_from_server);
- if (status != RPC_S_OK) return status;
- status = RPCRT4_ParseHttpPrepareHeader1(&pkt_from_server, data_from_server,
- &field1);
- HeapFree(GetProcessHeap(), 0, data_from_server);
- if (status != RPC_S_OK) return status;
- TRACE("received (%d) from first prepare header\n", field1);
-
- status = rpcrt4_http_read_http_packet(out_request, &pkt_from_server,
- &data_from_server);
- if (status != RPC_S_OK) return status;
- status = RPCRT4_ParseHttpPrepareHeader2(&pkt_from_server, data_from_server,
- &field1, flow_control_increment,
- &field3);
- HeapFree(GetProcessHeap(), 0, data_from_server);
- if (status != RPC_S_OK) return status;
- TRACE("received (0x%08x 0x%08x %d) from second prepare header\n", field1, *flow_control_increment, field3);
-
- return RPC_S_OK;
-}
-
-static RPC_STATUS rpcrt4_ncacn_http_open(RpcConnection* Connection)
-{
- RpcConnection_http *httpc = (RpcConnection_http *)Connection;
- static const WCHAR wszVerbIn[] = {'R','P','C','_','I','N','_','D','A','T','A',0};
- static const WCHAR wszVerbOut[] = {'R','P','C','_','O','U','T','_','D','A','T','A',0};
- static const WCHAR wszRpcProxyPrefix[] = {'/','r','p','c','/','r','p','c','p','r','o','x','y','.','d','l','l','?',0};
- static const WCHAR wszColon[] = {':',0};
- static const WCHAR wszAcceptType[] = {'a','p','p','l','i','c','a','t','i','o','n','/','r','p','c',0};
- LPCWSTR wszAcceptTypes[] = { wszAcceptType, NULL };
- WCHAR *url;
- RPC_STATUS status;
- BOOL secure;
- HttpTimerThreadData *timer_data;
- HANDLE thread;
-
- TRACE("(%s, %s)\n", Connection->NetworkAddr, Connection->Endpoint);
-
- if (Connection->server)
- {
- ERR("ncacn_http servers not supported yet\n");
- return RPC_S_SERVER_UNAVAILABLE;
- }
-
- if (httpc->in_request)
- return RPC_S_OK;
-
- httpc->async_data->completion_event = CreateEventW(NULL, FALSE, FALSE, NULL);
-
- status = UuidCreate(&httpc->connection_uuid);
- status = UuidCreate(&httpc->in_pipe_uuid);
- status = UuidCreate(&httpc->out_pipe_uuid);
-
- status = rpcrt4_http_internet_connect(httpc);
- if (status != RPC_S_OK)
- return status;
-
- url = HeapAlloc(GetProcessHeap(), 0, sizeof(wszRpcProxyPrefix) + (strlen(Connection->NetworkAddr) + 1 + strlen(Connection->Endpoint))*sizeof(WCHAR));
- if (!url)
- return RPC_S_OUT_OF_MEMORY;
- memcpy(url, wszRpcProxyPrefix, sizeof(wszRpcProxyPrefix));
- MultiByteToWideChar(CP_ACP, 0, Connection->NetworkAddr, -1, url+sizeof(wszRpcProxyPrefix)/sizeof(wszRpcProxyPrefix[0])-1, strlen(Connection->NetworkAddr)+1);
- strcatW(url, wszColon);
- MultiByteToWideChar(CP_ACP, 0, Connection->Endpoint, -1, url+strlenW(url), strlen(Connection->Endpoint)+1);
-
- secure = httpc->common.QOS &&
- (httpc->common.QOS->qos->AdditionalSecurityInfoType == RPC_C_AUTHN_INFO_TYPE_HTTP) &&
- (httpc->common.QOS->qos->u.HttpCredentials->Flags & RPC_C_HTTP_FLAG_USE_SSL);
-
- httpc->in_request = HttpOpenRequestW(httpc->session, wszVerbIn, url, NULL, NULL,
- wszAcceptTypes,
- (secure ? INTERNET_FLAG_SECURE : 0)|INTERNET_FLAG_KEEP_CONNECTION|INTERNET_FLAG_PRAGMA_NOCACHE,
- (DWORD_PTR)httpc->async_data);
- if (!httpc->in_request)
- {
- ERR("HttpOpenRequestW failed with error %d\n", GetLastError());
- return RPC_S_SERVER_UNAVAILABLE;
- }
- httpc->out_request = HttpOpenRequestW(httpc->session, wszVerbOut, url, NULL, NULL,
- wszAcceptTypes,
- (secure ? INTERNET_FLAG_SECURE : 0)|INTERNET_FLAG_KEEP_CONNECTION|INTERNET_FLAG_PRAGMA_NOCACHE,
- (DWORD_PTR)httpc->async_data);
- if (!httpc->out_request)
- {
- ERR("HttpOpenRequestW failed with error %d\n", GetLastError());
- return RPC_S_SERVER_UNAVAILABLE;
- }
-
- status = rpcrt4_http_prepare_in_pipe(httpc->in_request,
- httpc->async_data,
- &httpc->connection_uuid,
- &httpc->in_pipe_uuid,
- &Connection->assoc->http_uuid);
- if (status != RPC_S_OK)
- return status;
-
- status = rpcrt4_http_prepare_out_pipe(httpc->out_request,
- httpc->async_data,
- &httpc->connection_uuid,
- &httpc->out_pipe_uuid,
- &httpc->flow_control_increment);
- if (status != RPC_S_OK)
- return status;
-
- httpc->flow_control_mark = httpc->flow_control_increment / 2;
- httpc->last_sent_time = GetTickCount();
- httpc->timer_cancelled = CreateEventW(NULL, FALSE, FALSE, NULL);
-
- timer_data = HeapAlloc(GetProcessHeap(), 0, sizeof(*timer_data));
- if (!timer_data)
- return ERROR_OUTOFMEMORY;
- timer_data->timer_param = httpc->in_request;
- timer_data->last_sent_time = &httpc->last_sent_time;
- timer_data->timer_cancelled = httpc->timer_cancelled;
- /* FIXME: should use CreateTimerQueueTimer when implemented */
- thread = CreateThread(NULL, 0, rpcrt4_http_timer_thread, timer_data, 0, NULL);
- if (!thread)
- {
- HeapFree(GetProcessHeap(), 0, timer_data);
- return GetLastError();
- }
- CloseHandle(thread);
-
- return RPC_S_OK;
-}
-
-static RPC_STATUS rpcrt4_ncacn_http_handoff(RpcConnection *old_conn, RpcConnection *new_conn)
-{
- assert(0);
- return RPC_S_SERVER_UNAVAILABLE;
-}
-
-static int rpcrt4_ncacn_http_read(RpcConnection *Connection,
- void *buffer, unsigned int count)
-{
- RpcConnection_http *httpc = (RpcConnection_http *) Connection;
- char *buf = buffer;
- BOOL ret = TRUE;
- unsigned int bytes_left = count;
-
- ResetEvent(httpc->async_data->completion_event);
- while (bytes_left)
- {
- RpcHttpAsyncData_AddRef(httpc->async_data);
- httpc->async_data->inet_buffers.dwBufferLength = bytes_left;
- httpc->async_data->inet_buffers.lpvBuffer = HeapAlloc(GetProcessHeap(), 0, bytes_left);
- httpc->async_data->destination_buffer = buf;
- ret = InternetReadFileExA(httpc->out_request, &httpc->async_data->inet_buffers, IRF_ASYNC, 0);
- if (ret)
- {
- /* INTERNET_STATUS_REQUEST_COMPLETED won't be sent, so release our
- * async ref now */
- RpcHttpAsyncData_Release(httpc->async_data);
- memcpy(buf, httpc->async_data->inet_buffers.lpvBuffer,
- httpc->async_data->inet_buffers.dwBufferLength);
- HeapFree(GetProcessHeap(), 0, httpc->async_data->inet_buffers.lpvBuffer);
- httpc->async_data->inet_buffers.lpvBuffer = NULL;
- httpc->async_data->destination_buffer = NULL;
- }
- else
- {
- if (GetLastError() == ERROR_IO_PENDING)
- {
- HANDLE handles[2] = { httpc->async_data->completion_event, httpc->cancel_event };
- DWORD result = WaitForMultipleObjects(2, handles, FALSE, DEFAULT_NCACN_HTTP_TIMEOUT);
- if (result == WAIT_OBJECT_0)
- ret = TRUE;
- else
- {
- TRACE("call cancelled\n");
- EnterCriticalSection(&httpc->async_data->cs);
- httpc->async_data->destination_buffer = NULL;
- LeaveCriticalSection(&httpc->async_data->cs);
- break;
- }
- }
- else
- {
- HeapFree(GetProcessHeap(), 0, httpc->async_data->inet_buffers.lpvBuffer);
- httpc->async_data->inet_buffers.lpvBuffer = NULL;
- httpc->async_data->destination_buffer = NULL;
- RpcHttpAsyncData_Release(httpc->async_data);
- break;
- }
- }
- if (!httpc->async_data->inet_buffers.dwBufferLength)
- break;
- bytes_left -= httpc->async_data->inet_buffers.dwBufferLength;
- buf += httpc->async_data->inet_buffers.dwBufferLength;
- }
- TRACE("%p %p %u -> %s\n", httpc->out_request, buffer, count, ret ? "TRUE" : "FALSE");
- return ret ? count : -1;
-}
-
-static RPC_STATUS rpcrt4_ncacn_http_receive_fragment(RpcConnection *Connection, RpcPktHdr **Header, void **Payload)
-{
- RpcConnection_http *httpc = (RpcConnection_http *) Connection;
- RPC_STATUS status;
- DWORD hdr_length;
- LONG dwRead;
- RpcPktCommonHdr common_hdr;
-
- *Header = NULL;
-
- TRACE("(%p, %p, %p)\n", Connection, Header, Payload);
-
-again:
- /* read packet common header */
- dwRead = rpcrt4_ncacn_http_read(Connection, &common_hdr, sizeof(common_hdr));
- if (dwRead != sizeof(common_hdr)) {
- WARN("Short read of header, %d bytes\n", dwRead);
- status = RPC_S_PROTOCOL_ERROR;
- goto fail;
- }
- if (!memcmp(&common_hdr, "HTTP/1.1", sizeof("HTTP/1.1")) ||
- !memcmp(&common_hdr, "HTTP/1.0", sizeof("HTTP/1.0")))
- {
- FIXME("server returned %s\n", debugstr_a((const char *)&common_hdr));
- status = RPC_S_PROTOCOL_ERROR;
- goto fail;
- }
-
- status = RPCRT4_ValidateCommonHeader(&common_hdr);
- if (status != RPC_S_OK) goto fail;
-
- hdr_length = RPCRT4_GetHeaderSize((RpcPktHdr*)&common_hdr);
- if (hdr_length == 0) {
- WARN("header length == 0\n");
- status = RPC_S_PROTOCOL_ERROR;
- goto fail;
- }
-
- *Header = HeapAlloc(GetProcessHeap(), 0, hdr_length);
- if (!*Header)
- {
- status = RPC_S_OUT_OF_RESOURCES;
- goto fail;
- }
- memcpy(*Header, &common_hdr, sizeof(common_hdr));
-
- /* read the rest of packet header */
- dwRead = rpcrt4_ncacn_http_read(Connection, &(*Header)->common + 1, hdr_length - sizeof(common_hdr));
- if (dwRead != hdr_length - sizeof(common_hdr)) {
- WARN("bad header length, %d bytes, hdr_length %d\n", dwRead, hdr_length);
- status = RPC_S_PROTOCOL_ERROR;
- goto fail;
- }
-
- if (common_hdr.frag_len - hdr_length)
- {
- *Payload = HeapAlloc(GetProcessHeap(), 0, common_hdr.frag_len - hdr_length);
- if (!*Payload)
- {
- status = RPC_S_OUT_OF_RESOURCES;
- goto fail;
- }
-
- dwRead = rpcrt4_ncacn_http_read(Connection, *Payload, common_hdr.frag_len - hdr_length);
- if (dwRead != common_hdr.frag_len - hdr_length)
- {
- WARN("bad data length, %d/%d\n", dwRead, common_hdr.frag_len - hdr_length);
- status = RPC_S_PROTOCOL_ERROR;
- goto fail;
- }
- }
- else
- *Payload = NULL;
-
- if ((*Header)->common.ptype == PKT_HTTP)
- {
- if (!RPCRT4_IsValidHttpPacket(*Header, *Payload, common_hdr.frag_len - hdr_length))
- {
- ERR("invalid http packet of length %d bytes\n", (*Header)->common.frag_len);
- status = RPC_S_PROTOCOL_ERROR;
- goto fail;
- }
- if ((*Header)->http.flags == 0x0001)
- {
- TRACE("http idle packet, waiting for real packet\n");
- if ((*Header)->http.num_data_items != 0)
- {
- ERR("HTTP idle packet should have no data items instead of %d\n", (*Header)->http.num_data_items);
- status = RPC_S_PROTOCOL_ERROR;
- goto fail;
- }
- }
- else if ((*Header)->http.flags == 0x0002)
- {
- ULONG bytes_transmitted;
- ULONG flow_control_increment;
- UUID pipe_uuid;
- status = RPCRT4_ParseHttpFlowControlHeader(*Header, *Payload,
- Connection->server,
- &bytes_transmitted,
- &flow_control_increment,
- &pipe_uuid);
- if (status != RPC_S_OK)
- goto fail;
- TRACE("received http flow control header (0x%x, 0x%x, %s)\n",
- bytes_transmitted, flow_control_increment, debugstr_guid(&pipe_uuid));
- /* FIXME: do something with parsed data */
- }
- else
- {
- FIXME("unrecognised http packet with flags 0x%04x\n", (*Header)->http.flags);
- status = RPC_S_PROTOCOL_ERROR;
- goto fail;
- }
- RPCRT4_FreeHeader(*Header);
- *Header = NULL;
- HeapFree(GetProcessHeap(), 0, *Payload);
- *Payload = NULL;
- goto again;
- }
-
- /* success */
- status = RPC_S_OK;
-
- httpc->bytes_received += common_hdr.frag_len;
-
- TRACE("httpc->bytes_received = 0x%x\n", httpc->bytes_received);
-
- if (httpc->bytes_received > httpc->flow_control_mark)
- {
- RpcPktHdr *hdr = RPCRT4_BuildHttpFlowControlHeader(httpc->common.server,
- httpc->bytes_received,
- httpc->flow_control_increment,
- &httpc->out_pipe_uuid);
- if (hdr)
- {
- DWORD bytes_written;
- BOOL ret2;
- TRACE("sending flow control packet at 0x%x\n", httpc->bytes_received);
- ret2 = InternetWriteFile(httpc->in_request, hdr, hdr->common.frag_len, &bytes_written);
- RPCRT4_FreeHeader(hdr);
- if (ret2)
- httpc->flow_control_mark = httpc->bytes_received + httpc->flow_control_increment / 2;
- }
- }
-
-fail:
- if (status != RPC_S_OK) {
- RPCRT4_FreeHeader(*Header);
- *Header = NULL;
- HeapFree(GetProcessHeap(), 0, *Payload);
- *Payload = NULL;
- }
- return status;
-}
-
-static int rpcrt4_ncacn_http_write(RpcConnection *Connection,
- const void *buffer, unsigned int count)
-{
- RpcConnection_http *httpc = (RpcConnection_http *) Connection;
- DWORD bytes_written;
- BOOL ret;
-
- httpc->last_sent_time = ~0U; /* disable idle packet sending */
- ret = InternetWriteFile(httpc->in_request, buffer, count, &bytes_written);
- httpc->last_sent_time = GetTickCount();
- TRACE("%p %p %u -> %s\n", httpc->in_request, buffer, count, ret ? "TRUE" : "FALSE");
- return ret ? bytes_written : -1;
-}
-
-static int rpcrt4_ncacn_http_close(RpcConnection *Connection)
-{
- RpcConnection_http *httpc = (RpcConnection_http *) Connection;
-
- TRACE("\n");
-
- SetEvent(httpc->timer_cancelled);
- if (httpc->in_request)
- InternetCloseHandle(httpc->in_request);
- httpc->in_request = NULL;
- if (httpc->out_request)
- InternetCloseHandle(httpc->out_request);
- httpc->out_request = NULL;
- if (httpc->app_info)
- InternetCloseHandle(httpc->app_info);
- httpc->app_info = NULL;
- if (httpc->session)
- InternetCloseHandle(httpc->session);
- httpc->session = NULL;
- RpcHttpAsyncData_Release(httpc->async_data);
- if (httpc->cancel_event)
- CloseHandle(httpc->cancel_event);
-
- return 0;
-}
-
-static void rpcrt4_ncacn_http_cancel_call(RpcConnection *Connection)
-{
- RpcConnection_http *httpc = (RpcConnection_http *) Connection;
-
- SetEvent(httpc->cancel_event);
-}
-
-static int rpcrt4_ncacn_http_wait_for_incoming_data(RpcConnection *Connection)
-{
- BOOL ret;
- RpcConnection_http *httpc = (RpcConnection_http *) Connection;
-
- RpcHttpAsyncData_AddRef(httpc->async_data);
- ret = InternetQueryDataAvailable(httpc->out_request,
- &httpc->async_data->inet_buffers.dwBufferLength, IRF_ASYNC, 0);
- if (ret)
- {
- /* INTERNET_STATUS_REQUEST_COMPLETED won't be sent, so release our
- * async ref now */
- RpcHttpAsyncData_Release(httpc->async_data);
- }
- else
- {
- if (GetLastError() == ERROR_IO_PENDING)
- {
- HANDLE handles[2] = { httpc->async_data->completion_event, httpc->cancel_event };
- DWORD result = WaitForMultipleObjects(2, handles, FALSE, DEFAULT_NCACN_HTTP_TIMEOUT);
- if (result != WAIT_OBJECT_0)
- {
- TRACE("call cancelled\n");
- return -1;
- }
- }
- else
- {
- RpcHttpAsyncData_Release(httpc->async_data);
- return -1;
- }
- }
-
- /* success */
- return 0;
-}
-
-static size_t rpcrt4_ncacn_http_get_top_of_tower(unsigned char *tower_data,
- const char *networkaddr,
- const char *endpoint)
-{
- return rpcrt4_ip_tcp_get_top_of_tower(tower_data, networkaddr,
- EPM_PROTOCOL_HTTP, endpoint);
-}
-
-static RPC_STATUS rpcrt4_ncacn_http_parse_top_of_tower(const unsigned char *tower_data,
- size_t tower_size,
- char **networkaddr,
- char **endpoint)
-{
- return rpcrt4_ip_tcp_parse_top_of_tower(tower_data, tower_size,
- networkaddr, EPM_PROTOCOL_HTTP,
- endpoint);
-}
-
-#endif /* end http support */
-
static const struct connection_ops conn_protseq_list[] = {
{ "ncacn_np",
{ EPM_PROTOCOL_NCACN, EPM_PROTOCOL_SMB },
rpcrt4_conn_np_wait_for_incoming_data,
rpcrt4_ncacn_np_get_top_of_tower,
rpcrt4_ncacn_np_parse_top_of_tower,
- NULL,
- RPCRT4_default_is_authorized,
- RPCRT4_default_authorize,
- RPCRT4_default_secure_packet,
- rpcrt4_conn_np_impersonate_client,
- rpcrt4_conn_np_revert_to_self,
- RPCRT4_default_inquire_auth_client,
},
{ "ncalrpc",
{ EPM_PROTOCOL_NCALRPC, EPM_PROTOCOL_PIPE },
rpcrt4_conn_np_wait_for_incoming_data,
rpcrt4_ncalrpc_get_top_of_tower,
rpcrt4_ncalrpc_parse_top_of_tower,
- NULL,
- rpcrt4_ncalrpc_is_authorized,
- rpcrt4_ncalrpc_authorize,
- rpcrt4_ncalrpc_secure_packet,
- rpcrt4_conn_np_impersonate_client,
- rpcrt4_conn_np_revert_to_self,
- rpcrt4_ncalrpc_inquire_auth_client,
},
{ "ncacn_ip_tcp",
{ EPM_PROTOCOL_NCACN, EPM_PROTOCOL_TCP },
rpcrt4_conn_tcp_wait_for_incoming_data,
rpcrt4_ncacn_ip_tcp_get_top_of_tower,
rpcrt4_ncacn_ip_tcp_parse_top_of_tower,
- NULL,
- RPCRT4_default_is_authorized,
- RPCRT4_default_authorize,
- RPCRT4_default_secure_packet,
- RPCRT4_default_impersonate_client,
- RPCRT4_default_revert_to_self,
- RPCRT4_default_inquire_auth_client,
- },
-#if 0
- { "ncacn_http",
- { EPM_PROTOCOL_NCACN, EPM_PROTOCOL_HTTP },
- rpcrt4_ncacn_http_alloc,
- rpcrt4_ncacn_http_open,
- rpcrt4_ncacn_http_handoff,
- rpcrt4_ncacn_http_read,
- rpcrt4_ncacn_http_write,
- rpcrt4_ncacn_http_close,
- rpcrt4_ncacn_http_cancel_call,
- rpcrt4_ncacn_http_wait_for_incoming_data,
- rpcrt4_ncacn_http_get_top_of_tower,
- rpcrt4_ncacn_http_parse_top_of_tower,
- rpcrt4_ncacn_http_receive_fragment,
- RPCRT4_default_is_authorized,
- RPCRT4_default_authorize,
- RPCRT4_default_secure_packet,
- RPCRT4_default_impersonate_client,
- RPCRT4_default_revert_to_self,
- RPCRT4_default_inquire_auth_client,
- },
-#endif
+ }
+
};
LPCSTR Protseq, LPCSTR NetworkAddr, LPCSTR Endpoint,
LPCWSTR NetworkOptions, RpcAuthInfo* AuthInfo, RpcQualityOfService *QOS)
{
- static LONG next_id;
const struct connection_ops *ops;
RpcConnection* NewConnection;
NewConnection->attr = 0;
if (AuthInfo) RpcAuthInfo_AddRef(AuthInfo);
NewConnection->AuthInfo = AuthInfo;
- NewConnection->auth_context_id = InterlockedIncrement( &next_id );
NewConnection->encryption_auth_len = 0;
NewConnection->signature_auth_len = 0;
if (QOS) RpcQualityOfService_AddRef(QOS);
@ stdcall CreateProxyFromTypeInfo(ptr ptr ptr ptr ptr)
-@ stdcall CreateStubFromTypeInfo(ptr ptr ptr ptr)
+@ stub CreateStubFromTypeInfo
@ stdcall CStdStubBuffer_AddRef(ptr)
@ stdcall CStdStubBuffer_Connect(ptr ptr)
@ stdcall CStdStubBuffer_CountRefs(ptr)
@ stdcall NDRSContextUnmarshallEx(ptr ptr ptr)
@ stub NDRcopy
@ stdcall NdrAllocate(ptr long)
-@ varargs NdrAsyncClientCall(ptr ptr)
+@ stub NdrAsyncClientCall
@ stub NdrAsyncServerCall
-@ stdcall NdrAsyncStubCall(ptr ptr ptr ptr)
@ stdcall NdrByteCountPointerBufferSize(ptr ptr ptr)
@ stdcall NdrByteCountPointerFree(ptr ptr ptr)
@ stdcall NdrByteCountPointerMarshall(ptr ptr ptr)
@ stdcall RpcBindingFree(ptr)
@ stdcall RpcBindingFromStringBindingA(str ptr)
@ stdcall RpcBindingFromStringBindingW(wstr ptr)
-@ stdcall RpcBindingInqAuthClientA(ptr ptr ptr ptr ptr ptr)
-@ stdcall RpcBindingInqAuthClientExA(ptr ptr ptr ptr ptr ptr long)
-@ stdcall RpcBindingInqAuthClientExW(ptr ptr ptr ptr ptr ptr long)
-@ stdcall RpcBindingInqAuthClientW(ptr ptr ptr ptr ptr ptr)
+@ stub RpcBindingInqAuthClientA
+@ stub RpcBindingInqAuthClientExA
+@ stub RpcBindingInqAuthClientExW
+@ stub RpcBindingInqAuthClientW
@ stdcall RpcBindingInqAuthInfoA(ptr ptr ptr ptr ptr ptr)
@ stdcall RpcBindingInqAuthInfoExA(ptr ptr ptr ptr ptr ptr long ptr)
@ stdcall RpcBindingInqAuthInfoExW(ptr ptr ptr ptr ptr ptr long ptr)
@ stdcall RpcEpRegisterA(ptr ptr ptr str)
@ stub RpcEpRegisterNoReplaceA
@ stub RpcEpRegisterNoReplaceW
-@ stdcall RpcEpRegisterW(ptr ptr ptr wstr)
+@ stub RpcEpRegisterW
@ stdcall RpcEpResolveBinding(ptr ptr)
@ stdcall RpcEpUnregister(ptr ptr ptr)
@ stub RpcErrorAddRecord # wxp
#include "winbase.h"
#include "winuser.h"
#include "winnt.h"
-#include "ntndk.h"
-#include "ntsecapi.h"
+#include "winternl.h"
#include "iptypes.h"
#include "iphlpapi.h"
#include "wine/unicode.h"
#include "rpcproxy.h"
#include "rpc_binding.h"
-#include "rpc_server.h"
#include "wine/debug.h"
break;
case DLL_PROCESS_DETACH:
- RPCRT4_destroy_all_protseqs();
- RPCRT4_ServerFreeAllRegisteredAuthInfo();
break;
}
return RPC_S_OK;
}
-/*************************************************************************
- * UuidCreate [RPCRT4.@]
- *
- * Creates a 128bit UUID.
- *
- * RETURNS
- *
- * RPC_S_OK if successful.
- * RPC_S_UUID_LOCAL_ONLY if UUID is only locally unique.
- *
- * NOTES
- *
- * Follows RFC 4122, section 4.4 (Algorithms for Creating a UUID from
- * Truly Random or Pseudo-Random Numbers)
- */
-RPC_STATUS WINAPI UuidCreate(UUID *Uuid)
-{
- RtlGenRandom(Uuid, sizeof(*Uuid));
- /* Clear the version bits and set the version (4) */
- Uuid->Data3 &= 0x0fff;
- Uuid->Data3 |= (4 << 12);
- /* Set the topmost bits of Data4 (clock_seq_hi_and_reserved) as
- * specified in RFC 4122, section 4.4.
- */
- Uuid->Data4[0] &= 0x3f;
- Uuid->Data4[0] |= 0x80;
-
- TRACE("%s\n", debugstr_guid(Uuid));
-
- return RPC_S_OK;
-}
-
/* Number of 100ns ticks per clock tick. To be safe, assume that the clock
resolution is at least 1000 * 100 * (1/1000000) = 1/10 of a second */
#define TICKS_PER_CLOCK_TICK 1000
*time += TICKS_15_OCT_1582_TO_1601;
}
-/* Assume that a hardware address is at least 6 bytes long */
+/* Assume that a hardware address is at least 6 bytes long */
#define ADDRESS_BYTES_NEEDED 6
static RPC_STATUS RPC_UuidGetNodeAddress(BYTE *address)
/* We can't get a hardware address, just use random numbers.
Set the multicast bit to prevent conflicts with real cards. */
else {
- RtlGenRandom(address, ADDRESS_BYTES_NEEDED);
+ for (i = 0; i < ADDRESS_BYTES_NEEDED; i++) {
+ address[i] = rand() & 0xff;
+ }
+
address[0] |= 0x01;
status = RPC_S_UUID_LOCAL_ONLY;
}
}
/*************************************************************************
- * UuidCreateSequential [RPCRT4.@]
+ * UuidCreate [RPCRT4.@]
*
* Creates a 128bit UUID.
*
* RPC_S_UUID_LOCAL_ONLY if UUID is only locally unique.
*
* FIXME: No compensation for changes across reloading
- * this dll or across reboots (e.g. clock going
+ * this dll or across reboots (e.g. clock going
* backwards and swapped network cards). The RFC
- * suggests using NVRAM for storing persistent
+ * suggests using NVRAM for storing persistent
* values.
*/
-RPC_STATUS WINAPI UuidCreateSequential(UUID *Uuid)
+RPC_STATUS WINAPI UuidCreate(UUID *Uuid)
{
static int initialised, count;
/* Pack the information into the UUID structure. */
- Uuid->Data1 = (ULONG)(time & 0xffffffff);
+ Uuid->Data1 = (unsigned long)(time & 0xffffffff);
Uuid->Data2 = (unsigned short)((time >> 32) & 0xffff);
Uuid->Data3 = (unsigned short)((time >> 48) & 0x0fff);
Uuid->Data4[0] = sequence & 0xff;
Uuid->Data4[1] = (sequence & 0x3f00) >> 8;
Uuid->Data4[1] |= 0x80;
- memcpy(&Uuid->Data4[2], address, ADDRESS_BYTES_NEEDED);
+
+ Uuid->Data4[2] = address[0];
+ Uuid->Data4[3] = address[1];
+ Uuid->Data4[4] = address[2];
+ Uuid->Data4[5] = address[3];
+ Uuid->Data4[6] = address[4];
+ Uuid->Data4[7] = address[5];
LeaveCriticalSection(&uuid_cs);
return status;
}
+/*************************************************************************
+ * UuidCreateSequential [RPCRT4.@]
+ *
+ * Creates a 128bit UUID.
+ *
+ * RETURNS
+ *
+ * RPC_S_OK if successful.
+ * RPC_S_UUID_LOCAL_ONLY if UUID is only locally unique.
+ *
+ */
+RPC_STATUS WINAPI UuidCreateSequential(UUID *Uuid)
+{
+ return UuidCreate(Uuid);
+}
+
/*************************************************************************
* UuidHash [RPCRT4.@]
projects / reactos.git / commitdiff