archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Branch: master
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'master'
${ noResults }
windows-server-2003/com/rpc/runtime/epmap/worker.c

3562 lines
85 KiB
Raw Permalink Blame History

/*++
Copyright (C) Microsoft Corporation, 1991 - 1999
Module Name:
worker.c
Abstract:
This file contains the real stuff for the EP Mapper.
Author:
Bharat Shah (barat) 17-2-92
Revision History:
06-03-97 gopalp Added code to cleanup stale EP Mapper entries.
--*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <sysinc.h>
#include <wincrypt.h>
#include <rpc.h>
#include <rpcndr.h>
#include "epmp.h"
#include "eptypes.h"
#include "local.h"
#include "twrproto.h"
#include <winsock2.h>
#define StringCompareA lstrcmpiA
#define StringLengthA lstrlenA
#define EP_S_DUPLICATE_ENTRY 0x16c9a0d8
RPC_IF_ID LocalNullUuid = {0};
UUID MgmtIf = {
0xafa8bd80,
0x7d8a,
0x11c9,
{0xbe, 0xf4, 0x08, 0x00, 0x2b, 0x10, 0x29, 0x89}
};
const int IP_ADDR_OFFSET = 0x4b;
void
PatchTower(
IN OUT twr_t *Tower,
IN int address)
{
int UNALIGNED *pIPAddr;
pIPAddr = (int UNALIGNED *) (((char *) Tower) + IP_ADDR_OFFSET);
//
// Patch the tower
//
*pIPAddr = address;
}
//
// Forward definitions
//
USHORT
GetProtseqIdAnsi(
PSTR Protseq
);
RPC_STATUS
DelayedUseProtseq(
USHORT id
);
VOID
CompleteDelayedUseProtseqs(
void
);
void
DeletePSEP(
PIFOBJNode Node,
char * Protseq,
char * Endpoint
);
void
PurgeOldEntries(
PIFOBJNode Node,
PPSEPNode List,
BOOL StrictMatch
);
RPC_STATUS
MatchPSAndEP (
PPSEPNode Node,
void *Pseq,
void * Endpoint,
unsigned long Version
);
PPSEPNode
FindPSEP (
register PPSEPNode List,
char * Pseq,
char * Endpoint,
unsigned long Version,
PFNPointer2 Compare
);
PIFOBJNode
FindIFOBJNode(
register PIFOBJNode List,
UUID * Obj,
UUID * IF,
unsigned long Version,
PSID pSID,
unsigned long Inq,
unsigned long VersOpts,
PFNPointer Compare
);
PIENTRY
MatchByKey(
register PIENTRY pList,
unsigned long key
)
/*++
Routine Description:
This routine Seqrches the Link-list of IF-OBJ nodes based on
key supplied.
Arguments:
List - The Linked list [head] - to be searched
key - The Id
Return Value:
Returns a pointer to the matching IFObj node in the list or returns NULL.
--*/
{
CheckInSem();
for (; pList && pList->Id < key; pList = pList->Next)
{
; // Empty body
}
return(pList);
}
RPC_STATUS RPC_ENTRY
GetForwardEp(
UUID *IfId,
RPC_VERSION * IFVersion,
UUID *Object,
unsigned char * Protseq,
void * * EpString
)
/*++
Routine Description:
Server rutime has received a pkt destined for a dynamically
declared endpoint. Epmapper must return the servers endpoint
to enable the runtime to correctly forward the pkt.
Arguments:
IF - Server Interface UUID
IFVersion - Version of the Interface
Obj - UUID of the Object
Protseq - Ptotocol sequence the interface is using.
EpString - Place to store the endpoint structure.
Return Value:
Returns a pointer to a string containing the server's endpoint.
RPC_S_OUT_OF_MEMORY
EPT_S_NOT_REGISTERED
---*/
{
PIFOBJNode pNode;
PPSEPNode pPSEPNode;
unsigned short len;
char * String;
PFNPointer Match;
unsigned long InqType;
unsigned long Version = VERSION(IFVersion->MajorVersion,
IFVersion->MinorVersion);
if (memcmp((char *)IfId, (char *)&MgmtIf, sizeof(UUID)) == 0)
{
InqType = RPC_C_EP_MATCH_BY_OBJ;
Match = SearchIFObjNode;
}
else
{
InqType = 0;
Match = WildCardMatch;
}
*EpString = 0;
EnterSem();
pNode = IFObjList;
if (pNode == 0)
{
LeaveSem();
return(EPT_S_NOT_REGISTERED);
}
while (pNode != 0)
{
// We do not have support for registrant SID matching for DG.
pNode = FindIFOBJNode(
pNode,
Object,
IfId,
Version,
NULL,
InqType,
0,
Match
);
if (pNode == 0)
{
LeaveSem();
return(EPT_S_NOT_REGISTERED);
}
pPSEPNode = pNode->PSEPlist;
pPSEPNode = FindPSEP(
pPSEPNode,
Protseq,
NULL,
0L,
MatchPSAndEP
);
if (pPSEPNode == 0)
{
pNode = pNode->Next;
if (pNode == 0)
{
LeaveSem();
return(EPT_S_NOT_REGISTERED);
}
continue;
}
// We now have a PSEPNode. We just ought to return the first one!
// Use I_RpcAllocate To Allocate because runtime will free this!
String = I_RpcAllocate( len = (strlen(pPSEPNode->EP) + 1) );
if (String == 0)
{
LeaveSem();
return(RPC_S_OUT_OF_MEMORY);
}
memcpy(String, pPSEPNode->EP, len);
*EpString = String;
LeaveSem();
return(RPC_S_OK);
} // while loop
// we never go through here.
return(EPT_S_NOT_REGISTERED);
}
RPC_STATUS
SearchIFObjNode(
PIFOBJNode pNode,
UUID *Object,
UUID *IfUuid,
unsigned long Version,
PSID pSID,
unsigned long InqType,
unsigned long VersOption
)
/*++
Routine Description:
This routine Seqrches the Link-list of IF-OBJ nodes based on
Obj, IFUuid, IFVersion, Inqtype [Ignore OBJ, IgnoreIF, etc],
and VersOption [Identical Ver, Compatible Vers. etc]
Arguments:
List - The Linked list head - to be searched
Obj - UUID of the Object
IF - Interface UUID
Version - Version of the Interface
pSID - SID of the registering principal. NULL will match any principal's entry.
InqType - Type of Inquiry [Filter options based on IF/Obj/Both
VersOpts - Filter options based on Version
Return Value:
Returns a pointer to the matching IFObj node in the list or returns NULL.
--*/
{
switch (InqType)
{
default:
case RPC_C_EP_ALL_ELTS:
return 0;
case RPC_C_EP_MATCH_BY_BOTH:
if (memcmp(
(char *)&pNode->ObjUuid,
(char *)Object,
sizeof(UUID))
||
// !(pSID -> EqualSid (pNode->pSID, pSID))
!(!pSID || EqualSid (pNode->pSID, pSID))
)
return(1);
// Intentionally Fall through ..
case RPC_C_EP_MATCH_BY_IF:
return(!(
(
!memcmp(
(char *)&pNode->IFUuid,
(char *)IfUuid,
sizeof(UUID)
)
)
&&
(
( (VersOption == RPC_C_VERS_UPTO)
&& pNode->IFVersion <= Version)
|| ( (VersOption == RPC_C_VERS_COMPATIBLE)
&& ((pNode->IFVersion & 0xFFFF0000) ==
(Version & 0xFFFF0000))
&& (pNode->IFVersion >= Version)
)
|| ( (VersOption == RPC_C_VERS_EXACT)
&& (pNode->IFVersion == Version)
)
|| (VersOption == RPC_C_VERS_ALL)
|| ( (VersOption == RPC_C_VERS_MAJOR_ONLY)
&& ((pNode->IFVersion & 0xFFFF0000L)
== (Version & 0xFFFF0000L))
)
|| ( (VersOption ==
I_RPC_C_VERS_UPTO_AND_COMPATIBLE)
&& ((pNode->IFVersion & 0xFFFF0000L)
== (Version & 0xFFFF0000L))
&& (pNode->IFVersion <= Version)
)
)
)
||
!(!pSID || EqualSid (pNode->pSID, pSID))
); // return(
case RPC_C_EP_MATCH_BY_OBJ:
return(
memcmp(
(char *)&pNode->ObjUuid,
(char *)Object,
sizeof(UUID)
)
||
!(!pSID || EqualSid (pNode->pSID, pSID))
);
} // switch
}
PIFOBJNode
FindIFOBJNode(
register PIFOBJNode List,
UUID * Obj,
UUID * IF,
unsigned long Version,
PSID pSID,
unsigned long Inq,
unsigned long VersOpts,
PFNPointer Compare
)
/*++
Routine Description:
This routine Searches the Linked list of IFOBJ nodes based on
Obj, IF, and the SID of the registering principal.
Arguments:
List - The Linked list head - to be searched
Obj - UUID of the Object
IF - Interface UUID
Version - Version of the Interface
pSID - The SID of the registering principal
Inq - Type of Inquiry [Filter based on IF/OB/Both]
VersOpt - Filter based on version [<=, >=, == etc]
Compare() - A pointer to function used for searching.
WildCardMatch or ExactMatch.
Return Value:
Returns a pointer to the matching IFObj node in the list or returns NULL.
--*/
{
CheckInSem();
for (; (List !=NULL) && (*Compare)(List, Obj, IF, Version, pSID, Inq, VersOpts);
List = List->Next)
{
; // Empty body
}
return (List);
}
PPSEPNode
FindPSEP (
register PPSEPNode List,
char * Pseq,
char * Endpoint,
unsigned long Version,
PFNPointer2 Compare
)
/*++
Routine Description:
This routine Searches the Link-list of PSEP nodes based on
Protocol sequence and Endpoint specified.
Arguments:
List - The Linked list head - to be searched
Pseq - Protocol sequence string specified
Endpoint - Endpoint string specified
Version - Version of the Interface
Compare() - A pointer to function used for searching.
Return Value:
Returns a pointer to the matching PSEP node in the list or returns NULL.
--*/
{
CheckInSem();
for (; List && (*Compare)(List, Pseq, Endpoint, Version); List = List->Next)
{
; // Empty body
}
return (List);
if (Version); // May need this if we overload FindNode and collapse
// FindPSEP and FindIFOBJ
}
RPC_STATUS
ExactMatch(
PIFOBJNode Node,
UUID *Obj,
UUID *IF,
unsigned long Version,
PSID pSID,
unsigned long InqType,
unsigned long VersOptions
)
/*++
Routine Description:
This routine compares a Node in the IFOBJList to [Obj, IF, Version] triple
and returns 0 if there is an exact match else returns 1
Arguments:
Node - An IFOBJ node
Obj - UUID of the Object
IF - Interface UUID
Version - Version of the Interface
Return Value:
Returns 0 if there is an exact match; 1 otherwise
--*/
{
return(( memcmp(&Node->ObjUuid, Obj,sizeof(UUID))
|| memcmp(&Node->IFUuid, IF, sizeof(UUID))
|| (Node->IFVersion != Version))
||
// !(pSID -> EqualSid (pNode->pSID, pSID))
!(!pSID || EqualSid (Node->pSID, pSID))
);
}
RPC_STATUS
WildCardMatch (
PIFOBJNode Node,
UUID *Obj,
UUID *IF,
unsigned long Version,
PSID pSID,
unsigned long InqType,
unsigned long VersOptions
)
/*++
Routine Description:
This routine compares a Node in the IFOBJList to [Obj, IF, Version] triple
and returns 0 if there is an exact match or if registered IF-Obj node
has a NULL Obj UUid and version of the registed IF_Obj is >= that
supplied
Arguments:
Node - An IFOBJ node
Obj - UUID of the Object
IF - Interface UUID
Version - Version of the Interface
Return Value:
Returns 0 if there is a wild card match ; 1 otherwise
--*/
{
if ( (!memcmp(&Node->IFUuid, IF, sizeof(UUID)))
&& ((Node->IFVersion & 0xFFFF0000L) == (Version & 0xFFFF0000L))
&& (Node->IFVersion >= Version)
&& ((!memcmp(&Node->ObjUuid, Obj, sizeof(UUID))) ||
(IsNullUuid(&Node->ObjUuid)) )
&&
// pSID -> EqualSid (Node->pSID, pSID)
(!pSID || EqualSid (Node->pSID, pSID)) )
{
return(0);
}
return(1);
}
RPC_STATUS
MatchPSAndEP (
PPSEPNode Node,
void *Pseq,
void * Endpoint,
unsigned long Version
)
/*++
Routine Description:
This routine Matches A Node on PSEP list with given Protseq and Endpoint
If Pseq is given pseqs are matched, if Endpoint is given Endpoints
are matched, if neither is given returns true, if both are given
both are matched.
Arguments:
Node - A PSEP node on PSEP list.
Pseq - Protocol Sequence string
Endpoint - Endpoint string
Return Value:
Returns 0 if Matched successfully, 1 otherwise.
--*/
{
return ( (Pseq && RpcpStringCompareA(Node->Protseq, Pseq))
|| (Endpoint && RpcpStringCompareA(Node->EP, Endpoint)) );
}
void
PurgeOldEntries(
PIFOBJNode Node,
PPSEPNode List,
BOOL StrictMatch
)
{
PPSEPNode Tmp, DeleteMe;
char * Endpoint = 0;
CheckInSem();
Tmp = Node->PSEPlist;
while (Tmp != 0)
{
if (StrictMatch == TRUE)
Endpoint = Tmp->EP;
if (DeleteMe = FindPSEP(List, Tmp->Protseq, Endpoint, 0L, MatchPSAndEP))
{
DeleteMe = Tmp;
Tmp = Tmp->Next;
UnLinkFromPSEPList(&Node->PSEPlist, DeleteMe);
DeleteMe->Signature = FREE;
FreeMem(DeleteMe);
}
else
{
Tmp = Tmp->Next;
}
}
}
RPC_STATUS
IsNullUuid (
UUID * Uuid
)
/*++
Routine Description:
This routine checks if a UUID is Nil
Arguments:
Uuid - UUID to be tested
Return Value:
Returns 1 if it is a Nil UUID
0 otherwise.
--*/
{
unsigned long PAPI * Vector;
Vector = (unsigned long PAPI *) Uuid;
if ( (Vector[0] == 0)
&& (Vector[1] == 0)
&& (Vector[2] == 0)
&& (Vector[3] == 0))
return(1);
return(0);
}
twr_p_t
NewTower(
twr_p_t Tower
)
/*++
Routine Description:
This routine returns a New, Duplicated tower
Arguments:
Tower - The tower that needs to be duplicated.
Return Value:
Retunes a pointer to a new tower if successful else returns
NULL
--*/
{
unsigned short len;
twr_p_t NewTower;
len = (unsigned short)(sizeof(Tower->tower_length) + Tower->tower_length);
if ((NewTower = MIDL_user_allocate(len)) != NULL)
{
memcpy((char *)NewTower, (char *)Tower, len);
}
return(NewTower);
}
const unsigned long EPLookupHandleSignature = 0xFAFAFAFA;
PSAVEDCONTEXT
GetNewContext(
unsigned long Type
)
/*++
Routine Description
++*/
{
PSAVEDCONTEXT Context;
if ( ((Context = AllocMem(sizeof(SAVEDCONTEXT))) == 0) )
return 0;
memset(Context, 0, sizeof(SAVEDCONTEXT));
Context->Cb = sizeof(SAVEDCONTEXT);
Context->Type = Type;
Context->Signature = EPLookupHandleSignature;
EnLinkContext(Context);
return(Context);
}
const unsigned int EPMapSignature = 0xCBBCCBBC;
const unsigned int EPLookupSignature = 0xABBAABBA;
RPC_STATUS
AddToSavedContext(
PSAVEDCONTEXT Context,
PIFOBJNode Node,
PPSEPNode Psep,
unsigned long Calltype,
BOOL fPatchTower,
int PatchTowerAddress
)
{
void * NewNode;
PSAVEDTOWER SavedTower;
PSAVED_EPT SavedEndpoint;
unsigned long Size;
unsigned long TowerSize;
ASSERT(Calltype == Context->Type);
switch (Calltype)
{
case EP_MAP:
Size = sizeof(SAVEDTOWER) ;
if ((NewNode = AllocMem(Size)) == 0)
return(RPC_S_OUT_OF_MEMORY);
SavedTower = (PSAVEDTOWER) NewNode;
memset(SavedTower, 0, Size);
SavedTower->Cb = Size;
SavedTower->Signature = EPMapSignature;
SavedTower->Tower = NewTower(Psep->Tower);
if (SavedTower->Tower == 0)
{
FreeMem(NewNode);
return(RPC_S_OUT_OF_MEMORY);
}
if (fPatchTower)
{
PatchTower(SavedTower->Tower, PatchTowerAddress);
}
break;
case EP_LOOKUP:
Size = sizeof(SAVED_EPT) + strlen(Node->Annotation) + 1;
if ((NewNode = AllocMem(Size)) == 0)
return(RPC_S_OUT_OF_MEMORY);
SavedEndpoint = (PSAVED_EPT) NewNode;
memset(SavedEndpoint, 0, Size);
SavedEndpoint->Cb = Size;
SavedEndpoint->Signature = EPLookupSignature;
SavedEndpoint->Tower = NewTower(Psep->Tower);
SavedEndpoint->Annotation = (char *)NewNode +
sizeof(SAVED_EPT);
memcpy( (char *) &SavedEndpoint->Object,
(char *)&Node->ObjUuid,
sizeof(UUID)
);
strcpy(SavedEndpoint->Annotation, Node->Annotation);
if (SavedEndpoint->Tower == 0)
{
FreeMem(NewNode);
return(RPC_S_OUT_OF_MEMORY);
}
if (fPatchTower)
{
PatchTower(SavedEndpoint->Tower, PatchTowerAddress);
}
break;
default:
ASSERT(!"Unknown lookup type\n");
return(RPC_S_INTERNAL_ERROR);
break;
}
Link((PIENTRY *)(&Context->List), NewNode);
return(RPC_S_OK);
}
RPC_STATUS
GetEntriesFromSavedContext(
PSAVEDCONTEXT Context,
char * Buffer,
unsigned long Requested,
unsigned long *Returned
)
{
PIENTRY SavedEntry = (PIENTRY)Context->List;
PIENTRY TmpEntry;
unsigned long Type = Context->Type;
while ( (*Returned < Requested) && (SavedEntry != 0) )
{
switch (Type)
{
case EP_MAP:
((I_Tower *)Buffer)->Tower = ((PSAVEDTOWER)SavedEntry)->Tower;
Buffer = Buffer + sizeof(I_Tower);
break;
case EP_LOOKUP:
((ept_entry_t *)Buffer)->tower = ((PSAVED_EPT)SavedEntry)->Tower;
strcpy(((ept_entry_t *)Buffer)->annotation,
((PSAVED_EPT)SavedEntry)->Annotation);
memcpy(Buffer,(char *)&((PSAVED_EPT)SavedEntry)->Object,
sizeof(UUID));
Buffer = Buffer + sizeof(ept_entry_t);
break;
default:
ASSERT(!"Unknown Inquiry Type");
break;
}
(*Returned)++;
TmpEntry = SavedEntry;
SavedEntry = SavedEntry->Next;
UnLink((PIENTRY *)&Context->List, TmpEntry);
FreeMem(TmpEntry);
}
return(RPC_S_OK);
}
RPC_STATUS
GetEntries(
UUID *ObjUuid,
UUID *IFUuid,
unsigned long Version,
char * Pseq,
PSID pSID,
ept_lookup_handle_t *key,
char * Buffer,
unsigned long Calltype,
unsigned long Requested,
unsigned long *Returned,
unsigned long InqType,
unsigned long VersOptions,
PFNPointer Match
)
/*++
Routine Description:
This is a generic routine for retreiving a series [as spec. by Requested]
of Towers (in case of Map) or ept_entry_t's in case of Lookup.
Arguments:
ObjUuid - Object Uuid
IfUuid - Interface Uuid
Version - InterfaceVersion [hi ushort = VerMajor, lo ushort VerMinor]
Pseq - An ascii string specifying the protocol seq.
pSID - SID of the registering principal. NULL will retrieve without regard to SID.
key - A resume key - If NULL, search is started from the beginning
if non-null, represents an encoding from where the epmapper
supposed to start searching. It is an opaque value as far
as the client is concerned.
Buffer - A buffer of entries returned
Calltype - A flag to indicate whether Ep_entries or string bindings
are to be returned.
Requested - Max no. of entries requested
Returned - Actual no of entroes returned
Return Value:
RPC_S_OUT_OF_MEMORY
RPC_S_OK
EP_S_NOT_REGISTERED
--*/
{
PIFOBJNode pNode=NULL, pList = IFObjList;
unsigned long err=0, fResumeNodeFound=0;
PPSEPNode pPSEPNode;
char * buffer = Buffer;
PSAVEDCONTEXT Context = (PSAVEDCONTEXT) *key;
ept_lookup_handle_t LOOKUP_FINISHED = (ept_lookup_handle_t) LongToPtr(0xffffffff);
int UNALIGNED *pIPAddr;
BOOL fPatchTower;
int PatchTowerAddress;
SOCKADDR_STORAGE SockAddr;
ULONG BufferSize;
int FormatType;
RPC_STATUS RpcStatus;
*Returned = 0;
EnterSem();
if (*key)
{
if (*key == LOOKUP_FINISHED)
{
*key = 0;
LeaveSem();
return(EP_S_NOT_REGISTERED);
}
if (Context->Signature != EPLookupHandleSignature)
{
LeaveSem();
return EP_S_CANT_PERFORM_OP;
}
err = GetEntriesFromSavedContext(Context, Buffer, Requested, Returned);
if (Context->List == 0)
{
UnLink((PIENTRY *)&GlobalContextList, (PIENTRY)Context);
FreeMem(Context);
// Setting the Key To FFFFFFFFL is a hack for down level
// Version 1.0 Ep Clients who never expected getting a key 0
// and Success!
if (Requested <= 1)
*key = LOOKUP_FINISHED;
else
*key = 0L;
LeaveSem();
return(err);
}
LeaveSem();
return(err);
}
*key = 0;
while ((!err))
{
if ((pNode = FindIFOBJNode(
pList,
ObjUuid,
IFUuid,
Version,
pSID,
InqType,
VersOptions,
Match)) == 0)
{
break;
}
pPSEPNode = pNode->PSEPlist;
while (pPSEPNode != 0)
{
if ((pPSEPNode = FindPSEP(pPSEPNode, Pseq, NULL, 0L,
MatchPSAndEP)) == 0)
break;
fPatchTower = FALSE;
if (StringCompareA(pPSEPNode->Protseq, "ncacn_ip_tcp") == 0
|| StringCompareA(pPSEPNode->Protseq, "ncadg_ip_udp") == 0
|| StringCompareA(pPSEPNode->Protseq, "ncacn_http") == 0)
{
pIPAddr = (int UNALIGNED *) ((char *) pPSEPNode->Tower + IP_ADDR_OFFSET);
if (*pIPAddr == 0)
{
BufferSize = sizeof(SockAddr);
RpcStatus = I_RpcServerInqLocalConnAddress(NULL,
&SockAddr,
&BufferSize,
&FormatType);
if (RpcStatus == RPC_S_OK)
{
// IPv6 towers don't exist yet - they are not defined
// by DCE. Do patching for IPv4 only
if (FormatType == RPC_P_ADDR_FORMAT_TCP_IPV4)
{
PatchTowerAddress = ((SOCKADDR_IN *)&SockAddr)->sin_addr.S_un.S_addr;
fPatchTower = TRUE;
}
}
}
}
if (*Returned < Requested)
{
err = PackDataIntoBuffer(&buffer, pNode, pPSEPNode, Calltype, fPatchTower, PatchTowerAddress);
if (err == RPC_S_OK)
{
(*Returned)++;
}
else
{
ASSERT(err == RPC_S_OUT_OF_MEMORY);
break;
}
}
else
{
if (Context == 0)
{
*key = (ept_lookup_handle_t) (Context = GetNewContext(Calltype));
if (Context == 0)
{
err = RPC_S_OUT_OF_MEMORY;
break;
}
}
AddToSavedContext(Context, pNode, pPSEPNode, Calltype, fPatchTower, PatchTowerAddress);
}
pPSEPNode = pPSEPNode->Next;
} // while - over PSEPList
pList = pNode->Next;
} // while - over IFOBJList
LeaveSem();
if ((*Returned == 0) && Requested && (!err))
{
err = EP_S_NOT_REGISTERED;
}
if ((*Returned <= Requested) && (Context == 0))
{
if (Requested <= 1)
*key = LOOKUP_FINISHED;
else
*key = 0L;
}
return(err);
}
RPC_STATUS
PackDataIntoBuffer(
char * * Buffer,
PIFOBJNode Node,
PPSEPNode PSEP,
unsigned long Type,
BOOL fPatchTower,
int PatchTowerAddress
)
/*++
Routine Description:
This routine copies 1 entry [Either a Tower or ept_entry]
in the Buffer, increments buffer appropriately.
Arguments:
BindingHandle - An explicit binding handle to the EP.
Node - IFOBJNode
PSEP - PSEPNode
Type - Type of entry to be copied
PatchTower - if TRUE, the newly created tower needs to be patched. If
FALSE, the tower doesn't need to be patched
PatchTowerAddress - an IPv4 representation of the address to be put
in the tower. The IPv4 address must be in network byte order
Return Value:
RPC_S_OK or RPC_S_* for error
--*/
{
I_Tower * Twr;
ept_entry_t *p;
switch (Type)
{
case EP_MAP:
Twr = (I_Tower *)(* Buffer);
Twr->Tower = NewTower(PSEP->Tower);
if (Twr->Tower == 0)
{
return(RPC_S_OUT_OF_MEMORY);
}
if (fPatchTower)
PatchTower(Twr->Tower, PatchTowerAddress);
*Buffer += sizeof(I_Tower);
break;
case EP_LOOKUP:
p = (ept_entry_t *)(*Buffer);
p->tower = NewTower(PSEP->Tower);
if (p->tower == 0)
{
return(RPC_S_OUT_OF_MEMORY);
}
if (fPatchTower)
PatchTower(p->tower, PatchTowerAddress);
memcpy( *Buffer, (char *)&Node->ObjUuid, sizeof(UUID) );
strcpy(p->annotation, Node->Annotation);
*Buffer += sizeof(ept_entry_t);
break;
default:
ASSERT(!"Unknown type");
break;
}
return(RPC_S_OK);
}
void
ept_cleanup_handle_t_rundown(
ept_cleanup_handle_t hEpCleanup
)
/*++
Routine Description:
This routine cleans up the entries registered by the process
associated with this context handle hEpCleanup.
Arguments:
hEpCleanup - The context handle for which the rundown is
being done.
Return Value:
None.
--*/
{
PIFOBJNode NodesListToDelete = NULL;
PIFOBJNode pIterator, DeleteMe, pPreviousNode;
PPSEPNode pTempPSEP, pDeletePSEP;
PEP_CLEANUP ProcessCtxt = (PEP_CLEANUP) hEpCleanup;
#ifdef DBG_DETAIL
PIFOBJNode pTemp, pLast;
#endif // DBG_DETAIL
if (ProcessCtxt == NULL)
{
return;
}
EnterSem();
ASSERT(IFObjList);
ASSERT(cTotalEpEntries > 0);
ASSERT(ProcessCtxt->EntryList);
ASSERT(ProcessCtxt->cEntries > 0);
ASSERT(ProcessCtxt->EntryList->OwnerOfList == ProcessCtxt);
ASSERT_PROCESS_CONTEXT_LIST_COUNT(ProcessCtxt, ProcessCtxt->cEntries);
#ifdef DBG_DETAIL
DbgPrint("RPCSS: Entered Cleanup Rundown for [%p] with (%d) entries\n",
hEpCleanup, ProcessCtxt->cEntries);
DbgPrint("RPCSS: Dump of IFOBJList\n");
pTemp = IFObjList;
pLast = IFObjList;
while (pTemp)
{
DbgPrint("RPCSS: \t\t[%p]\n", pTemp);
pLast = pTemp;
pTemp = pTemp->Next;
}
DbgPrint("RPCSS: --------------------\n");
while (pLast)
{
DbgPrint("RPCSS: \t\t\t[%p]\n", pLast);
pLast = pLast->Prev;
}
#endif // DBG_DETAIL
// Save the previous Node.
pPreviousNode = ProcessCtxt->EntryList->Prev;
pIterator = ProcessCtxt->EntryList;
while ((pIterator != NULL) && (pIterator->OwnerOfList == ProcessCtxt))
{
ProcessCtxt->cEntries--;
cTotalEpEntries--;
#ifdef DBG_DETAIL
DbgPrint("RPCSS: cTotalEpEntries-- [%p] (%d) - Cleanup\n", hEpCleanup, cTotalEpEntries);
#endif // DBG_DETAIL
DeleteMe = pIterator;
pIterator = pIterator->Next;
// Add to a list that will be deleted later.
DeleteMe->Next = NodesListToDelete;
NodesListToDelete = DeleteMe;
DeleteMe->Signature = FREE;
}
ASSERT(ProcessCtxt->cEntries == 0);
//
// Adjust the links
//
if (pPreviousNode)
{
// Adjust forward link
pPreviousNode->Next = pIterator;
}
else
{
ASSERT(ProcessCtxt->EntryList == IFObjList);
}
if (pIterator)
{
// Adjust backward link
pIterator->Prev = pPreviousNode;
}
//
// Empty the EP Mapper table, if necessary.
//
if (ProcessCtxt->EntryList == IFObjList)
{
if (pIterator)
{
ASSERT(cTotalEpEntries > 0);
// New Head for Ep Mapper list
IFObjList = pIterator;
}
else
{
ASSERT(cTotalEpEntries == 0);
// Memory for this node is already freed in the while loop above.
IFObjList = NULL;
}
}
else
{
ASSERT(cTotalEpEntries > 0);
}
LeaveSem();
//
// Free entities outside the lock.
//
FreeMem(ProcessCtxt);
while (NodesListToDelete != NULL)
{
DeleteMe = NodesListToDelete;
NodesListToDelete = NodesListToDelete->Next;
// Delete the PSEP list.
pTempPSEP = DeleteMe->PSEPlist;
while (pTempPSEP != NULL)
{
pDeletePSEP = pTempPSEP;
pTempPSEP = pTempPSEP->Next;
FreeMem(pDeletePSEP);
}
I_RpcFree(DeleteMe->pSID);
FreeMem(DeleteMe);
}
}
void
ept_insert(
handle_t h,
unsigned32 NumEntries,
ept_entry_t Entries[],
unsigned long Replace,
error_status *Status
)
/*++
Routine Description:
This function is no longer supported by EpMapper. RPC Runtime does not
call this function anymore. And, no one else should be...
--*/
{
if (Status == NULL)
RpcRaiseException(EPT_S_CANT_PERFORM_OP);
*Status = EPT_S_CANT_PERFORM_OP;
}
RPC_STATUS GetCurrentUserSid(
IN BOOL fImpersonating,
OUT PSID *ppSid
)
/*++
Routine Description:
Returns the SID of the thread if thread token could be queried, or the process.
It is the responsibility of the caller to free the SID.
Return Value:
RPC_S_OK on sucess
--*/
{
HANDLE hUserToken;
HANDLE hThread = GetCurrentThread(); // We don't need to close this handle.
DWORD dwStatus = 0;
DWORD dwSizeNeeded = 0;
TOKEN_USER *pTokenData;
BOOL b;
DWORD cbSid;
// First, try to get the access token from the thread, in case
// we are impersonating.
if (!hThread)
{
return RPC_S_OUT_OF_RESOURCES;
}
b = OpenThreadToken(hThread,
TOKEN_READ,
FALSE, // Use context of the thread...
&hUserToken);
// We could not get the thread's token
if (!b)
{
dwStatus = GetLastError();
// If we are getting an impersonation token we have to fail
// since retrieving the process token would be incorrect.
if (fImpersonating)
{
ASSERT(dwStatus != ERROR_NO_TOKEN);
return RPC_S_OUT_OF_RESOURCES;
}
if (dwStatus == ERROR_NO_TOKEN)
{
// Try to get the process' access token.
HANDLE hProcess = GetCurrentProcess(); // This never fails.
ASSERT(hProcess);
// Reset the status since we are trying again to get the token.
dwStatus = NO_ERROR;
b = OpenProcessToken(hProcess,
TOKEN_READ,
&hUserToken);
if (!b)
{
dwStatus = GetLastError();
}
}
}
// Both ways of getting the token failed.
if (dwStatus)
{
return RPC_S_OUT_OF_RESOURCES;
}
// We have a token.
ASSERT(hUserToken);
// Query for the size of user information.
b = GetTokenInformation( hUserToken,
TokenUser,
0,
0,
&dwSizeNeeded
);
// Query should have failed.
ASSERT(!b && (GetLastError() == ERROR_INSUFFICIENT_BUFFER));
// Allocate and retrieve the user info.
pTokenData = (TOKEN_USER*)_alloca(dwSizeNeeded);
if (!GetTokenInformation( hUserToken,
TokenUser,
pTokenData,
dwSizeNeeded,
&dwSizeNeeded ))
{
CloseHandle(hUserToken);
return RPC_S_OUT_OF_RESOURCES;
}
CloseHandle(hUserToken);
// Copy out the SID to be returned.
cbSid = GetLengthSid(pTokenData->User.Sid);
*ppSid = (PSID) I_RpcAllocate(cbSid);
if (*ppSid == NULL)
{
return RPC_S_OUT_OF_RESOURCES;
}
CopySid(cbSid, *ppSid, pTokenData->User.Sid);
// The caller will have to free the copy.
return RPC_S_OK;
}
void
ept_insert_ex(
IN handle_t h,
IN OUT ept_cleanup_handle_t *hEpCleanup,
IN unsigned32 NumEntries,
IN ept_entry_t Entries[],
IN unsigned long Replace,
OUT error_status *Status
)
/*++
Routine Description:
This is the exposed rpc interface routine that adds a series of
endpoints to the Endpoint Mapper database.
Arguments:
h - An explicit binding handle to the EP.
hEpCleanup - A context handle used to purge the Endpoint Mapper
database of stale entries.
NumEntries - Number of Entries to be added.
Entries - An array of ept_entry_t entries.
Replace - TRUE => Replace existing entries.
FALSE=> Just add.
Return Value:
RPC_S_OK - The endpoint was successfully deleted.
RPC_S_OUT_OF_MEMORY - There is no memory to perform the op.
EPT_S_CANT_PERFORM - Invalid entry.
--*/
{
ept_entry_t * Ep;
unsigned short i, j;
unsigned int TransType = 0x0;
unsigned long err = 0;
unsigned long Version;
unsigned char protseqid;
char *Protseq, *Endpoint;
RPC_IF_ID IfId;
PPSEPNode List = 0;
PPSEPNode pPSEPNode, TmpPsep, pTempPSEP, pDeletePSEP;
unsigned long cb;
twr_t * Tower;
BOOL bIFNodeFound = FALSE;
PIFOBJNode NodesListToDelete = NULL;
PIFOBJNode Node, NewNode, DeleteMe = NULL;
UUID * Object;
char * Annotation;
RPC_STATUS Err;
SECURITY_DESCRIPTOR SecurityDescriptor, * PSecurityDesc;
BOOL Bool;
// SID of the principal registering the endpoint.
PSID pSID;
if (Status == NULL)
RpcRaiseException(EPT_S_CANT_PERFORM_OP);
// Security callback for the local epmp interface ensures that
// the function may be called over lpc only.
//
// Create a temporary PSEP list from the Tower entries.
//
for (Ep = &Entries[0], i = 0; i < NumEntries; Ep++,i++)
{
err = TowerExplode(
Ep->tower,
&IfId,
NULL,
&Protseq,
&Endpoint,
0
);
if (err == RPC_S_OUT_OF_MEMORY)
break;
if (err)
{
err = RPC_S_OK;
continue;
}
Object = &Ep->object;
Annotation = (char *)&Ep->annotation;
Tower = Ep->tower;
cb = sizeof(PSEPNode) +
strlen(Protseq) +
strlen(Endpoint) +
2 + // for the 2 null terminators
Tower->tower_length +
sizeof(Tower->tower_length) +
4; // We need to align tower on DWORD
if ( (pPSEPNode = AllocMem(cb)) == NULL )
{
I_RpcFree(Protseq);
I_RpcFree(Endpoint);
err = RPC_S_OUT_OF_MEMORY;
break;
}
// Mark this protseq to start listening if needed.
protseqid = (unsigned char) GetProtseqIdAnsi(Protseq);
DelayedUseProtseq(protseqid);
//
// Add a node to the temporary PSEP list
//
memset(pPSEPNode, 0, cb);
pPSEPNode->Signature = PSEPSIGN;
pPSEPNode->Cb = cb;
// Protseq
//
// Protseq is located after the PPSEPNode structure in the block at address pPSEPNode
// allocated above. We created the block so that it would contain enough space for
// Protseq, Endpoint, and Tower so that we would not allocate them separately.
pPSEPNode->Protseq = (char *) (pPSEPNode + 1);
strcpy(pPSEPNode->Protseq, Protseq);
// Endpoint
//
// Similarly to Protseq, EP is located in the same heap block following the Protseq.
pPSEPNode->EP = pPSEPNode->Protseq + strlen(pPSEPNode->Protseq) + 1;
strcpy(pPSEPNode->EP, Endpoint);
// Tower. We add necessary pad so that Tower is aligned to a DWORD.
pPSEPNode->Tower = (twr_t PAPI *)(pPSEPNode->EP +
strlen(pPSEPNode->EP) + 1);
(char PAPI*)(pPSEPNode->Tower) += 4 - ((ULONG_PTR)
(pPSEPNode->Tower) & 3);
memcpy((char PAPI *)pPSEPNode->Tower,
Tower,
Tower->tower_length + sizeof(Tower->tower_length)
);
// Finally, add.
EnterSem();
EnLinkOnPSEPList(&List, pPSEPNode);
LeaveSem();
I_RpcFree(Protseq);
I_RpcFree(Endpoint);
}
if ((err == RPC_S_OUT_OF_MEMORY) || (List == 0))
{
*Status = err;
return;
}
CompleteDelayedUseProtseqs();
Version = VERSION(IfId.VersMajor, IfId.VersMinor);
// Get the SID of the caller to be included in the IFOBJ structure.
Err = RpcImpersonateClient(NULL);
if (Err != RPC_S_OK)
{
RpcRaiseException(Err);
}
Err = GetCurrentUserSid(TRUE, &pSID);
if (Err != RPC_S_OK)
{
Err = RpcRevertToSelf();
ASSERT(Err == RPC_S_OK);
RpcRaiseException(Err);
}
ASSERT(pSID != NULL);
Err = RpcRevertToSelf();
ASSERT(Err == RPC_S_OK);
//
// Find if a compatible Endpoint Mapper entry is already present.
//
if (*hEpCleanup != NULL)
{
//
// The requesting process has previously registered entries
// with the Endpoint Mapper.
//
ASSERT_PROCESS_CONTEXT_LIST_COUNT((PEP_CLEANUP)*hEpCleanup, ((PEP_CLEANUP)*hEpCleanup)->cEntries);
ASSERT(((PEP_CLEANUP)*hEpCleanup)->MagicVal == CLEANUP_MAGIC_VALUE);
ASSERT(((PEP_CLEANUP)*hEpCleanup)->cEntries != 0);
if ( (((PEP_CLEANUP)*hEpCleanup)->MagicVal != CLEANUP_MAGIC_VALUE)
|| (((PEP_CLEANUP)*hEpCleanup)->cEntries == 0))
{
*Status = EPT_S_CANT_PERFORM_OP;
I_RpcFree(pSID);
return;
}
EnterSem();
if (Replace == TRUE) // Common case
{
//
// If we find a compatible entry, we just replace its PSEP list
// with the temporary list that we just created.
//
Node = ((PEP_CLEANUP)*hEpCleanup)->EntryList;
while (Node != 0)
{
Node = FindIFOBJNode(
Node,
Object,
&IfId.Uuid,
Version,
pSID,
RPC_C_EP_MATCH_BY_BOTH,
I_RPC_C_VERS_UPTO_AND_COMPATIBLE,
SearchIFObjNode
);
if ((Node == 0) || (Node->OwnerOfList != *hEpCleanup))
break;
// Matching Endpoint Mapper entry found.
PurgeOldEntries(Node, List, FALSE);
if (Node->IFVersion == Version)
{
bIFNodeFound = TRUE;
// Seek to the end of Tmp and then Link
TmpPsep = List;
while (TmpPsep->Next != 0)
TmpPsep = TmpPsep->Next;
TmpPsep->Next = Node->PSEPlist;
Node->PSEPlist = List;
}
if (Node->PSEPlist == 0)
{
DeleteMe = Node;
Node = Node->Next;
err = UnLinkFromIFOBJList((PEP_CLEANUP)*hEpCleanup, DeleteMe);
ASSERT(err == RPC_S_OK);
// Add to a list that will be deleted later...
DeleteMe->Next = NodesListToDelete;
NodesListToDelete = DeleteMe;
DeleteMe->Signature = FREE;
}
else
{
Node = Node->Next;
}
} // while loop
}
else // (Replace != TRUE)
{
//
// If we find an entry with an exact match, we append
// the temporary PSEP list to the entry's PSEP list.
//
Node = ((PEP_CLEANUP)*hEpCleanup)->EntryList;
NewNode = FindIFOBJNode(
Node,
Object,
&IfId.Uuid,
Version,
pSID,
0,
0,
ExactMatch
);
if (NewNode && (NewNode->OwnerOfList == *hEpCleanup))
{
bIFNodeFound = TRUE;
PurgeOldEntries(NewNode, List, TRUE);
// Seek to the end of Tmp and then Link
TmpPsep = List;
while (TmpPsep->Next != 0)
TmpPsep = TmpPsep->Next;
TmpPsep->Next = NewNode->PSEPlist;
NewNode->PSEPlist = List;
}
} // if (Replace == TRUE)
LeaveSem();
} // if (*hpCleanup != NULL)
//
// Free the list outside the lock.
//
while (NodesListToDelete != NULL)
{
DeleteMe = NodesListToDelete;
NodesListToDelete = NodesListToDelete->Next;
// Delete the PSEP list.
pTempPSEP = DeleteMe->PSEPlist;
while (pTempPSEP != NULL)
{
pDeletePSEP = pTempPSEP;
pTempPSEP = pTempPSEP->Next;
FreeMem(pDeletePSEP);
}
FreeMem(DeleteMe);
}
if (bIFNodeFound == FALSE)
{
//
// One of the following is TRUE:
// a. The process is registering with EP Mapper for the first time.
// b. No compatible Ep entry was found.
//
//
// Allocate a new EP Mapper entry.
//
cb = sizeof(IFOBJNode);
// We will put Annotation in the same heap block after IFOBJNode.
cb += strlen(Annotation) + 1;
if ((NewNode = AllocMem(cb)) == NULL)
{
*Status = RPC_S_OUT_OF_MEMORY;
I_RpcFree(pSID);
return;
}
//
// Fill-in the new entry
//
memset(NewNode, 0, cb);
NewNode->Cb = cb;
NewNode->Signature = IFOBJSIGN;
NewNode->IFVersion = Version;
memcpy((char *)&NewNode->ObjUuid, (char *)Object, sizeof(UUID));
memcpy((char *)&NewNode->IFUuid, (char *)&IfId.Uuid, sizeof(UUID));
// Put Annotation in the IFOBJNode's heap block after the structure.
strcpy((NewNode->Annotation=(char *)(NewNode+1)), Annotation);
// The SID now migrated to the IFOBJNode.
NewNode->pSID = pSID;
if (IsNullUuid(Object))
NewNode->IFOBJid = MAKEGLOBALIFOBJID(MAXIFOBJID);
else
NewNode->IFOBJid = MAKEGLOBALIFOBJID(GlobalIFOBJid--);
//
// Create a new context for this process, if necessary
//
if (*hEpCleanup == NULL)
{
*hEpCleanup = AllocMem(sizeof(EP_CLEANUP));
if (*hEpCleanup == NULL)
{
FreeMem(NewNode);
I_RpcFree(NewNode->pSID);
*Status = RPC_S_OUT_OF_MEMORY;
return;
}
memset(*hEpCleanup, 0x0, sizeof(EP_CLEANUP));
((PEP_CLEANUP)*hEpCleanup)->MagicVal = CLEANUP_MAGIC_VALUE;
}
//
// Insert the new entry into the EP Mapper table.
//
EnterSem();
err = EnLinkOnIFOBJList((PEP_CLEANUP)*hEpCleanup, NewNode);
ASSERT(err == RPC_S_OK);
NewNode->PSEPlist = List;
LeaveSem();
}
*Status = err;
}
void
ept_delete(
handle_t h,
unsigned32 NumEntries,
ept_entry_t Entries[],
error_status *Status
)
/*++
Routine Description:
This function is no longer supported by EpMapper. RPC Runtime does not
call this function anymore. And, no one else should be...
--*/
{
if (Status == NULL)
RpcRaiseException(EPT_S_CANT_PERFORM_OP);
*Status = EPT_S_CANT_PERFORM_OP;
}
RPC_STATUS
ept_delete_ex_helper(
IN ept_cleanup_handle_t hEpCleanup,
IN UUID *Object,
IN UUID *Interface,
IN unsigned long IFVersion,
IN char PAPI * Protseq,
IN char PAPI * Endpoint
)
/*++
Routine Description:
This routine deletes an Endpoint registered with the EP Mapper
Arguments:
hEpCleanup - A context handle used to purge the Endpoint Mapper
database of stale entries.
Object - Object Uuid.
Interface - If Uuid
IFVersion - Version of the IF [Hi ushort=Major, Lo ushort=Minor]
Protseq - Protocol Sequence
Endpoint - Endpoint string
Notes:
a. This routine has to be called by holding a mutex.
Return Value:
RPC_S_OK - The endpoint was successfully deleted
EPT_S_NOT_REGISTERED - No matching entries were found
--*/
{
PIFOBJNode pNode;
PPSEPNode pPSEPNode = NULL;
unsigned long cb, err = 0;
PEP_T p;
PEP_CLEANUP ProcessCtx;
if (!Protseq || !Endpoint)
{
return(EPT_S_NOT_REGISTERED);
}
CheckInSem();
ProcessCtx = (PEP_CLEANUP)hEpCleanup;
if (ProcessCtx->EntryList == NULL)
return EPT_S_NOT_REGISTERED;
// Search without regard to the registrant's SID.
pNode = FindIFOBJNode(
ProcessCtx->EntryList,
Object,
Interface,
IFVersion,
NULL,
0L,
0L,
ExactMatch
);
if ((pNode != NULL) && (pNode->PSEPlist != NULL))
{
pPSEPNode = FindPSEP(
pNode->PSEPlist,
Protseq,
Endpoint,
0L,
MatchPSAndEP
);
}
if (pPSEPNode != NULL)
{
UnLinkFromPSEPList(&pNode->PSEPlist, pPSEPNode);
if (pNode->PSEPlist == NULL)
{
err = UnLinkFromIFOBJList((PEP_CLEANUP)hEpCleanup, pNode);
ASSERT(err == RPC_S_OK);
if (err != RPC_S_OK)
{
// Restore the PSEPList
EnLinkOnPSEPList(&pNode->PSEPlist, pPSEPNode);
return err;
}
pNode->Signature = FREE;
I_RpcFree(pNode->pSID);
FreeMem(pNode);
}
pPSEPNode->Signature = FREE;
FreeMem(pPSEPNode);
}
else
{
err = EPT_S_NOT_REGISTERED;
}
return(err);
}
void
ept_delete_ex(
IN handle_t h,
IN OUT ept_cleanup_handle_t *hEpCleanup,
IN unsigned32 NumEntries,
IN ept_entry_t Entries[],
OUT error_status *Status
)
/*++
Routine Description:
This routine deletes the specified Endpoints
Arguments:
BindingHandle - An explicit binding handle to the EP.
NumEntries - #of entries in the Bunffer that need to be deleted.
Entries[] - Buffer of #NumEntries of ept_entry_t structures
Return Value:
RPC_S_OK - The endpoint was successfully deleted
EPT_S_NOT_REGISTERED - No matching entries were found
--*/
{
ept_entry_t * Ep;
unsigned short i;
unsigned int TransType = 0x0;
RPC_STATUS err;
RPC_STATUS DeleteStatus;
unsigned long Version;
char *Protseq, *Endpoint;
RPC_IF_ID IfId;
RPC_TRANSFER_SYNTAX XferId;
if (Status == NULL)
RpcRaiseException(EPT_S_CANT_PERFORM_OP);
// Security callback for the local epmp interface ensures that
// the function may be called over lpc only.
if ( !( (*hEpCleanup)
&& (((PEP_CLEANUP)*hEpCleanup)->MagicVal == CLEANUP_MAGIC_VALUE)
&& (((PEP_CLEANUP)*hEpCleanup)->cEntries != 0)
)
)
{
//
// Cannot ASSERT here. This is possible. (ep1-26, ep2-3)
//
//ASSERT(*hEpCleanup);
//ASSERT(((PEP_CLEANUP)*hEpCleanup)->MagicVal == CLEANUP_MAGIC_VALUE);
//ASSERT(((PEP_CLEANUP)*hEpCleanup)->cEntries != 0);
*Status = EPT_S_CANT_PERFORM_OP;
return;
}
*Status = EPT_S_NOT_REGISTERED;
DeleteStatus = RPC_S_OK;
for (Ep = &Entries[0], i = 0; i < NumEntries; Ep++,i++)
{
err = TowerExplode(
Ep->tower,
&IfId,
&XferId,
&Protseq,
&Endpoint,
0
);
if (err == RPC_S_OUT_OF_MEMORY)
{
*Status = RPC_S_OUT_OF_MEMORY;
break;
}
if (err)
{
continue;
}
Version = VERSION(IfId.VersMajor, IfId.VersMinor);
EnterSem();
//
// NOTE:
//
// If even one call to ept_delete_ex_helper() fails, we want to return
// failure from ept_delete_ex(). This is different from the past where
// if one call succeeded, then the function returned success.
//
err = ept_delete_ex_helper(
*hEpCleanup,
&Ep->object,
&IfId.Uuid,
Version,
Protseq,
Endpoint
);
if (err)
{
// Save the last failure status.
DeleteStatus = err;
}
if (((PEP_CLEANUP)*hEpCleanup)->cEntries == 0)
{
//
// No entry left in this process's list. Time to zero out this
// process's context handle.
//
//ASSERT(((PEP_CLEANUP)*hEpCleanup)->EntryList == NULL);
FreeMem(*hEpCleanup);
*hEpCleanup = NULL;
}
LeaveSem();
if (Protseq)
I_RpcFree(Protseq);
if (Endpoint)
I_RpcFree(Endpoint);
}
if (err)
{
// RPC_S_OUT_OF_MEMORY OR the last call to
// ept_delete_ex_helper() failed.
*Status = err;
}
else
{
// RPC_S_OK OR one of the calls to ept_delete_ex_helper() (but
// not the last one) failed.
*Status = DeleteStatus;
}
}
void
ept_lookup(
handle_t hEpMapper,
unsigned32 InquiryType,
UUID * Object,
RPC_IF_ID * Ifid,
unsigned32 VersOptions,
ept_lookup_handle_t *LookupHandle,
unsigned32 MaxRequested,
unsigned32 *NumEntries,
ept_entry_t Entries[],
error_status *Status
)
/*++
Routine Description:
This routine returns upto MaxRequested, ept_entry(s) currently
registered with the Endpoint mapper based on the
Obj, Interface, Protocol sequence and filters VersOptions and
InqType
Arguments:
hEpMapper - An explicit binding handle to the EP.
InquiryType - Search Filter [Seach based on IF, Obj or Both]
Object - Object Uuid. specified by the client
Ifid - Interface Uuid spec. by the client.
InId - The If Specification [IF Uuid+IfVersion]
VersOptions - Search Filter based on Versions [Versins <, >, ==]
LookupHandle - A resume key - If NULL, search is started from the beginning
if non-null, represents an encoding from where the epmapper is
is supposed to start searching. It is an opaque value as far as the
as far as the client is concerned.
MaxRequested - Max number of entries requested by the client.
NumEntries - The actual number of entries returned by the mapper.
Entries - Buffer of ept_entries returned.
Return Value:
RPC_S_OUT_OF_MEMORY
RPC_S_OK - At least one matching entry is being returned.
EP_S_NOT_REGISTERED - No matching entries were found
EPT_S_CANT_PERFORM_OP - MaxRequested value exceed ep_max_lookup_results
--*/
{
unsigned long Version;
if (Status == NULL)
RpcRaiseException(EPT_S_CANT_PERFORM_OP);
if (Ifid == NULL)
{
Ifid = &LocalNullUuid;
}
else
{
// Multiple full pointers in one method might point to the same memory.
// We need to check for pointer values being the same in the manager routine
// because reading these is unsafe and may case read-AVs.
if ((void *)Ifid == (void *)Object)
{
RpcRaiseException(EPT_S_CANT_PERFORM_OP);
}
}
if (Object == NULL)
{
Object = (UUID *) &LocalNullUuid;
}
switch (VersOptions)
{
case RPC_C_VERS_ALL:
Version = 0;
break;
case RPC_C_VERS_COMPATIBLE:
case RPC_C_VERS_EXACT:
case RPC_C_VERS_UPTO:
Version = VERSION(Ifid->VersMajor, Ifid->VersMinor);
break;
case RPC_C_VERS_MAJOR_ONLY:
Version = VERSION(Ifid->VersMajor, 0);
break;
default:
break;
}
*Status = GetEntries(
Object,
&Ifid->Uuid,
Version,
NULL,
NULL,
LookupHandle,
(char *)Entries,
EP_LOOKUP,
MaxRequested,
NumEntries,
InquiryType,
VersOptions,
SearchIFObjNode
);
}
void
ept_map_auth(
handle_t h,
UUID *Obj OPTIONAL,
twr_p_t MapTower,
PISID pSID,
ept_lookup_handle_t *MapHandle,
unsigned32 MaxTowers,
unsigned32 *NumTowers,
twr_p_t *ITowers,
error_status *Status
)
/*++
Routine Description:
This routine returns a fully-resolved string binding, for a given
Obj, Interface, and Protocol sequence if an appropriate entry is
found. Else returns EP_S_NOT_REGISTERED.
Arguments:
h - An explicit binding handle to the EP.
Obj - Object Uuid specified by the client.
MapTower - The input tower containing the protseq to query.
pSID - The SID specified by the client. If non-NULL, only entries registered
by the principal with this SID will be returned. If NULL, any matching entry
will be returned without regard to the registering SID.
MapHandle - A resume key - If NULL, search is started from the beginning
if non-null, represents an encoding from where the epmapper is
supposed to start searching. It is an opaque value as far as the
client is concerned.
MaxTowers - Max number of entries requested by the client.
NumTowers - The actual number of entries returned by the mapper.
ITowers - The fully resolved bindings.
Return Value:
RPC_S_OUT_OF_MEMORY
RPC_S_OK
EP_S_NOT_REGISTERED
--*/
{
RPC_IF_ID Ifid;
RPC_TRANSFER_SYNTAX Xferid;
char *Protseq;
unsigned long Version;
char * String = 0;
if (Status == NULL)
RpcRaiseException(EPT_S_CANT_PERFORM_OP);
if (pSID != NULL && !IsValidSid(pSID))
RpcRaiseException(EPT_S_CANT_PERFORM_OP);
if (Obj == 0)
{
Obj = (UUID *) &LocalNullUuid;
}
else
{
// Multiple full pointers in one method might point to the same memory.
// We need to check for pointer values being the same in the manager routine
// because reading these is unsafe and may case read-AVs.
if ((void *)Obj == (void *)MapTower)
{
RpcRaiseException(EPT_S_CANT_PERFORM_OP);
}
}
*Status = TowerExplode(
MapTower,
&Ifid,
&Xferid,
&Protseq,
NULL,
0
);
if (*Status)
{
*NumTowers = 0;
return;
}
Version = VERSION(Ifid.VersMajor,Ifid.VersMinor);
if (memcmp((char *)&Ifid.Uuid, (char *)&MgmtIf, sizeof(UUID)) == 0)
{
if ((Obj == 0) || IsNullUuid(Obj))
{
*NumTowers = 0;
*Status = RPC_S_BINDING_INCOMPLETE;
}
else
{
*Status = GetEntries(
Obj,
&Ifid.Uuid,
Version,
Protseq,
pSID,
MapHandle,
(char *)ITowers,
EP_MAP,
MaxTowers,
NumTowers,
RPC_C_EP_MATCH_BY_OBJ,
RPC_C_VERS_ALL,
SearchIFObjNode
);
}
}
else
{
*Status = GetEntries(
Obj,
&Ifid.Uuid,
Version,
Protseq,
pSID,
MapHandle,
(char *)ITowers,
EP_MAP,
MaxTowers,
NumTowers,
0L,
0L,
WildCardMatch
);
}
if (Protseq)
I_RpcFree(Protseq);
}
void
ept_map(
handle_t h,
UUID *Obj OPTIONAL,
twr_p_t MapTower,
ept_lookup_handle_t *MapHandle,
unsigned32 MaxTowers,
unsigned32 *NumTowers,
twr_p_t *ITowers,
error_status *Status
)
/*++
Routine Description:
This routine returns a fully-resolved string binding, for a given
Obj, Interface, and Protocol sequence if an appropriate entry is
found. The funciton does not verify the SID of the registering principal.
If an entry is not found returns EP_S_NOT_REGISTERED.
Arguments:
Idenitcal to those of ept_map_auth
Return Value:
Idenitcal to those of ept_map_auth
--*/
{
ept_map_auth(h,
Obj,
MapTower,
NULL,
MapHandle,
MaxTowers,
NumTowers,
ITowers,
Status);
}
void
ept_inq_object(
handle_t BindingHandle,
UUID *Object,
error_status *status
)
/*++
Routine Description:
Not supported
Arguments:
BindingHandle - An explicit binding handle to the EP.
Object _ No idea whose UUID this is.
Return Value:
EPT_S_CANT_PERFORM_OP
--*/
{
if (status == NULL)
RpcRaiseException(EPT_S_CANT_PERFORM_OP);
*status = EPT_S_CANT_PERFORM_OP;
}
void
DeletePSEP(
PIFOBJNode Node,
char * Protseq,
char * Endpoint
)
{
PSEPNode *Psep, *Tmp;
if (Node == 0)
return;
Psep = Node->PSEPlist;
while (Psep != 0)
{
Psep = FindPSEP(
Psep,
Protseq,
Endpoint,
0L,
MatchPSAndEP
);
if (Psep != 0)
{
Tmp = Psep;
Psep = Psep->Next;
UnLinkFromPSEPList(&Node->PSEPlist, Tmp);
Tmp->Signature = FREE;
FreeMem(Tmp);
}
}
}
void
ept_mgmt_delete(
handle_t BindingHandle,
boolean32 ObjectSpecd,
UUID * Object,
twr_p_t Tower,
error_status *Error
)
/*++
Routine Description:
Not supported
Arguments:
BindingHandle - An explicit binding handle to the EP.
Object _ ObjUUid
Tower - Tower specifying the Endpoints to be deleted.
Return Value:
EPT_S_CANT_PERFORM_OP
--*/
{
if (Error == NULL)
RpcRaiseException(EPT_S_CANT_PERFORM_OP);
*Error = EP_S_CANT_PERFORM_OP;
}
void ept_lookup_handle_t_rundown (ept_lookup_handle_t h)
{
PSAVEDCONTEXT Context = (PSAVEDCONTEXT) h;
PIENTRY Entry;
unsigned long Type;
PIENTRY Tmp;
twr_t * Tower;
ASSERT (Context != 0);
if ( (PtrToUlong(Context)) == 0xFFFFFFFF)
return;
Type = Context->Type;
EnterSem();
Entry = (PIENTRY)Context->List;
while (Entry != 0)
{
switch (Type)
{
case EP_MAP:
Tower = ((PSAVEDTOWER)Entry)->Tower;
break;
case EP_LOOKUP:
Tower = ((PSAVED_EPT)Entry)->Tower;
break;
default:
ASSERT(!"Unknown Inquiry Type");
break;
}
MIDL_user_free(Tower);
Tmp = Entry;
Entry = Entry->Next;
FreeMem(Tmp);
}
// Now free The Context
UnLink((PIENTRY *)&GlobalContextList, (PIENTRY)Context);
LeaveSem();
FreeMem(Context);
}
void
ept_lookup_handle_free(
handle_t h,
ept_lookup_handle_t * ept_context_handle,
error_status * status
)
{
if ( (ept_context_handle != 0) && (*ept_context_handle != 0))
{
ept_lookup_handle_t_rundown( *ept_context_handle );
*ept_context_handle = 0;
}
*status = 0;
}
#define MAX(x,y) ((x) < (y)) ? (y) : (x)
#define MIN(x,y) ((x) > (y)) ? (y) : (x)
#ifdef DEBUGRPC
#define DEBUG_MIN(x,y) MIN((x),(y))
#else
#define DEBUG_MIN(x,y) MAX((x),(y))
#endif
error_status_t
OpenEndpointMapper(
IN handle_t hServer,
OUT HPROCESS *pProcessHandle
)
{
PROCESS *pProcess = MIDL_user_allocate(sizeof(PROCESS));
if (!pProcess)
{
*pProcessHandle = 0;
return(RPC_S_OUT_OF_MEMORY);
}
pProcess->MagicVal = PROCESS_MAGIC_VALUE;
pProcess->pPorts = 0;
*pProcessHandle = (PVOID)pProcess;
return(RPC_S_OK);
}
//
// Port Management stuff
//
//
// Port Management Globals
//
const RPC_CHAR *PortConfigKey = RPC_CONST_STRING("Software\\Microsoft\\Rpc\\Internet");
const RPC_CHAR *DefaultPortType = RPC_CONST_STRING("UseInternetPorts");
const RPC_CHAR *ExplictPortType = RPC_CONST_STRING("PortsInternetAvailable");
const RPC_CHAR *PortRanges = RPC_CONST_STRING("Ports");
CRITICAL_SECTION PortLock;
BOOL fValidConfiguration = FALSE;
BOOL fPortRestrictions = FALSE;
PORT_TYPE SystemDefaultPortType = 0;
IP_PORT *pFreeInternetPorts = 0;
IP_PORT *pFreeIntranetPorts = 0;
PORT_RANGE *InternetPorts = 0;
PORT_RANGE *IntranetPorts = 0;
//
// Port management APIs
//
RPC_STATUS
InitializeIpPortManager(
void
)
{
HKEY hkey;
RPC_STATUS status;
DWORD size, type, value;
RPC_CHAR *pstr;
PORT_RANGE *pSet;
PORT_RANGE *pLast;
PORT_RANGE *pCurrent;
PORT_RANGE *pComplement;
PORT_RANGE *pNew;
LONG min, max;
InitializeCriticalSectionAndSpinCount(&PortLock, PREALLOCATE_EVENT_MASK);
status = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
PortConfigKey,
0,
KEY_READ,
&hkey);
if (status != RPC_S_OK)
{
if (status != ERROR_FILE_NOT_FOUND)
{
#if DBG
PrintToDebugger("RPCSS: Unable to open port config key: %d\n", status);
#endif
}
ASSERT(status == ERROR_FILE_NOT_FOUND);
fValidConfiguration = TRUE;
return(RPC_S_OK);
}
size = sizeof(value);
status = RegQueryValueEx(hkey,
DefaultPortType,
0,
&type,
(PBYTE)&value,
&size);
if ( status != RPC_S_OK
|| type != REG_SZ
|| ( *(RPC_CHAR *)&value != 'Y'
&& *(RPC_CHAR *)&value != 'y'
&& *(RPC_CHAR *)&value != 'N'
&& *(RPC_CHAR *)&value != 'n') )
{
RegCloseKey(hkey);
ASSERT(fValidConfiguration == FALSE);
return(RPC_S_OK);
}
if ( *(RPC_CHAR *)&value == 'Y'
|| *(RPC_CHAR *)&value == 'y')
{
SystemDefaultPortType = PORT_INTERNET;
}
else
{
SystemDefaultPortType = PORT_INTRANET;
}
size = sizeof(value);
status = RegQueryValueEx(hkey,
ExplictPortType,
0,
&type,
(PBYTE)&value,
&size);
if ( status != RPC_S_OK
|| type != REG_SZ
|| ( *(RPC_CHAR *)&value != 'Y'
&& *(RPC_CHAR *)&value != 'y'
&& *(RPC_CHAR *)&value != 'N'
&& *(RPC_CHAR *)&value != 'n') )
{
RegCloseKey(hkey);
ASSERT(fValidConfiguration == FALSE);
return(RPC_S_OK);
}
if ( *(RPC_CHAR *)&value == 'Y'
|| *(RPC_CHAR *)&value == 'y')
{
value = PORT_INTERNET;
}
else
{
value = PORT_INTRANET;
}
size = DEBUG_MIN(1, 100);
do
{
ASSERT(size);
pstr = alloca(size);
ASSERT(pstr);
status = RegQueryValueEx(hkey,
PortRanges,
0,
&type,
(PBYTE)pstr,
&size);
}
while (status == ERROR_MORE_DATA);
RegCloseKey(hkey);
if ( status != RPC_S_OK
|| type != REG_MULTI_SZ)
{
ASSERT(fValidConfiguration == FALSE);
return(RPC_S_OK);
}
//
// The user is going to specify a range of ports in the registery
// with a flag indicating if these ports are internet or intranet.
//
// ie, 500-550
// 560
// 559
// 2000-2048
// 2029-2049
//
// Note that order (in the REG_MULTI_SZ) and overlapping sets
// are ok. We must handle creating a port range list for this
// array and for the complement BUT NOT INCLUDING <=1024 by default.
//
// completment set to above is:
//
// 1025-1999
// 2050-32767
//
#define MIN_PORT 1025 // Only important for complement sets.
#define MAX_PORT 65535
pSet = 0;
pLast = 0;
while(*pstr)
{
RPC_CHAR *t;
#ifdef UNICODE
min = wcstol(pstr, &t, 10);
#else
min = strtol(pstr, &t, 10);
#endif
if (min > MAX_PORT || min < 0)
{
status = RPC_S_INVALID_ARG;
break;
}
if ( *t != 0
#ifdef UNICODE
&& *t != L'-')
#else
&& *t != '-')
#endif
{
status = RPC_S_INVALID_ARG;
break;
}
if (*t == 0)
{
max = min;
}
else
{
#ifdef UNICODE
max = wcstol(t + 1, &t, 10);
#else
min = strtol(t + 1, &t, 10);
#endif
if (max > MAX_PORT || max < 0 || max < min)
{
status = RPC_S_INVALID_ARG;
break;
}
}
ASSERT(min <= max);
// Ok, got some ports, allocate a structure for them..
pNew = MIDL_user_allocate(sizeof(PORT_RANGE));
if (0 == pNew)
{
status = RPC_S_OUT_OF_MEMORY;
break;
}
pNew->pNext = 0;
pNew->Min = (unsigned short) min;
pNew->Max = (unsigned short) max;
// We can to maintain the set of ranges in order. As we insert
// we'll fix any ranges which overlap.
pCurrent = pSet;
pLast = 0;
for (;;)
{
if (0 == pSet)
{
pSet = pNew;
break;
}
if ( pNew->Min <= (pCurrent->Max + 1)
&& pNew->Max >= (pCurrent->Min - 1) )
{
// The ranges overlap or touch. We'll merge them now..
pCurrent->Min = MIN(pNew->Min, pCurrent->Min);
pCurrent->Max = MAX(pCurrent->Max, pNew->Max);
MIDL_user_free(pNew);
// Since the new larger range may overlap another existing
// range we just insert the larger range as if it was new...
pNew = pCurrent;
// Take current out of the list.
if (pLast)
{
pLast->pNext = pCurrent->pNext;
}
if (pSet == pNew)
{
pSet = pSet->pNext;
}
// Restart
pCurrent = pSet;
pLast = 0;
continue;
}
if (pNew->Min < pCurrent->Min)
{
// Found the spot
if (pLast)
{
pLast->pNext = pNew;
pNew->pNext = pCurrent;
}
else
{
ASSERT(pCurrent == pSet);
pNew->pNext = pCurrent;
pSet = pNew;
}
break;
}
// Continue the search
pLast = pCurrent;
pCurrent = pCurrent->pNext;
if (0 == pCurrent)
{
// Reached the end of the list, insert it here.
pLast->pNext = pNew;
ASSERT(pNew->pNext == 0);
break;
}
}
ASSERT(pSet);
// Advance to the next string of the final null.
pstr = RpcpCharacter(pstr, 0) + 1;
}
if (pSet == 0)
{
status = RPC_S_INVALID_ARG;
}
if (value == PORT_INTERNET)
{
InternetPorts = pSet;
}
else
{
IntranetPorts = pSet;
}
if (status == RPC_S_OK)
{
// We've constructed the set of ports in the registry,
// now we need to compute the complement set.
pComplement = 0;
pCurrent = 0;
min = MIN_PORT;
while(pSet)
{
if (min < pSet->Min)
{
max = pSet->Min - 1;
ASSERT(max >= min);
pNew = MIDL_user_allocate(sizeof(PORT_RANGE));
if (0 == pNew)
{
status = RPC_S_OUT_OF_MEMORY;
break;
}
pNew->pNext = 0;
pNew->Min = (unsigned short) min;
pNew->Max = (unsigned short) max;
if (pComplement == 0)
{
pComplement = pCurrent = pNew;
}
else
{
ASSERT(pCurrent);
pCurrent->pNext = pNew;
pCurrent = pNew;
}
}
min = MAX(MIN_PORT, pSet->Max + 1);
pSet = pSet->pNext;
}
if (status == RPC_S_OK && min < MAX_PORT)
{
// Final port in orginal set less then max, allocate final
// range for the set complement.
pNew = MIDL_user_allocate(sizeof(PORT_RANGE));
if (0 != pNew)
{
pNew->Min = (unsigned short) min;
pNew->Max = MAX_PORT;
pNew->pNext = 0;
if (pCurrent)
{
pCurrent->pNext = pNew;
}
else
{
ASSERT(min == MIN_PORT);
pComplement = pNew;
}
}
else
{
status = RPC_S_OUT_OF_MEMORY;
}
}
// Even if we failed assign the pointer, it's either
// null or needs to be freed.
if (value == PORT_INTERNET)
{
ASSERT(IntranetPorts == 0);
IntranetPorts = pComplement;
}
else
{
ASSERT(InternetPorts == 0);
InternetPorts = pComplement;
}
}
if (status != RPC_S_OK)
{
ASSERT(fValidConfiguration == FALSE);
while(InternetPorts)
{
PORT_RANGE *pT = InternetPorts;
InternetPorts = InternetPorts->pNext;
MIDL_user_free(pT);
}
while(IntranetPorts)
{
PORT_RANGE *pT = IntranetPorts;
IntranetPorts = IntranetPorts->pNext;
MIDL_user_free(pT);
}
return(RPC_S_OK);
}
fValidConfiguration = TRUE;
fPortRestrictions = TRUE;
return(RPC_S_OK);
}
BOOL
AllocatePort(
OUT IP_PORT **ppPort,
IN OUT IP_PORT **ppPortFreeList,
IN PORT_RANGE *pPortList
)
/*++
Routine Description:
Allocates a port object for a specific process. It first tries
to use any ports in the free list. If there's nothing in the
port this then it tries to find a free port in the PortList
which is one of the sets computed during startup.
Arguments:
ppPort - Will contain the allocated port object if successful.
ppPortFreeList - Pointer to the head of the free list associated
with this type of port. Maybe modified during this call.
pPortList - Port ranges associated with this type of port.
Return Value:
TRUE - Port allocated
FALSE - Port not allocated
--*/
{
IP_PORT *pPort = 0;
// First see if there is free port to reuse.
if (*ppPortFreeList)
{
EnterCriticalSection(&PortLock);
if (*ppPortFreeList)
{
pPort = *ppPortFreeList;
*ppPortFreeList = pPort->pNext;
pPort->pNext = 0;
}
LeaveCriticalSection(&PortLock);
}
if (pPort == 0)
{
// No port in the free list, try to allocate one
// Assume we'll find a free port..
pPort = MIDL_user_allocate(sizeof(IP_PORT));
if (0 != pPort)
{
pPort->pNext = 0;
EnterCriticalSection(&PortLock);
while ( pPortList
&& pPortList->Min > pPortList->Max)
{
pPortList = pPortList->pNext;
}
if (pPortList)
{
ASSERT(pPortList->Min <= pPortList->Max);
pPort->Port = pPortList->Min;
pPortList->Min++;
// We could remove empty ranges from the list.
}
LeaveCriticalSection(&PortLock);
if (0 == pPortList)
{
MIDL_user_free(pPort);
pPort = 0;
#ifdef DEBUGRPC
DbgPrint("RPC: Out of reserved ports\n");
#endif
}
}
}
// REVIEW: Post SUR we should look at adding events for
// allocation and failure to allocate IP ports
*ppPort = pPort;
return(pPort != 0);
}
error_status_t
AllocateReservedIPPort(
IN HPROCESS hProcess,
IN PORT_TYPE PortType,
OUT long *pAllocationStatus,
OUT unsigned short *pAllocatedPort
)
/*++
Routine Description:
Remote manager for RPC runtime to call locally to allocate
a local port. The call and process parameters must be valid
and called only locally. Based on the PortType paramet a
IP port maybe allocated for the calling process. The
allocationstatus contains the result of the port allocation
step.
Arguments:
hProcess - Valid process context handle allocated with
a call to OpenEndpointMapper.
PortType - One of
PORT_INTERNET
PORT_INTRANET
PORT_DEFAULT
Used to determine which port range to allocate from.
pAllocationStatus -
RPC_S_OK - successfully allocated a port.
RPC_S_OUT_OF_RESOURES - no ports available.
pAllocatePort - If allocation status is RPC_S_OK then
this contains the value of the port allocated.
If zero it means that there are no port restrictions
and any port maybe used.
Return Value:
RPC_S_OK
RPC_S_INVALID_ARG - configuration error or PortType out of range.
RPC_S_ACCESS_ DENIED - not called locally.
--*/
{
PROCESS *pProcess = (PROCESS *)hProcess;
IP_PORT *pPort;
BOOL b;
*pAllocatedPort = 0;
*pAllocationStatus = RPC_S_OK;
ASSERT(pProcess);
if (!fValidConfiguration)
{
return(RPC_S_INVALID_ARG);
}
// Security callback for the local epmp interface ensures that
// the function may be called over lpc only.
if ( (0 == pProcess) || (pProcess->MagicVal != PROCESS_MAGIC_VALUE ) )
{
return(RPC_S_ACCESS_DENIED);
}
if (PortType > PORT_DEFAULT || PortType < PORT_INTERNET)
{
return(RPC_S_INVALID_ARG);
}
if (fPortRestrictions == FALSE)
{
// No port restrictions on this machine, just use zero.
// This is the common case.
ASSERT(*pAllocatedPort == 0);
ASSERT(*pAllocationStatus == 0);
return(RPC_S_OK);
}
// Need to actually allocate a unique port for this process.
if (PortType == PORT_DEFAULT)
{
// Allocate using default policy
PortType = SystemDefaultPortType;
}
ASSERT(PortType == PORT_INTERNET || PortType == PORT_INTRANET);
pPort = 0;
if (PortType == PORT_INTERNET)
{
b = AllocatePort(&pPort,
&pFreeInternetPorts,
InternetPorts
);
}
else
{
b = AllocatePort(&pPort,
&pFreeIntranetPorts,
IntranetPorts);
}
if (!b)
{
ASSERT(pPort == 0);
// REVIEW: Do we want a unique error code if no ports
// are available?
*pAllocationStatus = RPC_S_OUT_OF_RESOURCES;
return(RPC_S_OK);
}
ASSERT(pPort);
ASSERT(pPort->pNext == 0);
pPort->Type = (unsigned short) PortType;
pPort->pNext = pProcess->pPorts;
pProcess->pPorts = pPort;
*pAllocatedPort = pPort->Port;
ASSERT(*pAllocationStatus == RPC_S_OK);
return(RPC_S_OK);
}
void
HPROCESS_rundown(
HPROCESS hProcess
)
{
PROCESS *pProcess = (PROCESS *)hProcess;
IP_PORT *pCurrent;
IP_PORT *pSave;
ASSERT(pProcess);
ASSERT(pProcess->MagicVal == PROCESS_MAGIC_VALUE);
pCurrent = pProcess->pPorts;
if (pCurrent)
{
EnterCriticalSection(&PortLock);
do
{
pSave = pCurrent->pNext;
if (pCurrent->Type == PORT_INTERNET)
{
pCurrent->pNext = pFreeInternetPorts;
pFreeInternetPorts = pCurrent;
}
else
{
ASSERT(pCurrent->Type == PORT_INTRANET);
pCurrent->pNext = pFreeIntranetPorts;
pFreeIntranetPorts = pCurrent;
}
pCurrent = pSave;
}
while(pCurrent);
LeaveCriticalSection(&PortLock);
}
MIDL_user_free(pProcess);
return;
}
RPC_STATUS RPC_ENTRY
LocalEpmpSecurityCallback (
IN RPC_IF_HANDLE InterfaceUuid,
IN void *Context
)
/*++
Routine Description:
Security callback for the localepmp interface.
The interface may only be called by local clients.
For local protseqs we will return RPC_S_OK and RPC_S_ACCESS_DENIED
otherwise.
Arguments:
InterfaceUuid - Interface for which the callback is being issued.
Context - The client binding handle.
Return Value:
RPC_S_OK - the client is calling over lrpc
RPC_S_ACCESS_DENIED - not called over lrpc
--*/
{
RPC_STATUS Status;
unsigned int TransportType;
Status = I_RpcBindingInqTransportType(Context, &TransportType);
ASSERT(Status == RPC_S_OK);
if (Status != RPC_S_OK || TransportType != TRANSPORT_TYPE_LPC)
{
return(RPC_S_ACCESS_DENIED);
}
return RPC_S_OK;
}