mirrors
/
FreeRDP
mirror of https://github.com/FreeRDP/FreeRDP
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fixed warnings and mac build.

This commit is contained in:
Armin Novak 2016-07-21 16:51:42 +02:00 committed by Armin Novak
parent aad0a5cd5d
commit 35f1347d53
8 changed files with 796 additions and 540 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

306
channels/rdpdr/client/rdpdr_main.c
View File

File diff suppressed because it is too large Load Diff

2
libfreerdp/codec/color.c
View File

@ -236,7 +236,7 @@ BOOL freerdp_image_copy_from_pointer_data(
for (x = 0; x < nWidth; x++)
{
UINT32 color;
UINT32 color = 0;
xorPixel = (*xorBits & xorBit) ? 1 : 0;
if (!(xorBit >>= 1))

6
libfreerdp/codec/planar.c
View File

@ -302,7 +302,7 @@ BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
UINT32 subWidth;
UINT32 subHeight;
UINT32 planeSize;
UINT32 rleSizes[4];
INT32 rleSizes[4];
UINT32 rawSizes[4];
UINT32 rawWidths[4];
UINT32 rawHeights[4];
@ -314,10 +314,6 @@ BOOL planar_decompress(BITMAP_PLANAR_CONTEXT* planar,
const UINT32 w = MIN(nSrcWidth, nDstWidth);
const UINT32 h = MIN(nSrcHeight, nDstHeight);
const primitives_t* prims = primitives_get();
if ((nSrcWidth < 0) || (nSrcHeight < 0))
return FALSE;
dstBitsPerPixel = GetBitsPerPixel(DstFormat);
dstBytesPerPixel = GetBytesPerPixel(DstFormat);

2
libfreerdp/codec/progressive.c
View File

@ -1556,7 +1556,7 @@ INT32 progressive_decompress(PROGRESSIVE_CONTEXT* progressive,
UINT32 nWidth, UINT32 nHeight, UINT16 surfaceId)
{
INT32 rc = 1;
UINT status;
INT32 status;
const BYTE* block;
const BYTE* blocks;
UINT16 i, j;

6
libfreerdp/gdi/gdi.c
View File

@ -373,7 +373,7 @@ BYTE* gdi_get_bitmap_pointer(HGDI_DC hdcBmp, UINT32 x, UINT32 y)
BYTE* p;
HGDI_BITMAP hBmp = (HGDI_BITMAP) hdcBmp->selectedObject;
if (x >= 0 && x < hBmp->width && y >= 0 && y < hBmp->height)
if (x < hBmp->width && y < hBmp->height)
{
p = hBmp->data + (y * hBmp->scanline) + (x * GetBytesPerPixel(hdcBmp->format));
return p;
@ -404,13 +404,10 @@ BYTE* gdi_get_brush_pointer(HGDI_DC hdcBrush, UINT32 x, UINT32 y)
|| (hdcBrush->brush->style == GDI_BS_HATCHED))
{
HGDI_BITMAP hBmpBrush = hdcBrush->brush->pattern;
/* According to @msdn{dd183396}, the system always positions a brush bitmap
* at the brush origin and copy across the client area.
* Calculate the offset of the mapped pixel in the brush bitmap according to
* brush origin and dest coordinates */
if (x >= 0 && y >= 0)
{
x = (x + hBmpBrush->width - (hdcBrush->brush->nXOrg % hBmpBrush->width)) %
hBmpBrush->width;
y = (y + hBmpBrush->height - (hdcBrush->brush->nYOrg % hBmpBrush->height)) %
@ -420,7 +417,6 @@ BYTE* gdi_get_brush_pointer(HGDI_DC hdcBrush, UINT32 x, UINT32 y)
return p;
}
}
}
p = (BYTE*) & (hdcBrush->textColor);
return p;

6
libfreerdp/gdi/region.c
View File

@ -459,12 +459,6 @@ INLINE BOOL gdi_InvalidateRegion(HGDI_DC hdc, UINT32 x, UINT32 y, UINT32 w,
gdi_CRgnToRect(x, y, w, h, &rgn);
gdi_RgnToRect(invalid, &inv);
if (rgn.left < 0)
rgn.left = 0;
if (rgn.top < 0)
rgn.top = 0;
if (rgn.left < inv.left)
inv.left = rgn.left;

326
winpr/include/winpr/rpc.h
View File

@ -176,8 +176,10 @@ typedef struct _RPC_POLICY
unsigned long NICFlags;
} RPC_POLICY, *PRPC_POLICY;
typedef void RPC_OBJECT_INQ_FN(UUID* ObjectUuid, UUID* TypeUuid, RPC_STATUS* pStatus);
typedef RPC_STATUS RPC_IF_CALLBACK_FN(RPC_IF_HANDLE InterfaceUuid, void* Context);
typedef void RPC_OBJECT_INQ_FN(UUID* ObjectUuid, UUID* TypeUuid,
RPC_STATUS* pStatus);
typedef RPC_STATUS RPC_IF_CALLBACK_FN(RPC_IF_HANDLE InterfaceUuid,
void* Context);
typedef void RPC_SECURITY_CALLBACK_FN(void* Context);
#define RPC_MGR_EPV void
@ -308,7 +310,8 @@ typedef struct _RPC_SECURITY_QOS_V2_W
unsigned long IdentityTracking;
unsigned long ImpersonationType;
unsigned long AdditionalSecurityInfoType;
union {
union
{
RPC_HTTP_TRANSPORT_CREDENTIALS_W* HttpCredentials;
} u;
} RPC_SECURITY_QOS_V2_W, *PRPC_SECURITY_QOS_V2_W;
@ -320,7 +323,8 @@ typedef struct _RPC_SECURITY_QOS_V2_A
unsigned long IdentityTracking;
unsigned long ImpersonationType;
unsigned long AdditionalSecurityInfoType;
union {
union
{
RPC_HTTP_TRANSPORT_CREDENTIALS_A* HttpCredentials;
} u;
} RPC_SECURITY_QOS_V2_A, *PRPC_SECURITY_QOS_V2_A;
@ -334,7 +338,8 @@ typedef struct _RPC_SECURITY_QOS_V3_W
unsigned long IdentityTracking;
unsigned long ImpersonationType;
unsigned long AdditionalSecurityInfoType;
union {
union
{
RPC_HTTP_TRANSPORT_CREDENTIALS_W* HttpCredentials;
} u;
void* Sid;
@ -347,7 +352,8 @@ typedef struct _RPC_SECURITY_QOS_V3_A
unsigned long IdentityTracking;
unsigned long ImpersonationType;
unsigned long AdditionalSecurityInfoType;
union {
union
{
RPC_HTTP_TRANSPORT_CREDENTIALS_A* HttpCredentials;
} u;
void* Sid;
@ -362,10 +368,13 @@ typedef enum _RPC_HTTP_REDIRECTOR_STAGE
RPCHTTP_RS_INTERFACE
} RPC_HTTP_REDIRECTOR_STAGE;
typedef RPC_STATUS (*RPC_NEW_HTTP_PROXY_CHANNEL)(RPC_HTTP_REDIRECTOR_STAGE RedirectorStage,
unsigned short* ServerName, unsigned short* ServerPort, unsigned short* RemoteUser,
typedef RPC_STATUS(*RPC_NEW_HTTP_PROXY_CHANNEL)(RPC_HTTP_REDIRECTOR_STAGE
RedirectorStage,
unsigned short* ServerName, unsigned short* ServerPort,
unsigned short* RemoteUser,
unsigned short* AuthType, void* ResourceUuid, void* Metadata, void* SessionId,
void* Interface, void* Reserved, unsigned long Flags, unsigned short** NewServerName,
void* Interface, void* Reserved, unsigned long Flags,
unsigned short** NewServerName,
unsigned short** NewServerPort);
typedef void (*RPC_HTTP_PROXY_FREE_STRING)(unsigned short* String);
@ -377,7 +386,9 @@ typedef void (*RPC_HTTP_PROXY_FREE_STRING)(unsigned short* String);
#endif
typedef void (*RPC_AUTH_KEY_RETRIEVAL_FN)(void* Arg, unsigned short* ServerPrincName, unsigned long KeyVer, void** Key, RPC_STATUS* pStatus);
typedef void (*RPC_AUTH_KEY_RETRIEVAL_FN)(void* Arg,
unsigned short* ServerPrincName, unsigned long KeyVer, void** Key,
RPC_STATUS* pStatus);
#define DCE_C_ERROR_STRING_LEN 256
@ -394,7 +405,8 @@ typedef I_RPC_HANDLE *RPC_EP_INQ_HANDLE;
#define RPC_C_VERS_MAJOR_ONLY 4
#define RPC_C_VERS_UPTO 5
typedef int (*RPC_MGMT_AUTHORIZATION_FN)(RPC_BINDING_HANDLE ClientBinding, unsigned long RequestedMgmtOperation, RPC_STATUS *pStatus);
typedef int (*RPC_MGMT_AUTHORIZATION_FN)(RPC_BINDING_HANDLE ClientBinding,
unsigned long RequestedMgmtOperation, RPC_STATUS* pStatus);
#define RPC_C_MGMT_INQ_IF_IDS 0
#define RPC_C_MGMT_INQ_PRINC_NAME 1
@ -438,7 +450,8 @@ typedef struct _RPC_BINDING_HANDLE_TEMPLATE
unsigned long ProtocolSequence;
unsigned short* NetworkAddress;
unsigned short* StringEndpoint;
union {
union
{
unsigned short* Reserved;
} u1;
UUID ObjectUuid;
@ -455,122 +468,205 @@ typedef struct _RPC_BINDING_HANDLE_TEMPLATE
extern "C" {
#endif
WINPR_API RPC_STATUS RpcBindingCopy(RPC_BINDING_HANDLE SourceBinding, RPC_BINDING_HANDLE* DestinationBinding);
WINPR_API RPC_STATUS RpcBindingCopy(RPC_BINDING_HANDLE SourceBinding,
RPC_BINDING_HANDLE* DestinationBinding);
WINPR_API RPC_STATUS RpcBindingFree(RPC_BINDING_HANDLE* Binding);
WINPR_API RPC_STATUS RpcBindingSetOption(RPC_BINDING_HANDLE hBinding, unsigned long option, ULONG_PTR optionValue);
WINPR_API RPC_STATUS RpcBindingInqOption(RPC_BINDING_HANDLE hBinding, unsigned long option, ULONG_PTR *pOptionValue);
WINPR_API RPC_STATUS RpcBindingFromStringBindingA(RPC_CSTR StringBinding, RPC_BINDING_HANDLE* Binding);
WINPR_API RPC_STATUS RpcBindingFromStringBindingW(RPC_WSTR StringBinding, RPC_BINDING_HANDLE* Binding);
WINPR_API RPC_STATUS RpcSsGetContextBinding(void* ContextHandle, RPC_BINDING_HANDLE* Binding);
WINPR_API RPC_STATUS RpcBindingInqObject(RPC_BINDING_HANDLE Binding, UUID* ObjectUuid);
WINPR_API RPC_STATUS RpcBindingSetOption(RPC_BINDING_HANDLE hBinding,
unsigned long option, ULONG_PTR optionValue);
WINPR_API RPC_STATUS RpcBindingInqOption(RPC_BINDING_HANDLE hBinding,
unsigned long option, ULONG_PTR* pOptionValue);
WINPR_API RPC_STATUS RpcBindingFromStringBindingA(RPC_CSTR StringBinding,
RPC_BINDING_HANDLE* Binding);
WINPR_API RPC_STATUS RpcBindingFromStringBindingW(RPC_WSTR StringBinding,
RPC_BINDING_HANDLE* Binding);
WINPR_API RPC_STATUS RpcSsGetContextBinding(void* ContextHandle,
RPC_BINDING_HANDLE* Binding);
WINPR_API RPC_STATUS RpcBindingInqObject(RPC_BINDING_HANDLE Binding,
UUID* ObjectUuid);
WINPR_API RPC_STATUS RpcBindingReset(RPC_BINDING_HANDLE Binding);
WINPR_API RPC_STATUS RpcBindingSetObject(RPC_BINDING_HANDLE Binding, UUID* ObjectUuid);
WINPR_API RPC_STATUS RpcMgmtInqDefaultProtectLevel(unsigned long AuthnSvc, unsigned long* AuthnLevel);
WINPR_API RPC_STATUS RpcBindingToStringBindingA(RPC_BINDING_HANDLE Binding, RPC_CSTR* StringBinding);
WINPR_API RPC_STATUS RpcBindingToStringBindingW(RPC_BINDING_HANDLE Binding, RPC_WSTR* StringBinding);
WINPR_API RPC_STATUS RpcBindingSetObject(RPC_BINDING_HANDLE Binding,
UUID* ObjectUuid);
WINPR_API RPC_STATUS RpcMgmtInqDefaultProtectLevel(unsigned long AuthnSvc,
unsigned long* AuthnLevel);
WINPR_API RPC_STATUS RpcBindingToStringBindingA(RPC_BINDING_HANDLE Binding,
RPC_CSTR* StringBinding);
WINPR_API RPC_STATUS RpcBindingToStringBindingW(RPC_BINDING_HANDLE Binding,
RPC_WSTR* StringBinding);
WINPR_API RPC_STATUS RpcBindingVectorFree(RPC_BINDING_VECTOR** BindingVector);
WINPR_API RPC_STATUS RpcStringBindingComposeA(RPC_CSTR ObjUuid, RPC_CSTR Protseq, RPC_CSTR NetworkAddr,
WINPR_API RPC_STATUS RpcStringBindingComposeA(RPC_CSTR ObjUuid,
RPC_CSTR Protseq, RPC_CSTR NetworkAddr,
RPC_CSTR Endpoint, RPC_CSTR Options, RPC_CSTR* StringBinding);
WINPR_API RPC_STATUS RpcStringBindingComposeW(RPC_WSTR ObjUuid, RPC_WSTR Protseq, RPC_WSTR NetworkAddr,
WINPR_API RPC_STATUS RpcStringBindingComposeW(RPC_WSTR ObjUuid,
RPC_WSTR Protseq, RPC_WSTR NetworkAddr,
RPC_WSTR Endpoint, RPC_WSTR Options, RPC_WSTR* StringBinding);
WINPR_API RPC_STATUS RpcStringBindingParseA(RPC_CSTR StringBinding, RPC_CSTR* ObjUuid, RPC_CSTR* Protseq,
WINPR_API RPC_STATUS RpcStringBindingParseA(RPC_CSTR StringBinding,
RPC_CSTR* ObjUuid, RPC_CSTR* Protseq,
RPC_CSTR* NetworkAddr, RPC_CSTR* Endpoint, RPC_CSTR* NetworkOptions);
WINPR_API RPC_STATUS RpcStringBindingParseW(RPC_WSTR StringBinding, RPC_WSTR* ObjUuid, RPC_WSTR* Protseq,
WINPR_API RPC_STATUS RpcStringBindingParseW(RPC_WSTR StringBinding,
RPC_WSTR* ObjUuid, RPC_WSTR* Protseq,
RPC_WSTR* NetworkAddr, RPC_WSTR* Endpoint, RPC_WSTR* NetworkOptions);
WINPR_API RPC_STATUS RpcStringFreeA(RPC_CSTR* String);
WINPR_API RPC_STATUS RpcStringFreeW(RPC_WSTR* String);
WINPR_API RPC_STATUS RpcIfInqId(RPC_IF_HANDLE RpcIfHandle, RPC_IF_ID* RpcIfId);
WINPR_API RPC_STATUS RpcNetworkIsProtseqValidA(RPC_CSTR Protseq);
WINPR_API RPC_STATUS RpcNetworkIsProtseqValidW(RPC_WSTR Protseq);
WINPR_API RPC_STATUS RpcMgmtInqComTimeout(RPC_BINDING_HANDLE Binding, unsigned int* Timeout);
WINPR_API RPC_STATUS RpcMgmtSetComTimeout(RPC_BINDING_HANDLE Binding, unsigned int Timeout);
WINPR_API RPC_STATUS RpcMgmtInqComTimeout(RPC_BINDING_HANDLE Binding,
unsigned int* Timeout);
WINPR_API RPC_STATUS RpcMgmtSetComTimeout(RPC_BINDING_HANDLE Binding,
unsigned int Timeout);
WINPR_API RPC_STATUS RpcMgmtSetCancelTimeout(long Timeout);
WINPR_API RPC_STATUS RpcNetworkInqProtseqsA(RPC_PROTSEQ_VECTORA** ProtseqVector);
WINPR_API RPC_STATUS RpcNetworkInqProtseqsW(RPC_PROTSEQ_VECTORW** ProtseqVector);
WINPR_API RPC_STATUS RpcNetworkInqProtseqsA(RPC_PROTSEQ_VECTORA**
ProtseqVector);
WINPR_API RPC_STATUS RpcNetworkInqProtseqsW(RPC_PROTSEQ_VECTORW**
ProtseqVector);
WINPR_API RPC_STATUS RpcObjectInqType(UUID* ObjUuid, UUID* TypeUuid);
WINPR_API RPC_STATUS RpcObjectSetInqFn(RPC_OBJECT_INQ_FN* InquiryFn);
WINPR_API RPC_STATUS RpcObjectSetType(UUID* ObjUuid, UUID* TypeUuid);
WINPR_API RPC_STATUS RpcProtseqVectorFreeA(RPC_PROTSEQ_VECTORA** ProtseqVector);
WINPR_API RPC_STATUS RpcProtseqVectorFreeW(RPC_PROTSEQ_VECTORW** ProtseqVector);
WINPR_API RPC_STATUS RpcServerInqBindings(RPC_BINDING_VECTOR** BindingVector);
WINPR_API RPC_STATUS RpcServerInqIf(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV** MgrEpv);
WINPR_API RPC_STATUS RpcServerListen(unsigned int MinimumCallThreads, unsigned int MaxCalls, unsigned int DontWait);
WINPR_API RPC_STATUS RpcServerRegisterIf(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv);
WINPR_API RPC_STATUS RpcServerRegisterIfEx(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv,
WINPR_API RPC_STATUS RpcServerInqIf(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid,
RPC_MGR_EPV** MgrEpv);
WINPR_API RPC_STATUS RpcServerListen(unsigned int MinimumCallThreads,
unsigned int MaxCalls, unsigned int DontWait);
WINPR_API RPC_STATUS RpcServerRegisterIf(RPC_IF_HANDLE IfSpec,
UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv);
WINPR_API RPC_STATUS RpcServerRegisterIfEx(RPC_IF_HANDLE IfSpec,
UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv,
unsigned int Flags, unsigned int MaxCalls, RPC_IF_CALLBACK_FN* IfCallback);
WINPR_API RPC_STATUS RpcServerRegisterIf2(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv,
unsigned int Flags, unsigned int MaxCalls, unsigned int MaxRpcSize, RPC_IF_CALLBACK_FN* IfCallbackFn);
WINPR_API RPC_STATUS RpcServerUnregisterIf(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, unsigned int WaitForCallsToComplete);
WINPR_API RPC_STATUS RpcServerUnregisterIfEx(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, int RundownContextHandles);
WINPR_API RPC_STATUS RpcServerUseAllProtseqs(unsigned int MaxCalls, void* SecurityDescriptor);
WINPR_API RPC_STATUS RpcServerUseAllProtseqsEx(unsigned int MaxCalls, void* SecurityDescriptor, PRPC_POLICY Policy);
WINPR_API RPC_STATUS RpcServerUseAllProtseqsIf(unsigned int MaxCalls, RPC_IF_HANDLE IfSpec, void* SecurityDescriptor);
WINPR_API RPC_STATUS RpcServerUseAllProtseqsIfEx(unsigned int MaxCalls, RPC_IF_HANDLE IfSpec, void* SecurityDescriptor, PRPC_POLICY Policy);
WINPR_API RPC_STATUS RpcServerUseProtseqA(RPC_CSTR Protseq, unsigned int MaxCalls, void* SecurityDescriptor);
WINPR_API RPC_STATUS RpcServerUseProtseqExA(RPC_CSTR Protseq, unsigned int MaxCalls, void* SecurityDescriptor, PRPC_POLICY Policy);
WINPR_API RPC_STATUS RpcServerUseProtseqW(RPC_WSTR Protseq, unsigned int MaxCalls, void* SecurityDescriptor);
WINPR_API RPC_STATUS RpcServerUseProtseqExW(RPC_WSTR Protseq, unsigned int MaxCalls, void* SecurityDescriptor, PRPC_POLICY Policy);
WINPR_API RPC_STATUS RpcServerUseProtseqEpA(RPC_CSTR Protseq, unsigned int MaxCalls, RPC_CSTR Endpoint, void* SecurityDescriptor);
WINPR_API RPC_STATUS RpcServerUseProtseqEpExA(RPC_CSTR Protseq, unsigned int MaxCalls, RPC_CSTR Endpoint, void* SecurityDescriptor, PRPC_POLICY Policy);
WINPR_API RPC_STATUS RpcServerUseProtseqEpW(RPC_WSTR Protseq, unsigned int MaxCalls, RPC_WSTR Endpoint, void* SecurityDescriptor);
WINPR_API RPC_STATUS RpcServerUseProtseqEpExW(RPC_WSTR Protseq, unsigned int MaxCalls, RPC_WSTR Endpoint, void* SecurityDescriptor, PRPC_POLICY Policy);
WINPR_API RPC_STATUS RpcServerUseProtseqIfA(RPC_CSTR Protseq, unsigned int MaxCalls, RPC_IF_HANDLE IfSpec, void* SecurityDescriptor);
WINPR_API RPC_STATUS RpcServerUseProtseqIfExA(RPC_CSTR Protseq, unsigned int MaxCalls, RPC_IF_HANDLE IfSpec, void* SecurityDescriptor, PRPC_POLICY Policy);
WINPR_API RPC_STATUS RpcServerUseProtseqIfW(RPC_WSTR Protseq, unsigned int MaxCalls, RPC_IF_HANDLE IfSpec, void* SecurityDescriptor);
WINPR_API RPC_STATUS RpcServerUseProtseqIfExW(RPC_WSTR Protseq, unsigned int MaxCalls, RPC_IF_HANDLE IfSpec, void* SecurityDescriptor, PRPC_POLICY Policy);
WINPR_API RPC_STATUS RpcServerRegisterIf2(RPC_IF_HANDLE IfSpec,
UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv,
unsigned int Flags, unsigned int MaxCalls, unsigned int MaxRpcSize,
RPC_IF_CALLBACK_FN* IfCallbackFn);
WINPR_API RPC_STATUS RpcServerUnregisterIf(RPC_IF_HANDLE IfSpec,
UUID* MgrTypeUuid, unsigned int WaitForCallsToComplete);
WINPR_API RPC_STATUS RpcServerUnregisterIfEx(RPC_IF_HANDLE IfSpec,
UUID* MgrTypeUuid, int RundownContextHandles);
WINPR_API RPC_STATUS RpcServerUseAllProtseqs(unsigned int MaxCalls,
void* SecurityDescriptor);
WINPR_API RPC_STATUS RpcServerUseAllProtseqsEx(unsigned int MaxCalls,
void* SecurityDescriptor, PRPC_POLICY Policy);
WINPR_API RPC_STATUS RpcServerUseAllProtseqsIf(unsigned int MaxCalls,
RPC_IF_HANDLE IfSpec, void* SecurityDescriptor);
WINPR_API RPC_STATUS RpcServerUseAllProtseqsIfEx(unsigned int MaxCalls,
RPC_IF_HANDLE IfSpec, void* SecurityDescriptor, PRPC_POLICY Policy);
WINPR_API RPC_STATUS RpcServerUseProtseqA(RPC_CSTR Protseq,
unsigned int MaxCalls, void* SecurityDescriptor);
WINPR_API RPC_STATUS RpcServerUseProtseqExA(RPC_CSTR Protseq,
unsigned int MaxCalls, void* SecurityDescriptor, PRPC_POLICY Policy);
WINPR_API RPC_STATUS RpcServerUseProtseqW(RPC_WSTR Protseq,
unsigned int MaxCalls, void* SecurityDescriptor);
WINPR_API RPC_STATUS RpcServerUseProtseqExW(RPC_WSTR Protseq,
unsigned int MaxCalls, void* SecurityDescriptor, PRPC_POLICY Policy);
WINPR_API RPC_STATUS RpcServerUseProtseqEpA(RPC_CSTR Protseq,
unsigned int MaxCalls, RPC_CSTR Endpoint, void* SecurityDescriptor);
WINPR_API RPC_STATUS RpcServerUseProtseqEpExA(RPC_CSTR Protseq,
unsigned int MaxCalls, RPC_CSTR Endpoint, void* SecurityDescriptor,
PRPC_POLICY Policy);
WINPR_API RPC_STATUS RpcServerUseProtseqEpW(RPC_WSTR Protseq,
unsigned int MaxCalls, RPC_WSTR Endpoint, void* SecurityDescriptor);
WINPR_API RPC_STATUS RpcServerUseProtseqEpExW(RPC_WSTR Protseq,
unsigned int MaxCalls, RPC_WSTR Endpoint, void* SecurityDescriptor,
PRPC_POLICY Policy);
WINPR_API RPC_STATUS RpcServerUseProtseqIfA(RPC_CSTR Protseq,
unsigned int MaxCalls, RPC_IF_HANDLE IfSpec, void* SecurityDescriptor);
WINPR_API RPC_STATUS RpcServerUseProtseqIfExA(RPC_CSTR Protseq,
unsigned int MaxCalls, RPC_IF_HANDLE IfSpec, void* SecurityDescriptor,
PRPC_POLICY Policy);
WINPR_API RPC_STATUS RpcServerUseProtseqIfW(RPC_WSTR Protseq,
unsigned int MaxCalls, RPC_IF_HANDLE IfSpec, void* SecurityDescriptor);
WINPR_API RPC_STATUS RpcServerUseProtseqIfExW(RPC_WSTR Protseq,
unsigned int MaxCalls, RPC_IF_HANDLE IfSpec, void* SecurityDescriptor,
PRPC_POLICY Policy);
WINPR_API void RpcServerYield(void);
WINPR_API RPC_STATUS RpcMgmtStatsVectorFree(RPC_STATS_VECTOR** StatsVector);
WINPR_API RPC_STATUS RpcMgmtInqStats(RPC_BINDING_HANDLE Binding, RPC_STATS_VECTOR** Statistics);
WINPR_API RPC_STATUS RpcMgmtInqStats(RPC_BINDING_HANDLE Binding,
RPC_STATS_VECTOR** Statistics);
WINPR_API RPC_STATUS RpcMgmtIsServerListening(RPC_BINDING_HANDLE Binding);
WINPR_API RPC_STATUS RpcMgmtStopServerListening(RPC_BINDING_HANDLE Binding);
WINPR_API RPC_STATUS RpcMgmtWaitServerListen(void);
WINPR_API RPC_STATUS RpcMgmtSetServerStackSize(unsigned long ThreadStackSize);
WINPR_API void RpcSsDontSerializeContext(void);
WINPR_API RPC_STATUS RpcMgmtEnableIdleCleanup(void);
WINPR_API RPC_STATUS RpcMgmtInqIfIds(RPC_BINDING_HANDLE Binding, RPC_IF_ID_VECTOR** IfIdVector);
WINPR_API RPC_STATUS RpcMgmtInqIfIds(RPC_BINDING_HANDLE Binding,
RPC_IF_ID_VECTOR** IfIdVector);
WINPR_API RPC_STATUS RpcIfIdVectorFree(RPC_IF_ID_VECTOR** IfIdVector);
WINPR_API RPC_STATUS RpcMgmtInqServerPrincNameA(RPC_BINDING_HANDLE Binding, unsigned long AuthnSvc, RPC_CSTR* ServerPrincName);
WINPR_API RPC_STATUS RpcMgmtInqServerPrincNameW(RPC_BINDING_HANDLE Binding, unsigned long AuthnSvc, RPC_WSTR* ServerPrincName);
WINPR_API RPC_STATUS RpcServerInqDefaultPrincNameA(unsigned long AuthnSvc, RPC_CSTR* PrincName);
WINPR_API RPC_STATUS RpcServerInqDefaultPrincNameW(unsigned long AuthnSvc, RPC_WSTR* PrincName);
WINPR_API RPC_STATUS RpcEpResolveBinding(RPC_BINDING_HANDLE Binding, RPC_IF_HANDLE IfSpec);
WINPR_API RPC_STATUS RpcNsBindingInqEntryNameA(RPC_BINDING_HANDLE Binding, unsigned long EntryNameSyntax, RPC_CSTR* EntryName);
WINPR_API RPC_STATUS RpcNsBindingInqEntryNameW(RPC_BINDING_HANDLE Binding, unsigned long EntryNameSyntax, RPC_WSTR* EntryName);
WINPR_API RPC_STATUS RpcMgmtInqServerPrincNameA(RPC_BINDING_HANDLE Binding,
unsigned long AuthnSvc, RPC_CSTR* ServerPrincName);
WINPR_API RPC_STATUS RpcMgmtInqServerPrincNameW(RPC_BINDING_HANDLE Binding,
unsigned long AuthnSvc, RPC_WSTR* ServerPrincName);
WINPR_API RPC_STATUS RpcServerInqDefaultPrincNameA(unsigned long AuthnSvc,
RPC_CSTR* PrincName);
WINPR_API RPC_STATUS RpcServerInqDefaultPrincNameW(unsigned long AuthnSvc,
RPC_WSTR* PrincName);
WINPR_API RPC_STATUS RpcEpResolveBinding(RPC_BINDING_HANDLE Binding,
RPC_IF_HANDLE IfSpec);
WINPR_API RPC_STATUS RpcNsBindingInqEntryNameA(RPC_BINDING_HANDLE Binding,
unsigned long EntryNameSyntax, RPC_CSTR* EntryName);
WINPR_API RPC_STATUS RpcNsBindingInqEntryNameW(RPC_BINDING_HANDLE Binding,
unsigned long EntryNameSyntax, RPC_WSTR* EntryName);
WINPR_API RPC_STATUS RpcImpersonateClient(RPC_BINDING_HANDLE BindingHandle);
WINPR_API RPC_STATUS RpcRevertToSelfEx(RPC_BINDING_HANDLE BindingHandle);
WINPR_API RPC_STATUS RpcRevertToSelf(void);
WINPR_API RPC_STATUS RpcBindingInqAuthClientA(RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE* Privs,
RPC_CSTR* ServerPrincName, unsigned long* AuthnLevel, unsigned long* AuthnSvc, unsigned long* AuthzSvc);
WINPR_API RPC_STATUS RpcBindingInqAuthClientW(RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE* Privs,
RPC_WSTR* ServerPrincName, unsigned long* AuthnLevel, unsigned long* AuthnSvc, unsigned long* AuthzSvc);
WINPR_API RPC_STATUS RpcBindingInqAuthClientExA(RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE* Privs,
RPC_CSTR* ServerPrincName, unsigned long* AuthnLevel, unsigned long* AuthnSvc, unsigned long* AuthzSvc, unsigned long Flags);
WINPR_API RPC_STATUS RpcBindingInqAuthClientExW(RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE* Privs,
RPC_WSTR* ServerPrincName, unsigned long* AuthnLevel, unsigned long* AuthnSvc, unsigned long* AuthzSvc, unsigned long Flags);
WINPR_API RPC_STATUS RpcBindingInqAuthInfoA(RPC_BINDING_HANDLE Binding, RPC_CSTR* ServerPrincName, unsigned long* AuthnLevel,
unsigned long* AuthnSvc, RPC_AUTH_IDENTITY_HANDLE* AuthIdentity, unsigned long* AuthzSvc);
WINPR_API RPC_STATUS RpcBindingInqAuthInfoW(RPC_BINDING_HANDLE Binding, RPC_WSTR* ServerPrincName, unsigned long* AuthnLevel,
unsigned long* AuthnSvc, RPC_AUTH_IDENTITY_HANDLE* AuthIdentity, unsigned long* AuthzSvc);
WINPR_API RPC_STATUS RpcBindingSetAuthInfoA(RPC_BINDING_HANDLE Binding, RPC_CSTR ServerPrincName, unsigned long AuthnLevel,
unsigned long AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, unsigned long AuthzSvc);
WINPR_API RPC_STATUS RpcBindingSetAuthInfoExA(RPC_BINDING_HANDLE Binding, RPC_CSTR ServerPrincName, unsigned long AuthnLevel,
unsigned long AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, unsigned long AuthzSvc, RPC_SECURITY_QOS* SecurityQos);
WINPR_API RPC_STATUS RpcBindingSetAuthInfoW(RPC_BINDING_HANDLE Binding, RPC_WSTR ServerPrincName, unsigned long AuthnLevel,
unsigned long AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, unsigned long AuthzSvc);
WINPR_API RPC_STATUS RpcBindingSetAuthInfoExW(RPC_BINDING_HANDLE Binding, RPC_WSTR ServerPrincName, unsigned long AuthnLevel,
unsigned long AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, unsigned long AuthzSvc, RPC_SECURITY_QOS* SecurityQOS);
WINPR_API RPC_STATUS RpcBindingInqAuthInfoExA(RPC_BINDING_HANDLE Binding, RPC_CSTR* ServerPrincName, unsigned long* AuthnLevel,
unsigned long* AuthnSvc, RPC_AUTH_IDENTITY_HANDLE* AuthIdentity, unsigned long* AuthzSvc,
WINPR_API RPC_STATUS RpcBindingInqAuthClientA(RPC_BINDING_HANDLE ClientBinding,
RPC_AUTHZ_HANDLE* Privs,
RPC_CSTR* ServerPrincName, unsigned long* AuthnLevel, unsigned long* AuthnSvc,
unsigned long* AuthzSvc);
WINPR_API RPC_STATUS RpcBindingInqAuthClientW(RPC_BINDING_HANDLE ClientBinding,
RPC_AUTHZ_HANDLE* Privs,
RPC_WSTR* ServerPrincName, unsigned long* AuthnLevel, unsigned long* AuthnSvc,
unsigned long* AuthzSvc);
WINPR_API RPC_STATUS RpcBindingInqAuthClientExA(RPC_BINDING_HANDLE
ClientBinding, RPC_AUTHZ_HANDLE* Privs,
RPC_CSTR* ServerPrincName, unsigned long* AuthnLevel, unsigned long* AuthnSvc,
unsigned long* AuthzSvc, unsigned long Flags);
WINPR_API RPC_STATUS RpcBindingInqAuthClientExW(RPC_BINDING_HANDLE
ClientBinding, RPC_AUTHZ_HANDLE* Privs,
RPC_WSTR* ServerPrincName, unsigned long* AuthnLevel, unsigned long* AuthnSvc,
unsigned long* AuthzSvc, unsigned long Flags);
WINPR_API RPC_STATUS RpcBindingInqAuthInfoA(RPC_BINDING_HANDLE Binding,
RPC_CSTR* ServerPrincName, unsigned long* AuthnLevel,
unsigned long* AuthnSvc, RPC_AUTH_IDENTITY_HANDLE* AuthIdentity,
unsigned long* AuthzSvc);
WINPR_API RPC_STATUS RpcBindingInqAuthInfoW(RPC_BINDING_HANDLE Binding,
RPC_WSTR* ServerPrincName, unsigned long* AuthnLevel,
unsigned long* AuthnSvc, RPC_AUTH_IDENTITY_HANDLE* AuthIdentity,
unsigned long* AuthzSvc);
WINPR_API RPC_STATUS RpcBindingSetAuthInfoA(RPC_BINDING_HANDLE Binding,
RPC_CSTR ServerPrincName, unsigned long AuthnLevel,
unsigned long AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity,
unsigned long AuthzSvc);
WINPR_API RPC_STATUS RpcBindingSetAuthInfoExA(RPC_BINDING_HANDLE Binding,
RPC_CSTR ServerPrincName, unsigned long AuthnLevel,
unsigned long AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity,
unsigned long AuthzSvc, RPC_SECURITY_QOS* SecurityQos);
WINPR_API RPC_STATUS RpcBindingSetAuthInfoW(RPC_BINDING_HANDLE Binding,
RPC_WSTR ServerPrincName, unsigned long AuthnLevel,
unsigned long AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity,
unsigned long AuthzSvc);
WINPR_API RPC_STATUS RpcBindingSetAuthInfoExW(RPC_BINDING_HANDLE Binding,
RPC_WSTR ServerPrincName, unsigned long AuthnLevel,
unsigned long AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity,
unsigned long AuthzSvc, RPC_SECURITY_QOS* SecurityQOS);
WINPR_API RPC_STATUS RpcBindingInqAuthInfoExA(RPC_BINDING_HANDLE Binding,
RPC_CSTR* ServerPrincName, unsigned long* AuthnLevel,
unsigned long* AuthnSvc, RPC_AUTH_IDENTITY_HANDLE* AuthIdentity,
unsigned long* AuthzSvc,
unsigned long RpcQosVersion, RPC_SECURITY_QOS* SecurityQOS);
WINPR_API RPC_STATUS RpcBindingInqAuthInfoExW(RPC_BINDING_HANDLE Binding, RPC_WSTR* ServerPrincName, unsigned long* AuthnLevel,
unsigned long* AuthnSvc, RPC_AUTH_IDENTITY_HANDLE* AuthIdentity, unsigned long* AuthzSvc,
WINPR_API RPC_STATUS RpcBindingInqAuthInfoExW(RPC_BINDING_HANDLE Binding,
RPC_WSTR* ServerPrincName, unsigned long* AuthnLevel,
unsigned long* AuthnSvc, RPC_AUTH_IDENTITY_HANDLE* AuthIdentity,
unsigned long* AuthzSvc,
unsigned long RpcQosVersion, RPC_SECURITY_QOS* SecurityQOS);
WINPR_API RPC_STATUS RpcServerRegisterAuthInfoA(RPC_CSTR ServerPrincName, unsigned long AuthnSvc, RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn, void* Arg);
WINPR_API RPC_STATUS RpcServerRegisterAuthInfoW(RPC_WSTR ServerPrincName, unsigned long AuthnSvc, RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn, void* Arg);
WINPR_API RPC_STATUS RpcServerRegisterAuthInfoA(RPC_CSTR ServerPrincName,
unsigned long AuthnSvc, RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn, void* Arg);
WINPR_API RPC_STATUS RpcServerRegisterAuthInfoW(RPC_WSTR ServerPrincName,
unsigned long AuthnSvc, RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn, void* Arg);
WINPR_API RPC_STATUS RpcBindingServerFromClient(RPC_BINDING_HANDLE ClientBinding, RPC_BINDING_HANDLE* ServerBinding);
WINPR_API RPC_STATUS RpcBindingServerFromClient(RPC_BINDING_HANDLE
ClientBinding, RPC_BINDING_HANDLE* ServerBinding);
WINPR_API DECLSPEC_NORETURN void RpcRaiseException(RPC_STATUS exception);
WINPR_API RPC_STATUS RpcTestCancel(void);
WINPR_API RPC_STATUS RpcServerTestCancel(RPC_BINDING_HANDLE BindingHandle);
@ -579,35 +675,51 @@ WINPR_API RPC_STATUS RpcCancelThreadEx(void* Thread, long Timeout);
WINPR_API RPC_STATUS UuidCreate(UUID* Uuid);
WINPR_API RPC_STATUS UuidCreateSequential(UUID* Uuid);
WINPR_API RPC_STATUS UuidToStringA(UUID* Uuid, RPC_CSTR* StringUuid);
WINPR_API RPC_STATUS UuidToStringA(const UUID* Uuid, RPC_CSTR* StringUuid);
WINPR_API RPC_STATUS UuidFromStringA(RPC_CSTR StringUuid, UUID* Uuid);
WINPR_API RPC_STATUS UuidToStringW(UUID* Uuid, RPC_WSTR* StringUuid);
WINPR_API RPC_STATUS UuidToStringW(const UUID* Uuid, RPC_WSTR* StringUuid);
WINPR_API RPC_STATUS UuidFromStringW(RPC_WSTR StringUuid, UUID* Uuid);
WINPR_API signed int UuidCompare(UUID* Uuid1, UUID* Uuid2, RPC_STATUS* Status);
WINPR_API signed int UuidCompare(const UUID* Uuid1, const UUID* Uuid2,
RPC_STATUS* Status);
WINPR_API RPC_STATUS UuidCreateNil(UUID* NilUuid);
WINPR_API int UuidEqual(UUID* Uuid1, UUID* Uuid2, RPC_STATUS* Status);
WINPR_API unsigned short UuidHash(UUID* Uuid, RPC_STATUS* Status);
WINPR_API int UuidIsNil(UUID* Uuid, RPC_STATUS* Status);
WINPR_API int UuidEqual(const UUID* Uuid1, const UUID* Uuid2,
RPC_STATUS* Status);
WINPR_API unsigned short UuidHash(const UUID* Uuid, RPC_STATUS* Status);
WINPR_API int UuidIsNil(const UUID* Uuid, RPC_STATUS* Status);
WINPR_API RPC_STATUS RpcEpRegisterNoReplaceA(RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR* BindingVector, UUID_VECTOR* UuidVector, RPC_CSTR Annotation);
WINPR_API RPC_STATUS RpcEpRegisterNoReplaceW(RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR* BindingVector, UUID_VECTOR* UuidVector, RPC_WSTR Annotation);
WINPR_API RPC_STATUS RpcEpRegisterA(RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR* BindingVector, UUID_VECTOR* UuidVector, RPC_CSTR Annotation);
WINPR_API RPC_STATUS RpcEpRegisterW(RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR* BindingVector, UUID_VECTOR* UuidVector, RPC_WSTR Annotation);
WINPR_API RPC_STATUS RpcEpUnregister(RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR* BindingVector, UUID_VECTOR* UuidVector);
WINPR_API RPC_STATUS RpcEpRegisterNoReplaceA(RPC_IF_HANDLE IfSpec,
RPC_BINDING_VECTOR* BindingVector, UUID_VECTOR* UuidVector,
RPC_CSTR Annotation);
WINPR_API RPC_STATUS RpcEpRegisterNoReplaceW(RPC_IF_HANDLE IfSpec,
RPC_BINDING_VECTOR* BindingVector, UUID_VECTOR* UuidVector,
RPC_WSTR Annotation);
WINPR_API RPC_STATUS RpcEpRegisterA(RPC_IF_HANDLE IfSpec,
RPC_BINDING_VECTOR* BindingVector, UUID_VECTOR* UuidVector,
RPC_CSTR Annotation);
WINPR_API RPC_STATUS RpcEpRegisterW(RPC_IF_HANDLE IfSpec,
RPC_BINDING_VECTOR* BindingVector, UUID_VECTOR* UuidVector,
RPC_WSTR Annotation);
WINPR_API RPC_STATUS RpcEpUnregister(RPC_IF_HANDLE IfSpec,
RPC_BINDING_VECTOR* BindingVector, UUID_VECTOR* UuidVector);
WINPR_API RPC_STATUS DceErrorInqTextA(RPC_STATUS RpcStatus, RPC_CSTR ErrorText);
WINPR_API RPC_STATUS DceErrorInqTextW(RPC_STATUS RpcStatus, RPC_WSTR ErrorText);
WINPR_API RPC_STATUS RpcMgmtEpEltInqBegin(RPC_BINDING_HANDLE EpBinding, unsigned long InquiryType, RPC_IF_ID* IfId,
WINPR_API RPC_STATUS RpcMgmtEpEltInqBegin(RPC_BINDING_HANDLE EpBinding,
unsigned long InquiryType, RPC_IF_ID* IfId,
unsigned long VersOption, UUID* ObjectUuid, RPC_EP_INQ_HANDLE* InquiryContext);
WINPR_API RPC_STATUS RpcMgmtEpEltInqDone(RPC_EP_INQ_HANDLE* InquiryContext);
WINPR_API RPC_STATUS RpcMgmtEpEltInqNextA(RPC_EP_INQ_HANDLE InquiryContext, RPC_IF_ID* IfId,
WINPR_API RPC_STATUS RpcMgmtEpEltInqNextA(RPC_EP_INQ_HANDLE InquiryContext,
RPC_IF_ID* IfId,
RPC_BINDING_HANDLE* Binding, UUID* ObjectUuid, RPC_CSTR* Annotation);
WINPR_API RPC_STATUS RpcMgmtEpEltInqNextW(RPC_EP_INQ_HANDLE InquiryContext, RPC_IF_ID* IfId,
WINPR_API RPC_STATUS RpcMgmtEpEltInqNextW(RPC_EP_INQ_HANDLE InquiryContext,
RPC_IF_ID* IfId,
RPC_BINDING_HANDLE* Binding, UUID* ObjectUuid, RPC_WSTR* Annotation);
WINPR_API RPC_STATUS RpcMgmtEpUnregister(RPC_BINDING_HANDLE EpBinding, RPC_IF_ID* IfId,
WINPR_API RPC_STATUS RpcMgmtEpUnregister(RPC_BINDING_HANDLE EpBinding,
RPC_IF_ID* IfId,
RPC_BINDING_HANDLE Binding, UUID* ObjectUuid);
WINPR_API RPC_STATUS RpcMgmtSetAuthorizationFn(RPC_MGMT_AUTHORIZATION_FN AuthorizationFn);
WINPR_API RPC_STATUS RpcMgmtSetAuthorizationFn(RPC_MGMT_AUTHORIZATION_FN
AuthorizationFn);
WINPR_API RPC_STATUS RpcServerInqBindingHandle(RPC_BINDING_HANDLE* Binding);

264
winpr/libwinpr/rpc/rpc.c
View File

@ -30,7 +30,8 @@
#include "../log.h"
#define TAG WINPR_TAG("rpc")
RPC_STATUS RpcBindingCopy(RPC_BINDING_HANDLE SourceBinding, RPC_BINDING_HANDLE* DestinationBinding)
RPC_STATUS RpcBindingCopy(RPC_BINDING_HANDLE SourceBinding,
RPC_BINDING_HANDLE* DestinationBinding)
{
WLog_ERR(TAG, "Not implemented");
return 0;
@ -42,31 +43,36 @@ RPC_STATUS RpcBindingFree(RPC_BINDING_HANDLE* Binding)
return 0;
}
RPC_STATUS RpcBindingSetOption(RPC_BINDING_HANDLE hBinding, unsigned long option, ULONG_PTR optionValue)
RPC_STATUS RpcBindingSetOption(RPC_BINDING_HANDLE hBinding,
unsigned long option, ULONG_PTR optionValue)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcBindingInqOption(RPC_BINDING_HANDLE hBinding, unsigned long option, ULONG_PTR* pOptionValue)
RPC_STATUS RpcBindingInqOption(RPC_BINDING_HANDLE hBinding,
unsigned long option, ULONG_PTR* pOptionValue)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcBindingFromStringBindingA(RPC_CSTR StringBinding, RPC_BINDING_HANDLE* Binding)
RPC_STATUS RpcBindingFromStringBindingA(RPC_CSTR StringBinding,
RPC_BINDING_HANDLE* Binding)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcBindingFromStringBindingW(RPC_WSTR StringBinding, RPC_BINDING_HANDLE* Binding)
RPC_STATUS RpcBindingFromStringBindingW(RPC_WSTR StringBinding,
RPC_BINDING_HANDLE* Binding)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcSsGetContextBinding(void* ContextHandle, RPC_BINDING_HANDLE* Binding)
RPC_STATUS RpcSsGetContextBinding(void* ContextHandle,
RPC_BINDING_HANDLE* Binding)
{
WLog_ERR(TAG, "Not implemented");
return 0;
@ -90,19 +96,22 @@ RPC_STATUS RpcBindingSetObject(RPC_BINDING_HANDLE Binding, UUID* ObjectUuid)
return 0;
}
RPC_STATUS RpcMgmtInqDefaultProtectLevel(unsigned long AuthnSvc, unsigned long* AuthnLevel)
RPC_STATUS RpcMgmtInqDefaultProtectLevel(unsigned long AuthnSvc,
unsigned long* AuthnLevel)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcBindingToStringBindingA(RPC_BINDING_HANDLE Binding, RPC_CSTR* StringBinding)
RPC_STATUS RpcBindingToStringBindingA(RPC_BINDING_HANDLE Binding,
RPC_CSTR* StringBinding)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcBindingToStringBindingW(RPC_BINDING_HANDLE Binding, RPC_WSTR* StringBinding)
RPC_STATUS RpcBindingToStringBindingW(RPC_BINDING_HANDLE Binding,
RPC_WSTR* StringBinding)
{
WLog_ERR(TAG, "Not implemented");
return 0;
@ -114,28 +123,32 @@ RPC_STATUS RpcBindingVectorFree(RPC_BINDING_VECTOR** BindingVector)
return 0;
}
RPC_STATUS RpcStringBindingComposeA(RPC_CSTR ObjUuid, RPC_CSTR Protseq, RPC_CSTR NetworkAddr,
RPC_STATUS RpcStringBindingComposeA(RPC_CSTR ObjUuid, RPC_CSTR Protseq,
RPC_CSTR NetworkAddr,
RPC_CSTR Endpoint, RPC_CSTR Options, RPC_CSTR* StringBinding)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcStringBindingComposeW(RPC_WSTR ObjUuid, RPC_WSTR Protseq, RPC_WSTR NetworkAddr,
RPC_STATUS RpcStringBindingComposeW(RPC_WSTR ObjUuid, RPC_WSTR Protseq,
RPC_WSTR NetworkAddr,
RPC_WSTR Endpoint, RPC_WSTR Options, RPC_WSTR* StringBinding)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcStringBindingParseA(RPC_CSTR StringBinding, RPC_CSTR* ObjUuid, RPC_CSTR* Protseq,
RPC_STATUS RpcStringBindingParseA(RPC_CSTR StringBinding, RPC_CSTR* ObjUuid,
RPC_CSTR* Protseq,
RPC_CSTR* NetworkAddr, RPC_CSTR* Endpoint, RPC_CSTR* NetworkOptions)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcStringBindingParseW(RPC_WSTR StringBinding, RPC_WSTR* ObjUuid, RPC_WSTR* Protseq,
RPC_STATUS RpcStringBindingParseW(RPC_WSTR StringBinding, RPC_WSTR* ObjUuid,
RPC_WSTR* Protseq,
RPC_WSTR* NetworkAddr, RPC_WSTR* Endpoint, RPC_WSTR* NetworkOptions)
{
WLog_ERR(TAG, "Not implemented");
@ -176,13 +189,15 @@ RPC_STATUS RpcNetworkIsProtseqValidW(RPC_WSTR Protseq)
return 0;
}
RPC_STATUS RpcMgmtInqComTimeout(RPC_BINDING_HANDLE Binding, unsigned int* Timeout)
RPC_STATUS RpcMgmtInqComTimeout(RPC_BINDING_HANDLE Binding,
unsigned int* Timeout)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcMgmtSetComTimeout(RPC_BINDING_HANDLE Binding, unsigned int Timeout)
RPC_STATUS RpcMgmtSetComTimeout(RPC_BINDING_HANDLE Binding,
unsigned int Timeout)
{
WLog_ERR(TAG, "Not implemented");
return 0;
@ -242,141 +257,165 @@ RPC_STATUS RpcServerInqBindings(RPC_BINDING_VECTOR** BindingVector)
return 0;
}
RPC_STATUS RpcServerInqIf(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV** MgrEpv)
RPC_STATUS RpcServerInqIf(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid,
RPC_MGR_EPV** MgrEpv)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerListen(unsigned int MinimumCallThreads, unsigned int MaxCalls, unsigned int DontWait)
RPC_STATUS RpcServerListen(unsigned int MinimumCallThreads,
unsigned int MaxCalls, unsigned int DontWait)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerRegisterIf(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv)
RPC_STATUS RpcServerRegisterIf(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid,
RPC_MGR_EPV* MgrEpv)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerRegisterIfEx(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv,
RPC_STATUS RpcServerRegisterIfEx(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid,
RPC_MGR_EPV* MgrEpv,
unsigned int Flags, unsigned int MaxCalls, RPC_IF_CALLBACK_FN* IfCallback)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerRegisterIf2(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, RPC_MGR_EPV* MgrEpv,
unsigned int Flags, unsigned int MaxCalls, unsigned int MaxRpcSize, RPC_IF_CALLBACK_FN* IfCallbackFn)
RPC_STATUS RpcServerRegisterIf2(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid,
RPC_MGR_EPV* MgrEpv,
unsigned int Flags, unsigned int MaxCalls, unsigned int MaxRpcSize,
RPC_IF_CALLBACK_FN* IfCallbackFn)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerUnregisterIf(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, unsigned int WaitForCallsToComplete)
RPC_STATUS RpcServerUnregisterIf(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid,
unsigned int WaitForCallsToComplete)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerUnregisterIfEx(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid, int RundownContextHandles)
RPC_STATUS RpcServerUnregisterIfEx(RPC_IF_HANDLE IfSpec, UUID* MgrTypeUuid,
int RundownContextHandles)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerUseAllProtseqs(unsigned int MaxCalls, void* SecurityDescriptor)
RPC_STATUS RpcServerUseAllProtseqs(unsigned int MaxCalls,
void* SecurityDescriptor)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerUseAllProtseqsEx(unsigned int MaxCalls, void* SecurityDescriptor, PRPC_POLICY Policy)
RPC_STATUS RpcServerUseAllProtseqsEx(unsigned int MaxCalls,
void* SecurityDescriptor, PRPC_POLICY Policy)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerUseAllProtseqsIf(unsigned int MaxCalls, RPC_IF_HANDLE IfSpec, void* SecurityDescriptor)
RPC_STATUS RpcServerUseAllProtseqsIf(unsigned int MaxCalls,
RPC_IF_HANDLE IfSpec, void* SecurityDescriptor)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerUseAllProtseqsIfEx(unsigned int MaxCalls, RPC_IF_HANDLE IfSpec, void* SecurityDescriptor, PRPC_POLICY Policy)
RPC_STATUS RpcServerUseAllProtseqsIfEx(unsigned int MaxCalls,
RPC_IF_HANDLE IfSpec, void* SecurityDescriptor, PRPC_POLICY Policy)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerUseProtseqA(RPC_CSTR Protseq, unsigned int MaxCalls, void* SecurityDescriptor)
RPC_STATUS RpcServerUseProtseqA(RPC_CSTR Protseq, unsigned int MaxCalls,
void* SecurityDescriptor)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerUseProtseqExA(RPC_CSTR Protseq, unsigned int MaxCalls, void* SecurityDescriptor, PRPC_POLICY Policy)
RPC_STATUS RpcServerUseProtseqExA(RPC_CSTR Protseq, unsigned int MaxCalls,
void* SecurityDescriptor, PRPC_POLICY Policy)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerUseProtseqW(RPC_WSTR Protseq, unsigned int MaxCalls, void* SecurityDescriptor)
RPC_STATUS RpcServerUseProtseqW(RPC_WSTR Protseq, unsigned int MaxCalls,
void* SecurityDescriptor)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerUseProtseqExW(RPC_WSTR Protseq, unsigned int MaxCalls, void* SecurityDescriptor, PRPC_POLICY Policy)
RPC_STATUS RpcServerUseProtseqExW(RPC_WSTR Protseq, unsigned int MaxCalls,
void* SecurityDescriptor, PRPC_POLICY Policy)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerUseProtseqEpA(RPC_CSTR Protseq, unsigned int MaxCalls, RPC_CSTR Endpoint, void* SecurityDescriptor)
RPC_STATUS RpcServerUseProtseqEpA(RPC_CSTR Protseq, unsigned int MaxCalls,
RPC_CSTR Endpoint, void* SecurityDescriptor)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerUseProtseqEpExA(RPC_CSTR Protseq, unsigned int MaxCalls, RPC_CSTR Endpoint, void* SecurityDescriptor, PRPC_POLICY Policy)
RPC_STATUS RpcServerUseProtseqEpExA(RPC_CSTR Protseq, unsigned int MaxCalls,
RPC_CSTR Endpoint, void* SecurityDescriptor, PRPC_POLICY Policy)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerUseProtseqEpW(RPC_WSTR Protseq, unsigned int MaxCalls, RPC_WSTR Endpoint, void* SecurityDescriptor)
RPC_STATUS RpcServerUseProtseqEpW(RPC_WSTR Protseq, unsigned int MaxCalls,
RPC_WSTR Endpoint, void* SecurityDescriptor)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerUseProtseqEpExW(RPC_WSTR Protseq, unsigned int MaxCalls, RPC_WSTR Endpoint, void* SecurityDescriptor, PRPC_POLICY Policy)
RPC_STATUS RpcServerUseProtseqEpExW(RPC_WSTR Protseq, unsigned int MaxCalls,
RPC_WSTR Endpoint, void* SecurityDescriptor, PRPC_POLICY Policy)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerUseProtseqIfA(RPC_CSTR Protseq, unsigned int MaxCalls, RPC_IF_HANDLE IfSpec, void* SecurityDescriptor)
RPC_STATUS RpcServerUseProtseqIfA(RPC_CSTR Protseq, unsigned int MaxCalls,
RPC_IF_HANDLE IfSpec, void* SecurityDescriptor)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerUseProtseqIfExA(RPC_CSTR Protseq, unsigned int MaxCalls, RPC_IF_HANDLE IfSpec, void* SecurityDescriptor, PRPC_POLICY Policy)
RPC_STATUS RpcServerUseProtseqIfExA(RPC_CSTR Protseq, unsigned int MaxCalls,
RPC_IF_HANDLE IfSpec, void* SecurityDescriptor, PRPC_POLICY Policy)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerUseProtseqIfW(RPC_WSTR Protseq, unsigned int MaxCalls, RPC_IF_HANDLE IfSpec, void* SecurityDescriptor)
RPC_STATUS RpcServerUseProtseqIfW(RPC_WSTR Protseq, unsigned int MaxCalls,
RPC_IF_HANDLE IfSpec, void* SecurityDescriptor)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerUseProtseqIfExW(RPC_WSTR Protseq, unsigned int MaxCalls, RPC_IF_HANDLE IfSpec, void* SecurityDescriptor, PRPC_POLICY Policy)
RPC_STATUS RpcServerUseProtseqIfExW(RPC_WSTR Protseq, unsigned int MaxCalls,
RPC_IF_HANDLE IfSpec, void* SecurityDescriptor, PRPC_POLICY Policy)
{
WLog_ERR(TAG, "Not implemented");
return 0;
@ -393,7 +432,8 @@ RPC_STATUS RpcMgmtStatsVectorFree(RPC_STATS_VECTOR** StatsVector)
return 0;
}
RPC_STATUS RpcMgmtInqStats(RPC_BINDING_HANDLE Binding, RPC_STATS_VECTOR** Statistics)
RPC_STATUS RpcMgmtInqStats(RPC_BINDING_HANDLE Binding,
RPC_STATS_VECTOR** Statistics)
{
WLog_ERR(TAG, "Not implemented");
return 0;
@ -434,7 +474,8 @@ RPC_STATUS RpcMgmtEnableIdleCleanup(void)
return 0;
}
RPC_STATUS RpcMgmtInqIfIds(RPC_BINDING_HANDLE Binding, RPC_IF_ID_VECTOR** IfIdVector)
RPC_STATUS RpcMgmtInqIfIds(RPC_BINDING_HANDLE Binding,
RPC_IF_ID_VECTOR** IfIdVector)
{
WLog_ERR(TAG, "Not implemented");
return 0;
@ -446,25 +487,29 @@ RPC_STATUS RpcIfIdVectorFree(RPC_IF_ID_VECTOR** IfIdVector)
return 0;
}
RPC_STATUS RpcMgmtInqServerPrincNameA(RPC_BINDING_HANDLE Binding, unsigned long AuthnSvc, RPC_CSTR* ServerPrincName)
RPC_STATUS RpcMgmtInqServerPrincNameA(RPC_BINDING_HANDLE Binding,
unsigned long AuthnSvc, RPC_CSTR* ServerPrincName)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcMgmtInqServerPrincNameW(RPC_BINDING_HANDLE Binding, unsigned long AuthnSvc, RPC_WSTR* ServerPrincName)
RPC_STATUS RpcMgmtInqServerPrincNameW(RPC_BINDING_HANDLE Binding,
unsigned long AuthnSvc, RPC_WSTR* ServerPrincName)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerInqDefaultPrincNameA(unsigned long AuthnSvc, RPC_CSTR* PrincName)
RPC_STATUS RpcServerInqDefaultPrincNameA(unsigned long AuthnSvc,
RPC_CSTR* PrincName)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerInqDefaultPrincNameW(unsigned long AuthnSvc, RPC_WSTR* PrincName)
RPC_STATUS RpcServerInqDefaultPrincNameW(unsigned long AuthnSvc,
RPC_WSTR* PrincName)
{
WLog_ERR(TAG, "Not implemented");
return 0;
@ -476,13 +521,15 @@ RPC_STATUS RpcEpResolveBinding(RPC_BINDING_HANDLE Binding, RPC_IF_HANDLE IfSpec)
return 0;
}
RPC_STATUS RpcNsBindingInqEntryNameA(RPC_BINDING_HANDLE Binding, unsigned long EntryNameSyntax, RPC_CSTR* EntryName)
RPC_STATUS RpcNsBindingInqEntryNameA(RPC_BINDING_HANDLE Binding,
unsigned long EntryNameSyntax, RPC_CSTR* EntryName)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcNsBindingInqEntryNameW(RPC_BINDING_HANDLE Binding, unsigned long EntryNameSyntax, RPC_WSTR* EntryName)
RPC_STATUS RpcNsBindingInqEntryNameW(RPC_BINDING_HANDLE Binding,
unsigned long EntryNameSyntax, RPC_WSTR* EntryName)
{
WLog_ERR(TAG, "Not implemented");
return 0;
@ -507,86 +554,110 @@ RPC_STATUS RpcRevertToSelf()
return 0;
}
RPC_STATUS RpcBindingInqAuthClientA(RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE* Privs,
RPC_CSTR* ServerPrincName, unsigned long* AuthnLevel, unsigned long* AuthnSvc, unsigned long* AuthzSvc)
RPC_STATUS RpcBindingInqAuthClientA(RPC_BINDING_HANDLE ClientBinding,
RPC_AUTHZ_HANDLE* Privs,
RPC_CSTR* ServerPrincName, unsigned long* AuthnLevel, unsigned long* AuthnSvc,
unsigned long* AuthzSvc)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcBindingInqAuthClientW(RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE* Privs,
RPC_WSTR* ServerPrincName, unsigned long* AuthnLevel, unsigned long* AuthnSvc, unsigned long* AuthzSvc)
RPC_STATUS RpcBindingInqAuthClientW(RPC_BINDING_HANDLE ClientBinding,
RPC_AUTHZ_HANDLE* Privs,
RPC_WSTR* ServerPrincName, unsigned long* AuthnLevel, unsigned long* AuthnSvc,
unsigned long* AuthzSvc)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcBindingInqAuthClientExA(RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE* Privs,
RPC_CSTR* ServerPrincName, unsigned long* AuthnLevel, unsigned long* AuthnSvc, unsigned long* AuthzSvc, unsigned long Flags)
RPC_STATUS RpcBindingInqAuthClientExA(RPC_BINDING_HANDLE ClientBinding,
RPC_AUTHZ_HANDLE* Privs,
RPC_CSTR* ServerPrincName, unsigned long* AuthnLevel, unsigned long* AuthnSvc,
unsigned long* AuthzSvc, unsigned long Flags)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcBindingInqAuthClientExW(RPC_BINDING_HANDLE ClientBinding, RPC_AUTHZ_HANDLE* Privs,
RPC_WSTR* ServerPrincName, unsigned long* AuthnLevel, unsigned long* AuthnSvc, unsigned long* AuthzSvc, unsigned long Flags)
RPC_STATUS RpcBindingInqAuthClientExW(RPC_BINDING_HANDLE ClientBinding,
RPC_AUTHZ_HANDLE* Privs,
RPC_WSTR* ServerPrincName, unsigned long* AuthnLevel, unsigned long* AuthnSvc,
unsigned long* AuthzSvc, unsigned long Flags)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcBindingInqAuthInfoA(RPC_BINDING_HANDLE Binding, RPC_CSTR* ServerPrincName, unsigned long* AuthnLevel,
unsigned long* AuthnSvc, RPC_AUTH_IDENTITY_HANDLE* AuthIdentity, unsigned long* AuthzSvc)
RPC_STATUS RpcBindingInqAuthInfoA(RPC_BINDING_HANDLE Binding,
RPC_CSTR* ServerPrincName, unsigned long* AuthnLevel,
unsigned long* AuthnSvc, RPC_AUTH_IDENTITY_HANDLE* AuthIdentity,
unsigned long* AuthzSvc)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcBindingInqAuthInfoW(RPC_BINDING_HANDLE Binding, RPC_WSTR* ServerPrincName, unsigned long* AuthnLevel,
unsigned long* AuthnSvc, RPC_AUTH_IDENTITY_HANDLE* AuthIdentity, unsigned long* AuthzSvc)
RPC_STATUS RpcBindingInqAuthInfoW(RPC_BINDING_HANDLE Binding,
RPC_WSTR* ServerPrincName, unsigned long* AuthnLevel,
unsigned long* AuthnSvc, RPC_AUTH_IDENTITY_HANDLE* AuthIdentity,
unsigned long* AuthzSvc)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcBindingSetAuthInfoA(RPC_BINDING_HANDLE Binding, RPC_CSTR ServerPrincName, unsigned long AuthnLevel,
unsigned long AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, unsigned long AuthzSvc)
RPC_STATUS RpcBindingSetAuthInfoA(RPC_BINDING_HANDLE Binding,
RPC_CSTR ServerPrincName, unsigned long AuthnLevel,
unsigned long AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity,
unsigned long AuthzSvc)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcBindingSetAuthInfoExA(RPC_BINDING_HANDLE Binding, RPC_CSTR ServerPrincName, unsigned long AuthnLevel,
unsigned long AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, unsigned long AuthzSvc, RPC_SECURITY_QOS* SecurityQos)
RPC_STATUS RpcBindingSetAuthInfoExA(RPC_BINDING_HANDLE Binding,
RPC_CSTR ServerPrincName, unsigned long AuthnLevel,
unsigned long AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity,
unsigned long AuthzSvc, RPC_SECURITY_QOS* SecurityQos)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcBindingSetAuthInfoW(RPC_BINDING_HANDLE Binding, RPC_WSTR ServerPrincName, unsigned long AuthnLevel,
unsigned long AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, unsigned long AuthzSvc)
RPC_STATUS RpcBindingSetAuthInfoW(RPC_BINDING_HANDLE Binding,
RPC_WSTR ServerPrincName, unsigned long AuthnLevel,
unsigned long AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity,
unsigned long AuthzSvc)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcBindingSetAuthInfoExW(RPC_BINDING_HANDLE Binding, RPC_WSTR ServerPrincName, unsigned long AuthnLevel,
unsigned long AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity, unsigned long AuthzSvc, RPC_SECURITY_QOS* SecurityQOS)
RPC_STATUS RpcBindingSetAuthInfoExW(RPC_BINDING_HANDLE Binding,
RPC_WSTR ServerPrincName, unsigned long AuthnLevel,
unsigned long AuthnSvc, RPC_AUTH_IDENTITY_HANDLE AuthIdentity,
unsigned long AuthzSvc, RPC_SECURITY_QOS* SecurityQOS)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcBindingInqAuthInfoExA(RPC_BINDING_HANDLE Binding, RPC_CSTR* ServerPrincName, unsigned long* AuthnLevel,
unsigned long* AuthnSvc, RPC_AUTH_IDENTITY_HANDLE* AuthIdentity, unsigned long* AuthzSvc,
RPC_STATUS RpcBindingInqAuthInfoExA(RPC_BINDING_HANDLE Binding,
RPC_CSTR* ServerPrincName, unsigned long* AuthnLevel,
unsigned long* AuthnSvc, RPC_AUTH_IDENTITY_HANDLE* AuthIdentity,
unsigned long* AuthzSvc,
unsigned long RpcQosVersion, RPC_SECURITY_QOS* SecurityQOS)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcBindingInqAuthInfoExW(RPC_BINDING_HANDLE Binding, RPC_WSTR* ServerPrincName, unsigned long* AuthnLevel,
unsigned long* AuthnSvc, RPC_AUTH_IDENTITY_HANDLE* AuthIdentity, unsigned long* AuthzSvc,
RPC_STATUS RpcBindingInqAuthInfoExW(RPC_BINDING_HANDLE Binding,
RPC_WSTR* ServerPrincName, unsigned long* AuthnLevel,
unsigned long* AuthnSvc, RPC_AUTH_IDENTITY_HANDLE* AuthIdentity,
unsigned long* AuthzSvc,
unsigned long RpcQosVersion, RPC_SECURITY_QOS* SecurityQOS)
{
WLog_ERR(TAG, "Not implemented");
@ -594,20 +665,23 @@ RPC_STATUS RpcBindingInqAuthInfoExW(RPC_BINDING_HANDLE Binding, RPC_WSTR* Server
}
RPC_STATUS RpcServerRegisterAuthInfoA(RPC_CSTR ServerPrincName, unsigned long AuthnSvc, RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn, void* Arg)
RPC_STATUS RpcServerRegisterAuthInfoA(RPC_CSTR ServerPrincName,
unsigned long AuthnSvc, RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn, void* Arg)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcServerRegisterAuthInfoW(RPC_WSTR ServerPrincName, unsigned long AuthnSvc, RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn, void* Arg)
RPC_STATUS RpcServerRegisterAuthInfoW(RPC_WSTR ServerPrincName,
unsigned long AuthnSvc, RPC_AUTH_KEY_RETRIEVAL_FN GetKeyFn, void* Arg)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcBindingServerFromClient(RPC_BINDING_HANDLE ClientBinding, RPC_BINDING_HANDLE* ServerBinding)
RPC_STATUS RpcBindingServerFromClient(RPC_BINDING_HANDLE ClientBinding,
RPC_BINDING_HANDLE* ServerBinding)
{
WLog_ERR(TAG, "Not implemented");
return 0;
@ -665,7 +739,7 @@ RPC_STATUS UuidCreateSequential(UUID* Uuid)
return RPC_S_OK;
}
RPC_STATUS UuidToStringA(UUID* Uuid, RPC_CSTR* StringUuid)
RPC_STATUS UuidToStringA(const UUID* Uuid, RPC_CSTR* StringUuid)
{
*StringUuid = (RPC_CSTR) malloc(36 + 1);
@ -679,7 +753,8 @@ RPC_STATUS UuidToStringA(UUID* Uuid, RPC_CSTR* StringUuid)
* Format is 32 hex digits partitioned in 5 groups:
* xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
*/
sprintf_s((char*) *StringUuid, 36 + 1, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
sprintf_s((char*) *StringUuid, 36 + 1,
"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
Uuid->Data1, Uuid->Data2, Uuid->Data3,
Uuid->Data4[0], Uuid->Data4[1],
Uuid->Data4[2], Uuid->Data4[3], Uuid->Data4[4],
@ -687,7 +762,7 @@ RPC_STATUS UuidToStringA(UUID* Uuid, RPC_CSTR* StringUuid)
return RPC_S_OK;
}
RPC_STATUS UuidToStringW(UUID* Uuid, RPC_WSTR* StringUuid)
RPC_STATUS UuidToStringW(const UUID* Uuid, RPC_WSTR* StringUuid)
{
WLog_ERR(TAG, "Not implemented");
return 0;
@ -725,7 +800,8 @@ RPC_STATUS UuidFromStringA(RPC_CSTR StringUuid, UUID* Uuid)
return RPC_S_INVALID_STRING_UUID;
}
Uuid->Data1 = ((bin[0] << 28) | (bin[1] << 24) | (bin[2] << 20) | (bin[3] << 16) |
Uuid->Data1 = ((bin[0] << 28) | (bin[1] << 24) | (bin[2] << 20) |
(bin[3] << 16) |
(bin[4] << 12) | (bin[5] << 8) | (bin[6] << 4) | bin[7]);
Uuid->Data2 = ((bin[9] << 12) | (bin[10] << 8) | (bin[11] << 4) | bin[12]);
Uuid->Data3 = ((bin[14] << 12) | (bin[15] << 8) | (bin[16] << 4) | bin[17]);
@ -746,7 +822,7 @@ RPC_STATUS UuidFromStringW(RPC_WSTR StringUuid, UUID* Uuid)
return 0;
}
signed int UuidCompare(UUID* Uuid1, UUID* Uuid2, RPC_STATUS* Status)
signed int UuidCompare(const UUID* Uuid1, const UUID* Uuid2, RPC_STATUS* Status)
{
int index;
*Status = RPC_S_OK;
@ -781,47 +857,52 @@ RPC_STATUS UuidCreateNil(UUID* NilUuid)
return RPC_S_OK;
}
int UuidEqual(UUID* Uuid1, UUID* Uuid2, RPC_STATUS* Status)
int UuidEqual(const UUID* Uuid1, const UUID* Uuid2, RPC_STATUS* Status)
{
return ((UuidCompare(Uuid1, Uuid2, Status) == 0) ? TRUE : FALSE);
}
unsigned short UuidHash(UUID* Uuid, RPC_STATUS* Status)
unsigned short UuidHash(const UUID* Uuid, RPC_STATUS* Status)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
int UuidIsNil(UUID* Uuid, RPC_STATUS* Status)
int UuidIsNil(const UUID* Uuid, RPC_STATUS* Status)
{
return UuidEqual(Uuid, &UUID_NIL, Status);
}
RPC_STATUS RpcEpRegisterNoReplaceA(RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR* BindingVector, UUID_VECTOR* UuidVector, RPC_CSTR Annotation)
RPC_STATUS RpcEpRegisterNoReplaceA(RPC_IF_HANDLE IfSpec,
RPC_BINDING_VECTOR* BindingVector, UUID_VECTOR* UuidVector, RPC_CSTR Annotation)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcEpRegisterNoReplaceW(RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR* BindingVector, UUID_VECTOR* UuidVector, RPC_WSTR Annotation)
RPC_STATUS RpcEpRegisterNoReplaceW(RPC_IF_HANDLE IfSpec,
RPC_BINDING_VECTOR* BindingVector, UUID_VECTOR* UuidVector, RPC_WSTR Annotation)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcEpRegisterA(RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR* BindingVector, UUID_VECTOR* UuidVector, RPC_CSTR Annotation)
RPC_STATUS RpcEpRegisterA(RPC_IF_HANDLE IfSpec,
RPC_BINDING_VECTOR* BindingVector, UUID_VECTOR* UuidVector, RPC_CSTR Annotation)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcEpRegisterW(RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR* BindingVector, UUID_VECTOR* UuidVector, RPC_WSTR Annotation)
RPC_STATUS RpcEpRegisterW(RPC_IF_HANDLE IfSpec,
RPC_BINDING_VECTOR* BindingVector, UUID_VECTOR* UuidVector, RPC_WSTR Annotation)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcEpUnregister(RPC_IF_HANDLE IfSpec, RPC_BINDING_VECTOR* BindingVector, UUID_VECTOR* UuidVector)
RPC_STATUS RpcEpUnregister(RPC_IF_HANDLE IfSpec,
RPC_BINDING_VECTOR* BindingVector, UUID_VECTOR* UuidVector)
{
WLog_ERR(TAG, "Not implemented");
return 0;
@ -841,7 +922,8 @@ RPC_STATUS DceErrorInqTextW(RPC_STATUS RpcStatus, RPC_WSTR ErrorText)
}
RPC_STATUS RpcMgmtEpEltInqBegin(RPC_BINDING_HANDLE EpBinding, unsigned long InquiryType, RPC_IF_ID* IfId,
RPC_STATUS RpcMgmtEpEltInqBegin(RPC_BINDING_HANDLE EpBinding,
unsigned long InquiryType, RPC_IF_ID* IfId,
unsigned long VersOption, UUID* ObjectUuid, RPC_EP_INQ_HANDLE* InquiryContext)
{
WLog_ERR(TAG, "Not implemented");
@ -854,14 +936,16 @@ RPC_STATUS RpcMgmtEpEltInqDone(RPC_EP_INQ_HANDLE* InquiryContext)
return 0;
}
RPC_STATUS RpcMgmtEpEltInqNextA(RPC_EP_INQ_HANDLE InquiryContext, RPC_IF_ID* IfId,
RPC_STATUS RpcMgmtEpEltInqNextA(RPC_EP_INQ_HANDLE InquiryContext,
RPC_IF_ID* IfId,
RPC_BINDING_HANDLE* Binding, UUID* ObjectUuid, RPC_CSTR* Annotation)
{
WLog_ERR(TAG, "Not implemented");
return 0;
}
RPC_STATUS RpcMgmtEpEltInqNextW(RPC_EP_INQ_HANDLE InquiryContext, RPC_IF_ID* IfId,
RPC_STATUS RpcMgmtEpEltInqNextW(RPC_EP_INQ_HANDLE InquiryContext,
RPC_IF_ID* IfId,
RPC_BINDING_HANDLE* Binding, UUID* ObjectUuid, RPC_WSTR* Annotation)
{
WLog_ERR(TAG, "Not implemented");